Struct spectrusty_core::clock::VFrameTs

pub struct VFrameTs<V> {
    pub ts: VideoTs,
    /* private fields */
}

A VideoTs timestamp wrapper with a constraint to the V: VideoFrame, implementing methods and traits for timestamp calculations.

Fields

ts: VideoTs

The current value of the timestamp.

Implementations

impl<V: VideoFrame> VFrameTs<V>

pub const EOF: VFrameTs<V> = _

The end-of-frame timestamp, equal to the total number of T-states per frame.

pub fn new(vc: Ts, hc: Ts) -> Self

Constructs a new VFrameTs from the given vertical and horizontal counter values.

Note: The returned VFrameTs is not normalized.

Examples found in repository

src/clock/ops.rs (line 118)

    fn saturating_add(self, other: Self) -> Self {
        let VideoTs { vc, hc } = self.ts;
        let vc = vc.saturating_add(other.vc);
        let hc = hc + other.hc;
        VFrameTs::new(vc, hc).saturating_normalized()
    }
    /// # Panics
    /// May panic if `self` or `other` hasn't been normalized.
    fn saturating_sub(self, other: Self) -> Self {
        let VideoTs { vc, hc } = self.ts;
        let vc = vc.saturating_sub(other.vc);
        let hc = hc - other.hc;
        VFrameTs::new(vc, hc).saturating_normalized()
    }
}

impl<V: VideoFrame> Add<FTs> for VFrameTs<V> {
    type Output = Self;
    /// Returns a normalized video timestamp after adding `delta` T-states.
    ///
    /// # Panics
    /// Panics when normalized timestamp after addition leads to an overflow of the capacity of [VideoTs].
    #[inline]
    #[allow(clippy::suspicious_arithmetic_impl)]
    fn add(self, delta: FTs) -> Self {
        let VideoTs { vc, hc } = self.ts;
        let dvc: Ts = (delta / V::HTS_COUNT as FTs).try_into().expect("absolute delta FTs is too large");
        let dhc = (delta % V::HTS_COUNT as FTs) as Ts;
        VFrameTs::new(vc + dvc, hc + dhc).normalized()
    }
}

impl<V: VideoFrame> AddAssign<FTs> for VFrameTs<V> {
    #[inline(always)]
    fn add_assign(&mut self, delta: FTs) {
        *self = *self + delta
    }
}

impl<V: VideoFrame> Sub<FTs> for VFrameTs<V> {
    type Output = Self;
    /// Returns a normalized video timestamp after subtracting `delta` T-states.
    ///
    /// # Panics
    /// Panics when normalized timestamp after addition leads to an overflow of the capacity of [VideoTs].
    #[inline]
    #[allow(clippy::suspicious_arithmetic_impl)]
    fn sub(self, delta: FTs) -> Self {
        let VideoTs { vc, hc } = self.ts;
        let dvc: Ts = (delta / V::HTS_COUNT as FTs).try_into().expect("delta too large");
        let dhc = (delta % V::HTS_COUNT as FTs) as Ts;
        VFrameTs::new(vc - dvc, hc - dhc).normalized()
    }
}

impl<V: VideoFrame> SubAssign<FTs> for VFrameTs<V> {
    #[inline(always)]
    fn sub_assign(&mut self, delta: FTs) {
        *self = *self - delta
    }
}

impl<V: VideoFrame> Add<u32> for VFrameTs<V> {
    type Output = Self;
    /// Returns a normalized video timestamp after adding a `delta` T-state count.
    ///
    /// # Panics
    /// Panics when normalized timestamp after addition leads to an overflow of the capacity of [VideoTs].
    #[inline]
    #[allow(clippy::suspicious_arithmetic_impl)]
    fn add(self, delta: u32) -> Self {
        let VideoTs { vc, hc } = self.ts;
        let dvc = (delta / V::HTS_COUNT as u32).try_into().expect("delta too large");
        let dhc = (delta % V::HTS_COUNT as u32) as Ts;
        let vc = vc.checked_add(dvc).expect("delta too large");
        VFrameTs::new(vc, hc + dhc).normalized()
    }
}

impl<V: VideoFrame> AddAssign<u32> for VFrameTs<V> {
    #[inline(always)]
    fn add_assign(&mut self, delta: u32) {
        *self = *self + delta
    }
}

impl<V: VideoFrame> Sub<u32> for VFrameTs<V> {
    type Output = Self;
    /// Returns a normalized video timestamp after adding a `delta` T-state count.
    ///
    /// # Panics
    /// Panics when normalized timestamp after addition leads to an overflow of the capacity of [VideoTs].
    #[inline]
    #[allow(clippy::suspicious_arithmetic_impl)]
    fn sub(self, delta: u32) -> Self {
        let VideoTs { vc, hc } = self.ts;
        let dvc = (delta / V::HTS_COUNT as u32).try_into().expect("delta too large");
        let dhc = (delta % V::HTS_COUNT as u32) as Ts;
        let vc = vc.checked_sub(dvc).expect("delta too large");
        VFrameTs::new(vc, hc - dhc).normalized()
    }

src/clock.rs (line 130)

    pub fn normalized(self) -> Self {
        let VideoTs { mut vc, mut hc } = self.ts;
        if hc < V::HTS_RANGE.start || hc >= V::HTS_RANGE.end {
            let fhc: FTs = hc as FTs - if hc < 0 {
                V::HTS_RANGE.end
            }
            else {
                V::HTS_RANGE.start
            } as FTs;
            vc = vc.checked_add((fhc / V::HTS_COUNT as FTs) as Ts)
                   .expect("video timestamp overflow");
            hc = fhc.rem_euclid(V::HTS_COUNT as FTs) as Ts + V::HTS_RANGE.start;
        }
        VFrameTs::new(vc, hc)
    }
    /// Returns a video timestamp with a horizontal counter within the allowed range and a scan line
    /// counter adjusted accordingly. Saturates at [VFrameTs::min_value] or [VFrameTs::max_value].
    #[inline]
    pub fn saturating_normalized(self) -> Self {
        let VideoTs { mut vc, mut hc } = self.ts;
        if hc < V::HTS_RANGE.start || hc >= V::HTS_RANGE.end {
            let fhc: FTs = hc as FTs - if hc < 0 {
                V::HTS_RANGE.end
            }
            else {
                V::HTS_RANGE.start
            } as FTs;
            let dvc = (fhc / V::HTS_COUNT as FTs) as Ts;
            if let Some(vc1) = vc.checked_add(dvc) {
                vc = vc1;
                hc = fhc.rem_euclid(V::HTS_COUNT as FTs) as Ts + V::HTS_RANGE.start;
            }
            else {
                return if dvc < 0 { Self::min_value() } else { Self::max_value() };
            }
        }
        VFrameTs::new(vc, hc)
    }
    /// Returns the largest value that can be represented by a normalized timestamp.
    #[inline(always)]
    pub fn max_value() -> Self {
        VFrameTs { ts: VideoTs { vc: Ts::max_value(), hc: V::HTS_RANGE.end - 1 },
                   _vframe: PhantomData }
    }
    /// Returns the smallest value that can be represented by a normalized timestamp.
    #[inline(always)]
    pub fn min_value() -> Self {
        VFrameTs { ts: VideoTs { vc: Ts::min_value(), hc: V::HTS_RANGE.start },
                   _vframe: PhantomData }
    }
    /// Returns `true` if the counter value is past or near the end of a frame. Otherwise returns `false`.
    ///
    /// Specifically, the condition is met if the vertical counter is equal to or greater than [VideoFrame::VSL_COUNT].
    #[inline(always)]
    pub fn is_eof(self) -> bool {
        self.vc >= V::VSL_COUNT
    }
    /// Ensures the vertical counter is in the range: `(-VSL_COUNT, VSL_COUNT)` by calculating
    /// a remainder of the division of the vertical counter by [VideoFrame::VSL_COUNT].
    #[inline(always)]
    pub fn wrap_frame(&mut self) {
        self.ts.vc %= V::VSL_COUNT
    }
    /// Returns a video timestamp after subtracting the total number of frame video scanlines
    /// from the scan line counter.
    #[inline]
    pub fn saturating_sub_frame(self) -> Self {
        let VideoTs { vc, hc } = self.ts;
        let vc = vc.saturating_sub(V::VSL_COUNT);
        VFrameTs::new(vc, hc)
    }
    /// Returns a normalized timestamp from the given number of T-states.
    ///
    /// # Panics
    /// Panics when the given `ts` overflows the capacity of the timestamp.
    #[inline]
    pub fn from_tstates(ts: FTs) -> Self {
        Self::try_from_tstates(ts).expect("video timestamp overflow")
    }
    /// On success returns a normalized timestamp from the given number of T-states.
    ///
    /// Returns `None` when the given `ts` overflows the capacity of the timestamp.
    #[inline]
    pub fn try_from_tstates(ts: FTs) -> Option<Self> {
        let mut vc = match (ts / V::HTS_COUNT as FTs).try_into() {
            Ok(vc) => vc,
            Err(..) => return None
        };
        let mut hc: Ts = (ts % V::HTS_COUNT as FTs) as Ts;
        if hc >= V::HTS_RANGE.end {
            hc -= V::HTS_COUNT;
            vc += 1;
        }
        else if hc < V::HTS_RANGE.start {
            hc += V::HTS_COUNT;
            vc -= 1;
        }
        Some(VFrameTs::new(vc, hc))
    }
    /// Converts the timestamp to FTs.
    #[inline]
    pub fn into_tstates(self) -> FTs {
        let VideoTs { vc, hc } = self.ts;
        V::vc_hc_to_tstates(vc, hc)
    }
    /// Returns a tuple with an adjusted frame counter and with the frame-normalized timestamp as
    /// the number of T-states measured from the start of the frame.
    ///
    /// The frame starts when the horizontal and vertical counter are both 0.
    ///
    /// The returned timestamp value is in the range [0, [VideoFrame::FRAME_TSTATES_COUNT]).
    #[inline]
    pub fn into_frame_tstates(self, frames: u64) -> (u64, FTs) {
        let ts = TimestampOps::into_tstates(self);
        let frmdlt = ts / V::FRAME_TSTATES_COUNT;
        let ufrmdlt = if ts < 0 { frmdlt - 1 } else { frmdlt } as u64;
        let frames = frames.wrapping_add(ufrmdlt);
        let ts = ts.rem_euclid(V::FRAME_TSTATES_COUNT);
        (frames, ts)
    }

    #[inline]
    fn set_hc_after_small_increment(&mut self, mut hc: Ts) {
        if hc >= V::HTS_RANGE.end {
            hc -= V::HTS_COUNT as Ts;
            self.ts.vc += 1;
        }
        self.ts.hc = hc;
    }
}

impl<V, C> VFrameTsCounter<V, C>
    where V: VideoFrame,
          C: MemoryContention
{
    /// Constructs a new and normalized `VFrameTsCounter` from the given vertical and horizontal counter values.
    ///
    /// # Panics
    /// Panics when the given values lead to an overflow of the capacity of [VideoTs].
    #[inline]
    pub fn new(vc: Ts, hc: Ts, contention: C) -> Self {
        let vts = VFrameTs::new(vc, hc).normalized();
        VFrameTsCounter { vts, contention }
    }

pub fn is_normalized(self) -> bool

Returns true if a video timestamp is normalized. Otherwise returns false.

pub fn normalized(self) -> Self

Normalizes self with a horizontal counter within the allowed range and a scan line counter adjusted accordingly.

Panics

Panics when an attempt to normalize leads to an overflow of the capacity of VideoTs.

Examples found in repository

src/clock.rs (line 258)

    pub fn new(vc: Ts, hc: Ts, contention: C) -> Self {
        let vts = VFrameTs::new(vc, hc).normalized();
        VFrameTsCounter { vts, contention }
    }
    /// Builds a normalized [VFrameTsCounter] from the given count of T-states.
    ///
    /// # Panics
    ///
    /// Panics when the given `ts` overflows the capacity of [VideoTs].
    #[inline]
    pub fn from_tstates(ts: FTs, contention: C) -> Self {
        let vts = TimestampOps::from_tstates(ts);
        VFrameTsCounter { vts, contention }
    }
    /// Builds a normalized [VFrameTsCounter] from the given count of T-states.
    ///
    /// # Panics
    ///
    /// Panics when the given `ts` overflows the capacity of [VideoTs].
    #[inline]
    pub fn from_video_ts(vts: VideoTs, contention: C) -> Self {
        let vts = VFrameTs::from(vts).normalized();
        VFrameTsCounter { vts, contention }
    }
    /// Builds a normalized [VFrameTsCounter] from the given count of T-states.
    ///
    /// # Panics
    ///
    /// Panics when the given `ts` overflows the capacity of [VideoTs].
    #[inline]
    pub fn from_vframe_ts(vfts: VFrameTs<V>, contention: C) -> Self {
        let vts = vfts.normalized();
        VFrameTsCounter { vts, contention }
    }

src/clock/ops.rs (line 142)

    fn add(self, delta: FTs) -> Self {
        let VideoTs { vc, hc } = self.ts;
        let dvc: Ts = (delta / V::HTS_COUNT as FTs).try_into().expect("absolute delta FTs is too large");
        let dhc = (delta % V::HTS_COUNT as FTs) as Ts;
        VFrameTs::new(vc + dvc, hc + dhc).normalized()
    }
}

impl<V: VideoFrame> AddAssign<FTs> for VFrameTs<V> {
    #[inline(always)]
    fn add_assign(&mut self, delta: FTs) {
        *self = *self + delta
    }
}

impl<V: VideoFrame> Sub<FTs> for VFrameTs<V> {
    type Output = Self;
    /// Returns a normalized video timestamp after subtracting `delta` T-states.
    ///
    /// # Panics
    /// Panics when normalized timestamp after addition leads to an overflow of the capacity of [VideoTs].
    #[inline]
    #[allow(clippy::suspicious_arithmetic_impl)]
    fn sub(self, delta: FTs) -> Self {
        let VideoTs { vc, hc } = self.ts;
        let dvc: Ts = (delta / V::HTS_COUNT as FTs).try_into().expect("delta too large");
        let dhc = (delta % V::HTS_COUNT as FTs) as Ts;
        VFrameTs::new(vc - dvc, hc - dhc).normalized()
    }
}

impl<V: VideoFrame> SubAssign<FTs> for VFrameTs<V> {
    #[inline(always)]
    fn sub_assign(&mut self, delta: FTs) {
        *self = *self - delta
    }
}

impl<V: VideoFrame> Add<u32> for VFrameTs<V> {
    type Output = Self;
    /// Returns a normalized video timestamp after adding a `delta` T-state count.
    ///
    /// # Panics
    /// Panics when normalized timestamp after addition leads to an overflow of the capacity of [VideoTs].
    #[inline]
    #[allow(clippy::suspicious_arithmetic_impl)]
    fn add(self, delta: u32) -> Self {
        let VideoTs { vc, hc } = self.ts;
        let dvc = (delta / V::HTS_COUNT as u32).try_into().expect("delta too large");
        let dhc = (delta % V::HTS_COUNT as u32) as Ts;
        let vc = vc.checked_add(dvc).expect("delta too large");
        VFrameTs::new(vc, hc + dhc).normalized()
    }
}

impl<V: VideoFrame> AddAssign<u32> for VFrameTs<V> {
    #[inline(always)]
    fn add_assign(&mut self, delta: u32) {
        *self = *self + delta
    }
}

impl<V: VideoFrame> Sub<u32> for VFrameTs<V> {
    type Output = Self;
    /// Returns a normalized video timestamp after adding a `delta` T-state count.
    ///
    /// # Panics
    /// Panics when normalized timestamp after addition leads to an overflow of the capacity of [VideoTs].
    #[inline]
    #[allow(clippy::suspicious_arithmetic_impl)]
    fn sub(self, delta: u32) -> Self {
        let VideoTs { vc, hc } = self.ts;
        let dvc = (delta / V::HTS_COUNT as u32).try_into().expect("delta too large");
        let dhc = (delta % V::HTS_COUNT as u32) as Ts;
        let vc = vc.checked_sub(dvc).expect("delta too large");
        VFrameTs::new(vc, hc - dhc).normalized()
    }

pub fn saturating_normalized(self) -> Self

Returns a video timestamp with a horizontal counter within the allowed range and a scan line counter adjusted accordingly. Saturates at VFrameTs::min_value or VFrameTs::max_value.

Examples found in repository

src/clock/ops.rs (line 118)

    fn saturating_add(self, other: Self) -> Self {
        let VideoTs { vc, hc } = self.ts;
        let vc = vc.saturating_add(other.vc);
        let hc = hc + other.hc;
        VFrameTs::new(vc, hc).saturating_normalized()
    }
    /// # Panics
    /// May panic if `self` or `other` hasn't been normalized.
    fn saturating_sub(self, other: Self) -> Self {
        let VideoTs { vc, hc } = self.ts;
        let vc = vc.saturating_sub(other.vc);
        let hc = hc - other.hc;
        VFrameTs::new(vc, hc).saturating_normalized()
    }

pub fn max_value() -> Self

Returns the largest value that can be represented by a normalized timestamp.

Examples found in repository

src/clock/ops.rs (line 101)

    fn max_value() -> Self {
        VFrameTs::max_value()
    }

src/clock.rs (line 150)

    pub fn saturating_normalized(self) -> Self {
        let VideoTs { mut vc, mut hc } = self.ts;
        if hc < V::HTS_RANGE.start || hc >= V::HTS_RANGE.end {
            let fhc: FTs = hc as FTs - if hc < 0 {
                V::HTS_RANGE.end
            }
            else {
                V::HTS_RANGE.start
            } as FTs;
            let dvc = (fhc / V::HTS_COUNT as FTs) as Ts;
            if let Some(vc1) = vc.checked_add(dvc) {
                vc = vc1;
                hc = fhc.rem_euclid(V::HTS_COUNT as FTs) as Ts + V::HTS_RANGE.start;
            }
            else {
                return if dvc < 0 { Self::min_value() } else { Self::max_value() };
            }
        }
        VFrameTs::new(vc, hc)
    }

pub fn min_value() -> Self

Returns the smallest value that can be represented by a normalized timestamp.

Examples found in repository

src/clock/ops.rs (line 105)

    fn min_value() -> Self {
        VFrameTs::min_value()
    }

src/clock.rs (line 150)

    pub fn saturating_normalized(self) -> Self {
        let VideoTs { mut vc, mut hc } = self.ts;
        if hc < V::HTS_RANGE.start || hc >= V::HTS_RANGE.end {
            let fhc: FTs = hc as FTs - if hc < 0 {
                V::HTS_RANGE.end
            }
            else {
                V::HTS_RANGE.start
            } as FTs;
            let dvc = (fhc / V::HTS_COUNT as FTs) as Ts;
            if let Some(vc1) = vc.checked_add(dvc) {
                vc = vc1;
                hc = fhc.rem_euclid(V::HTS_COUNT as FTs) as Ts + V::HTS_RANGE.start;
            }
            else {
                return if dvc < 0 { Self::min_value() } else { Self::max_value() };
            }
        }
        VFrameTs::new(vc, hc)
    }

pub fn is_eof(self) -> bool

Returns true if the counter value is past or near the end of a frame. Otherwise returns false.

Specifically, the condition is met if the vertical counter is equal to or greater than VideoFrame::VSL_COUNT.

pub fn wrap_frame(&mut self)

Ensures the vertical counter is in the range: (-VSL_COUNT, VSL_COUNT) by calculating a remainder of the division of the vertical counter by VideoFrame::VSL_COUNT.

pub fn saturating_sub_frame(self) -> Self

Returns a video timestamp after subtracting the total number of frame video scanlines from the scan line counter.

pub fn from_tstates(ts: FTs) -> Self

Returns a normalized timestamp from the given number of T-states.

Panics

Panics when the given ts overflows the capacity of the timestamp.

Examples found in repository

src/clock/ops.rs (line 93)

    fn from_tstates(ts: FTs) -> Self {
        VFrameTs::from_tstates(ts)
    }

pub fn try_from_tstates(ts: FTs) -> Option<Self>

On success returns a normalized timestamp from the given number of T-states.

Returns None when the given ts overflows the capacity of the timestamp.

Examples found in repository

src/clock.rs (line 194)

    pub fn from_tstates(ts: FTs) -> Self {
        Self::try_from_tstates(ts).expect("video timestamp overflow")
    }
    /// On success returns a normalized timestamp from the given number of T-states.
    ///
    /// Returns `None` when the given `ts` overflows the capacity of the timestamp.
    #[inline]
    pub fn try_from_tstates(ts: FTs) -> Option<Self> {
        let mut vc = match (ts / V::HTS_COUNT as FTs).try_into() {
            Ok(vc) => vc,
            Err(..) => return None
        };
        let mut hc: Ts = (ts % V::HTS_COUNT as FTs) as Ts;
        if hc >= V::HTS_RANGE.end {
            hc -= V::HTS_COUNT;
            vc += 1;
        }
        else if hc < V::HTS_RANGE.start {
            hc += V::HTS_COUNT;
            vc -= 1;
        }
        Some(VFrameTs::new(vc, hc))
    }
    /// Converts the timestamp to FTs.
    #[inline]
    pub fn into_tstates(self) -> FTs {
        let VideoTs { vc, hc } = self.ts;
        V::vc_hc_to_tstates(vc, hc)
    }
    /// Returns a tuple with an adjusted frame counter and with the frame-normalized timestamp as
    /// the number of T-states measured from the start of the frame.
    ///
    /// The frame starts when the horizontal and vertical counter are both 0.
    ///
    /// The returned timestamp value is in the range [0, [VideoFrame::FRAME_TSTATES_COUNT]).
    #[inline]
    pub fn into_frame_tstates(self, frames: u64) -> (u64, FTs) {
        let ts = TimestampOps::into_tstates(self);
        let frmdlt = ts / V::FRAME_TSTATES_COUNT;
        let ufrmdlt = if ts < 0 { frmdlt - 1 } else { frmdlt } as u64;
        let frames = frames.wrapping_add(ufrmdlt);
        let ts = ts.rem_euclid(V::FRAME_TSTATES_COUNT);
        (frames, ts)
    }

    #[inline]
    fn set_hc_after_small_increment(&mut self, mut hc: Ts) {
        if hc >= V::HTS_RANGE.end {
            hc -= V::HTS_COUNT as Ts;
            self.ts.vc += 1;
        }
        self.ts.hc = hc;
    }
}

impl<V, C> VFrameTsCounter<V, C>
    where V: VideoFrame,
          C: MemoryContention
{
    /// Constructs a new and normalized `VFrameTsCounter` from the given vertical and horizontal counter values.
    ///
    /// # Panics
    /// Panics when the given values lead to an overflow of the capacity of [VideoTs].
    #[inline]
    pub fn new(vc: Ts, hc: Ts, contention: C) -> Self {
        let vts = VFrameTs::new(vc, hc).normalized();
        VFrameTsCounter { vts, contention }
    }
    /// Builds a normalized [VFrameTsCounter] from the given count of T-states.
    ///
    /// # Panics
    ///
    /// Panics when the given `ts` overflows the capacity of [VideoTs].
    #[inline]
    pub fn from_tstates(ts: FTs, contention: C) -> Self {
        let vts = TimestampOps::from_tstates(ts);
        VFrameTsCounter { vts, contention }
    }
    /// Builds a normalized [VFrameTsCounter] from the given count of T-states.
    ///
    /// # Panics
    ///
    /// Panics when the given `ts` overflows the capacity of [VideoTs].
    #[inline]
    pub fn from_video_ts(vts: VideoTs, contention: C) -> Self {
        let vts = VFrameTs::from(vts).normalized();
        VFrameTsCounter { vts, contention }
    }
    /// Builds a normalized [VFrameTsCounter] from the given count of T-states.
    ///
    /// # Panics
    ///
    /// Panics when the given `ts` overflows the capacity of [VideoTs].
    #[inline]
    pub fn from_vframe_ts(vfts: VFrameTs<V>, contention: C) -> Self {
        let vts = vfts.normalized();
        VFrameTsCounter { vts, contention }
    }

    #[inline]
    pub fn is_contended_address(self, address: u16) -> bool {
        self.contention.is_contended_address(address)
    }
}

/// This macro is used to implement the ULA I/O contention scheme, for [z80emu::Clock::add_io] method of
/// [VFrameTsCounter].
/// It's being exported for the purpose of performing FUSE tests.
///
/// * $mc should be a type implementing [MemoryContention] trait.
/// * $port is a port address.
/// * $hc is an identifier of a mutable variable containing the `hc` property of a `VideoTs` timestamp.
/// * $contention should be a path to the [VideoFrame::contention] function.
///
/// The macro returns a horizontal timestamp pointing after the whole I/O cycle is over.
/// The `hc` variable is modified to contain a horizontal timestamp indicating when the data R/W operation 
/// takes place.
#[macro_export]
macro_rules! ula_io_contention {
    ($mc:expr, $port:expr, $hc:ident, $contention:path) => {
        {
            use $crate::z80emu::host::cycles::*;
            if $mc.is_contended_address($port) {
                $hc = $contention($hc) + IO_IORQ_LOW_TS as Ts;
                if $port & 1 == 0 { // C:1, C:3
                    $contention($hc) + (IO_CYCLE_TS - IO_IORQ_LOW_TS) as Ts
                }
                else { // C:1, C:1, C:1, C:1
                    let mut hc1 = $hc;
                    for _ in 0..(IO_CYCLE_TS - IO_IORQ_LOW_TS) {
                        hc1 = $contention(hc1) + 1;
                    }
                    hc1
                }
            }
            else {
                $hc += IO_IORQ_LOW_TS as Ts;
                if $port & 1 == 0 { // N:1 C:3
                    $contention($hc) + (IO_CYCLE_TS - IO_IORQ_LOW_TS) as Ts
                }
                else { // N:4
                    $hc + (IO_CYCLE_TS - IO_IORQ_LOW_TS) as Ts
                }
            }
        }
    };
}
/*
impl<V: VideoFrame> Clock for VFrameTs<V> {
    type Limit = Ts;
    type Timestamp = VideoTs;

    #[inline(always)]
    fn is_past_limit(&self, limit: Self::Limit) -> bool {
        self.vc >= limit
    }

    fn add_irq(&mut self, _pc: u16) -> Self::Timestamp {
        self.set_hc_after_small_increment(self.hc + IRQ_ACK_CYCLE_TS as Ts);
        self.as_timestamp()
    }

    fn add_no_mreq(&mut self, _address: u16, add_ts: NonZeroU8) {
        let hc = self.hc + add_ts.get() as Ts;
        self.set_hc_after_small_increment(hc);
    }

    fn add_m1(&mut self, _address: u16) -> Self::Timestamp {
        self.set_hc_after_small_increment(self.hc + M1_CYCLE_TS as Ts);
        self.as_timestamp()
    }

    fn add_mreq(&mut self, _address: u16) -> Self::Timestamp {
        self.set_hc_after_small_increment(self.hc + MEMRW_CYCLE_TS as Ts);
        self.as_timestamp()
    }

    fn add_io(&mut self, _port: u16) -> Self::Timestamp {
        let hc = self.hc + IO_IORQ_LOW_TS as Ts;
        let hc1 = hc + (IO_CYCLE_TS - IO_IORQ_LOW_TS) as Ts;

        let mut tsc = *self;
        tsc.set_hc_after_small_increment(hc);
        self.set_hc_after_small_increment(hc1);
        tsc.as_timestamp()
    }

    fn add_wait_states(&mut self, _bus: u16, wait_states: NonZeroU16) {
        let ws = wait_states.get();
        if ws > WAIT_STATES_THRESHOLD {
            // emulate hanging the Spectrum
            self.vc += HALT_VC_THRESHOLD;
        }
        else if ws < V::HTS_COUNT as u16 {
            self.set_hc_after_small_increment(self.hc + ws as i16);
        }
        else {
            *self += ws as u32;
        }
    }

    #[inline(always)]
    fn as_timestamp(&self) -> Self::Timestamp {
        self.ts
    }
}
*/
impl<V: VideoFrame, C: MemoryContention> Clock for VFrameTsCounter<V, C> {
    type Limit = Ts;
    type Timestamp = VideoTs;

    #[inline(always)]
    fn is_past_limit(&self, limit: Self::Limit) -> bool {
        self.vc >= limit
    }

    fn add_irq(&mut self, _pc: u16) -> Self::Timestamp {
        self.vts.set_hc_after_small_increment(self.hc + IRQ_ACK_CYCLE_TS as Ts);
        self.as_timestamp()
    }

    #[inline(always)]
    fn add_no_mreq(&mut self, address: u16, add_ts: NonZeroU8) {
        let mut hc = self.hc;
        if V::is_contended_line_no_mreq(self.vc) && self.contention.is_contended_address(address) {
            for _ in 0..add_ts.get() {
                hc = V::contention(hc) + 1;
            }
        }
        else {
            hc += add_ts.get() as Ts;
        }
        self.vts.set_hc_after_small_increment(hc);
    }

    #[inline(always)]
    fn add_m1(&mut self, address: u16) -> Self::Timestamp {
        // match address {
        //     // 0x8043 => println!("0x{:04x}: {} {:?}", address, self.as_tstates(), self.tsc),
        //     0x806F..=0x8078 => println!("0x{:04x}: {} {:?}", address, self.as_tstates(), self.tsc),
        //     // 0xC008..=0xC011 => println!("0x{:04x}: {} {:?}", address, self.as_tstates(), self.tsc),
        //     _ => {}
        // }
        let hc = if V::is_contended_line_mreq(self.vc) && self.contention.is_contended_address(address) {
            V::contention(self.hc)
        }
        else {
            self.hc
        };
        self.vts.set_hc_after_small_increment(hc + M1_CYCLE_TS as Ts);
        self.as_timestamp()
    }

    #[inline(always)]
    fn add_mreq(&mut self, address: u16) -> Self::Timestamp {
        let hc = if V::is_contended_line_mreq(self.vc) && self.contention.is_contended_address(address) {
            V::contention(self.hc)
        }
        else {
            self.hc
        };
        self.vts.set_hc_after_small_increment(hc + MEMRW_CYCLE_TS as Ts);
        self.as_timestamp()
    }

    // fn add_io(&mut self, port: u16) -> Self::Timestamp {
    //     let VideoTs{ vc, hc } = self.tsc;
    //     let hc = if V::is_contended_line_no_mreq(vc) {
    //         if self.contention.is_contended_address(port) {
    //             let hc = V::contention(hc) + 1;
    //             if port & 1 == 0 { // C:1, C:3
    //                 V::contention(hc) + (IO_CYCLE_TS - 1) as Ts
    //             }
    //             else { // C:1, C:1, C:1, C:1
    //                 let mut hc1 = hc;
    //                 for _ in 1..IO_CYCLE_TS {
    //                     hc1 = V::contention(hc1) + 1;
    //                 }
    //                 hc1
    //             }
    //         }
    //         else {
    //             if port & 1 == 0 { // N:1 C:3
    //                 V::contention(hc + 1) + (IO_CYCLE_TS - 1) as Ts
    //             }
    //             else { // N:4
    //                 hc + IO_CYCLE_TS as Ts
    //             }
    //         }
    //     }
    //     else { // N:4
    //         hc + IO_CYCLE_TS as Ts
    //     };
    //     self.vts.set_hc_after_small_increment(hc);
    //     Self::new(vc, hc - 1).as_timestamp() // data read at last cycle
    // }

    fn add_io(&mut self, port: u16) -> Self::Timestamp {
        let VideoTs{ vc, mut hc } = self.as_timestamp();
        // if port == 0x7ffd {
        //     println!("0x{:04x}: {} {:?}", port, self.as_tstates(), self.tsc);
        // }
        let hc1 = if V::is_contended_line_no_mreq(vc) {
            ula_io_contention!(self.contention, port, hc, V::contention)
            // if is_contended_address(self.contention_mask, port) {
            //     hc = V::contention(hc) + IO_IORQ_LOW_TS as Ts;
            //     if port & 1 == 0 { // C:1, C:3
            //         V::contention(hc) + (IO_CYCLE_TS - IO_IORQ_LOW_TS) as Ts
            //     }
            //     else { // C:1, C:1, C:1, C:1
            //         let mut hc1 = hc;
            //         for _ in 0..(IO_CYCLE_TS - IO_IORQ_LOW_TS) {
            //             hc1 = V::contention(hc1) + 1;
            //         }
            //         hc1
            //     }
            // }
            // else {
            //     hc += IO_IORQ_LOW_TS as Ts;
            //     if port & 1 == 0 { // N:1 C:3
            //         V::contention(hc) + (IO_CYCLE_TS - IO_IORQ_LOW_TS) as Ts
            //     }
            //     else { // N:4
            //         hc + (IO_CYCLE_TS - IO_IORQ_LOW_TS) as Ts
            //     }
            // }
        }
        else {
            hc += IO_IORQ_LOW_TS as Ts;
            hc + (IO_CYCLE_TS - IO_IORQ_LOW_TS) as Ts
        };
        let mut vtsc = *self;
        vtsc.vts.set_hc_after_small_increment(hc);
        self.vts.set_hc_after_small_increment(hc1);
        vtsc.as_timestamp()
    }

    fn add_wait_states(&mut self, _bus: u16, wait_states: NonZeroU16) {
        let ws = wait_states.get();
        if ws > WAIT_STATES_THRESHOLD {
            // emulate hanging the Spectrum
            self.vc += HALT_VC_THRESHOLD;
        }
        else if ws < V::HTS_COUNT as u16 {
            self.vts.set_hc_after_small_increment(self.hc + ws as i16);
        }
        else {
            *self += ws as u32;
        }
    }

    #[inline(always)]
    fn as_timestamp(&self) -> Self::Timestamp {
        ***self
    }
}

impl<V> Default for VFrameTs<V> {
    fn default() -> Self {
        VFrameTs::from(VideoTs::default())
    }
}

impl<V> Clone for VFrameTs<V> {
    fn clone(&self) -> Self {
        VFrameTs::from(self.ts)
    }
}

impl<V> Hash for VFrameTs<V> {
    fn hash<H: Hasher>(&self, state: &mut H) {
        self.ts.hash(state);
    }
}

impl<V> Eq for VFrameTs<V> {}

impl<V> PartialEq for VFrameTs<V> {
    #[inline(always)]
    fn eq(&self, other: &Self) -> bool {
        self.ts == other.ts
    }
}

impl<V> Ord for VFrameTs<V> {
    #[inline(always)]
    fn cmp(&self, other: &Self) -> Ordering {
        self.ts.cmp(other)
    }
}

impl<V> PartialOrd for VFrameTs<V> {
    #[inline(always)]
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        Some(self.cmp(other))
    }
}

impl<V: VideoFrame> From<VFrameTs<V>> for FTs {
    #[inline(always)]
    fn from(vfts: VFrameTs<V>) -> FTs {
        VFrameTs::into_tstates(vfts)
    }
}

impl<V: VideoFrame> TryFrom<FTs> for VFrameTs<V> {
    type Error = &'static str;

    fn try_from(ts: FTs) -> Result<Self, Self::Error> {
        VFrameTs::try_from_tstates(ts).ok_or(
            "out of range video timestamp conversion attempted")
    }

pub fn into_tstates(self) -> FTs

Converts the timestamp to FTs.

Examples found in repository

src/clock/ops.rs (line 97)

    fn into_tstates(self) -> FTs {
        VFrameTs::into_tstates(self)
    }

src/clock.rs (line 594)

    fn from(vfts: VFrameTs<V>) -> FTs {
        VFrameTs::into_tstates(vfts)
    }

src/audio.rs (line 373)

pub fn render_audio_frame_vts<VF,VL,L,A,T>(
            prev_state: u8,
            end_ts: Option<VFrameTs<VF>>,
            changes: &[T],
            blep: &mut A, channel: usize
        )
    where VF: VideoFrame,
          VL: AmpLevels<L>,
          L: SampleDelta,
          A: Blep<SampleDelta=L>,
          T: Copy, (VideoTs, u8): From<T>,
{
    let mut last_vol = VL::amp_level(prev_state.into());
    for &tsd in changes.iter() {
        let (ts, state) = tsd.into();
        let vts: VFrameTs<_> = ts.into();
        if let Some(end_ts) = end_ts {
            if vts >= end_ts { // TODO >= or >
                break
            }
        }
        let next_vol = VL::amp_level(state.into());
        if let Some(delta) = last_vol.sample_delta(next_vol) {
            let timestamp = vts.into_tstates();
            blep.add_step(channel, timestamp, delta);
            last_vol = next_vol;
        }
    }
}

pub fn into_frame_tstates(self, frames: u64) -> (u64, FTs)

Returns a tuple with an adjusted frame counter and with the frame-normalized timestamp as the number of T-states measured from the start of the frame.

The frame starts when the horizontal and vertical counter are both 0.

The returned timestamp value is in the range [0, VideoFrame::FRAME_TSTATES_COUNT).

Trait Implementations

impl<V: VideoFrame> Add<i32> for VFrameTs<V>

fn add(self, delta: FTs) -> Self

Returns a normalized video timestamp after adding delta T-states.

Panics

Panics when normalized timestamp after addition leads to an overflow of the capacity of VideoTs.

type Output = VFrameTs<V>

The resulting type after applying the + operator.

impl<V: VideoFrame> Add<u32> for VFrameTs<V>

fn add(self, delta: u32) -> Self

Returns a normalized video timestamp after adding a delta T-state count.

Panics

Panics when normalized timestamp after addition leads to an overflow of the capacity of VideoTs.

type Output = VFrameTs<V>

The resulting type after applying the + operator.

impl<V: VideoFrame> AddAssign<i32> for VFrameTs<V>

fn add_assign(&mut self, delta: FTs)

Performs the += operation.

impl<V: VideoFrame> AddAssign<u32> for VFrameTs<V>

fn add_assign(&mut self, delta: u32)

Performs the += operation.

impl<V> Clone for VFrameTs<V>

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<V: Debug> Debug for VFrameTs<V>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<V> Default for VFrameTs<V>

fn default() -> Self

Returns the “default value” for a type.

impl<V> Deref for VFrameTs<V>

type Target = VideoTs

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<V> DerefMut for VFrameTs<V>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'de, V> Deserialize<'de> for VFrameTs<V>where
    V: VideoFrame,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<V: VideoFrame> From<&VideoTsData1> for VFrameTs<V>

fn from(vtsd: &VideoTsData1) -> Self

Converts to this type from the input type.

impl<V: VideoFrame> From<&VideoTsData2> for VFrameTs<V>

fn from(vtsd: &VideoTsData2) -> Self

Converts to this type from the input type.

impl<V: VideoFrame> From<&VideoTsData3> for VFrameTs<V>

fn from(vtsd: &VideoTsData3) -> Self

Converts to this type from the input type.

impl<V: VideoFrame> From<&VideoTsData6> for VFrameTs<V>

fn from(vtsd: &VideoTsData6) -> Self

Converts to this type from the input type.

impl<V: VideoFrame> From<VFrameTs<V>> for FTs

fn from(vfts: VFrameTs<V>) -> FTs

Converts to this type from the input type.

impl<V> From<VFrameTs<V>> for VideoTs

fn from(vfts: VFrameTs<V>) -> VideoTs

Converts to this type from the input type.

impl<V, C> From<VFrameTsCounter<V, C>> for VFrameTs<V>

fn from(vftsc: VFrameTsCounter<V, C>) -> VFrameTs<V>

Converts to this type from the input type.

impl<V> From<VideoTs> for VFrameTs<V>

fn from(ts: VideoTs) -> Self

Returns a VFrameTs from the given VideoTs. A returned VFrameTs is not being normalized.

Panics

Panics when the given ts overflows the capacity of VideoTs.

impl<V: VideoFrame> From<VideoTsData1> for VFrameTs<V>

fn from(vtsd: VideoTsData1) -> Self

Converts to this type from the input type.

impl<V: VideoFrame> From<VideoTsData2> for VFrameTs<V>

fn from(vtsd: VideoTsData2) -> Self

Converts to this type from the input type.

impl<V: VideoFrame> From<VideoTsData3> for VFrameTs<V>

fn from(vtsd: VideoTsData3) -> Self

Converts to this type from the input type.

impl<V: VideoFrame> From<VideoTsData6> for VFrameTs<V>

fn from(vtsd: VideoTsData6) -> Self

Converts to this type from the input type.

impl<V> Hash for VFrameTs<V>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where
    H: Hasher,
    Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<V> Ord for VFrameTs<V>

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Selfwhere
    Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Selfwhere
    Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere
    Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl<V> PartialEq<VFrameTs<V>> for VFrameTs<V>

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<V> PartialOrd<VFrameTs<V>> for VFrameTs<V>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<V> Serialize for VFrameTs<V>where
    V: VideoFrame,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where
    __S: Serializer,

Serialize this value into the given Serde serializer.

impl<V: VideoFrame> Sub<i32> for VFrameTs<V>

fn sub(self, delta: FTs) -> Self

Returns a normalized video timestamp after subtracting delta T-states.

Panics

Panics when normalized timestamp after addition leads to an overflow of the capacity of VideoTs.

type Output = VFrameTs<V>

The resulting type after applying the - operator.

impl<V: VideoFrame> Sub<u32> for VFrameTs<V>

fn sub(self, delta: u32) -> Self

Returns a normalized video timestamp after adding a delta T-state count.

Panics

Panics when normalized timestamp after addition leads to an overflow of the capacity of VideoTs.

type Output = VFrameTs<V>

The resulting type after applying the - operator.

impl<V: VideoFrame> SubAssign<i32> for VFrameTs<V>

fn sub_assign(&mut self, delta: FTs)

Performs the -= operation.

impl<V: VideoFrame> SubAssign<u32> for VFrameTs<V>

fn sub_assign(&mut self, delta: u32)

Performs the -= operation.

impl<V: VideoFrame> TimestampOps for VFrameTs<V>

fn saturating_add(self, other: Self) -> Self

Panics

May panic if self or other hasn’t been normalized.

fn saturating_sub(self, other: Self) -> Self

Panics

May panic if self or other hasn’t been normalized.

fn from_tstates(ts: FTs) -> Self

Returns a normalized timestamp from the given number of T-states.

fn into_tstates(self) -> FTs

Converts the timestamp to FTs.

fn max_value() -> Self

Returns the largest value that can be represented by a normalized timestamp.

fn min_value() -> Self

Returns the smallest value that can be represented by a normalized timestamp.

fn diff_from(self, vts_from: Self) -> FTs

Returns the difference between ts_from and self in the number of T-states.

impl<V: VideoFrame> TryFrom<i32> for VFrameTs<V>

type Error = &'static str

The type returned in the event of a conversion error.

fn try_from(ts: FTs) -> Result<Self, Self::Error>

Performs the conversion.

impl<V: Copy> Copy for VFrameTs<V>

impl<V> Eq for VFrameTs<V>