Struct spectrusty::chip::scld::Scld

pub struct Scld<M: PagedMemory8k, B, X, V> { /* fields omitted */ }

This is the emulator of SCLD chip used with Timex's TC2048 / TC2068 / TS2068 models.

The generic type M must implement PagedMemory8k trait in addition to ZxMemory.

See Ula for description of other generic parameters.

Trait Implementations

impl<A, M, B, X, V> AudioFrame<A> for Scld<M, B, X, V> where
    A: Blep,
    M: PagedMemory8k,
    Ula<M, B, X, V>: AudioFrame<A>, 

pub fn ensure_audio_frame_time(
    &self,
    blep: &mut A,
    sample_rate: u32,
    cpu_hz: f64
)

Sets up the Blep time rate and ensures there is enough room for the single frame's audio data.

pub fn get_audio_frame_end_time(&self) -> FTs

Returns a timestamp to be passed to Blep to end the frame.

pub fn end_audio_frame(&self, blep: &mut B) -> usize

Calls Blep::end_frame to finalize the frame and prepare it for rendition.

impl<A, M, B, X, V> AyAudioFrame<A> for Scld<M, B, X, V> where
    A: Blep,
    M: PagedMemory8k,
    B: AyAudioBusDevice + BusDevice,
    B::Timestamp: From<VFrameTs<V>>,
    V: VideoFrame, 

pub fn render_ay_audio_frame<L: AmpLevels<A::SampleDelta>>(
    &mut self,
    blep: &mut A,
    chans: [usize; 3]
)

Renders square-wave pulses via Blep interface.

impl<M: Clone + PagedMemory8k, B: Clone, X: Clone, V: Clone> Clone for Scld<M, B, X, V>

pub fn clone(&self) -> Scld<M, B, X, V>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<M, B, X, V> ControlUnit for Scld<M, B, X, V> where
    M: PagedMemory8k,
    B: BusDevice,
    B::Timestamp: From<VFrameTs<V>>,
    X: MemoryExtension,
    V: VideoFrame, 

type BusDevice = B

A type of a chain of emulated peripheral devices should be declared here.

pub fn bus_device_mut(&mut self) -> &mut Self::BusDevice

Returns a mutable reference to the instance of the first bus device in the device chain.

pub fn bus_device_ref(&self) -> &Self::BusDevice

Returns a reference to the the instance of the first bus device in the device chain.

pub fn into_bus_device(self) -> Self::BusDevice

Destructs self and returns the instance of the bus device.

pub fn reset<C: Cpu>(&mut self, cpu: &mut C, hard: bool)

Performs a system reset.

pub fn nmi<C: Cpu>(&mut self, cpu: &mut C) -> bool

Triggers a non-maskable interrupt. Returns true if NMI was accepted.

pub fn execute_next_frame<C: Cpu>(&mut self, cpu: &mut C)

Conditionally prepares the internal state for the next frame and executes instructions on the cpu as fast as possible, until the near end of that frame.

pub fn ensure_next_frame(&mut self)

Conditionally prepares the internal state for the next frame, advances the frame counter, and wraps the T-state counter if it is near the end of a frame.

pub fn execute_single_step<C: Cpu, F: FnOnce(CpuDebug)>(
    &mut self,
    cpu: &mut C,
    debug: Option<F>
) -> Result<(), ()>

Executes a single instruction on the cpu with the option to pass a debugging function.

impl<M, B, X, V> Debug for Scld<M, B, X, V> where
    M: PagedMemory8k,
    B: BusDevice,
    X: MemoryExtension,
    V: VideoFrame, 

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

Formats the value using the given formatter.

impl<M, B, X, V> Default for Scld<M, B, X, V> where
    M: PagedMemory8k,
    V: VideoFrame,
    Ula<M, B, X, V>: Default, 

pub fn default() -> Self

Returns the "default value" for a type.

impl<'de, M: PagedMemory8k, B, X, V> Deserialize<'de> for Scld<M, B, X, V> where
    Ula<M, B, X, V>: Deserialize<'de>,
    V: Default, 

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

Deserialize this value from the given Serde deserializer.

impl<M, B, X, V> EarIn for Scld<M, B, X, V> where
    M: PagedMemory8k,
    V: VideoFrame, 

pub fn set_ear_in(&mut self, ear_in: bool, delta_fts: u32)

Sets EAR IN bit state after the provided interval in ∆ T-states counted from the last recorded change.

pub fn feed_ear_in<I>(
    &mut self,
    fts_deltas: I,
    max_frames_threshold: Option<usize>
) where
    I: Iterator<Item = NonZeroU32>, 

Feeds the EAR IN buffer with changes.

pub fn purge_ear_in_changes(&mut self, ear_in: bool)

Removes all buffered so far EAR IN changes.

pub fn read_ear_in_count(&self) -> u32

Returns the counter of how many times the EAR input line was read since the beginning of the current frame.

pub fn read_ear_mode(&self) -> ReadEarMode

Returns the current mode.

pub fn set_read_ear_mode(&mut self, mode: ReadEarMode)

Changes the current mode.

impl<A, M, B, X, F> EarInAudioFrame<A> for Scld<M, B, X, F> where
    A: Blep,
    M: PagedMemory8k,
    F: VideoFrame, 

pub fn render_ear_in_audio_frame<V: AmpLevels<A::SampleDelta>>(
    &self,
    blep: &mut A,
    channel: usize
)

Renders EAR input as square-wave pulses via Blep interface.

impl<A, M, B, X, F> EarMicOutAudioFrame<A> for Scld<M, B, X, F> where
    A: Blep,
    M: PagedMemory8k,
    F: VideoFrame, 

pub fn render_earmic_out_audio_frame<V: AmpLevels<A::SampleDelta>>(
    &self,
    blep: &mut A,
    channel: usize
)

Renders EAR/MIC output as square-wave pulses via Blep interface.

impl<M: PagedMemory8k, B, X> HostConfig for Scld<M, B, X, UlaVideoFrame>

pub const CPU_HZ: u32

The number of CPU cycles (T-states) per second.

pub const FRAME_TSTATES: FTs

The number of CPU cycles (T-states) in a single execution frame.

pub fn effective_cpu_rate(multiplier: f64) -> f64

Returns the CPU rate (T-states / second) after multiplying it by the multiplier.

pub fn effective_frame_duration_nanos(multiplier: f64) -> u32

Returns the duration of a single execution frame in nanoseconds after multiplying the CPU rate by the multiplier.

pub fn effective_frame_duration(multiplier: f64) -> Duration

Returns the duration of a single execution frame after multiplying the CPU rate by the multiplier.

pub fn frame_duration_nanos() -> u32

Returns the duration of a single execution frame in nanoseconds.

pub fn frame_duration() -> Duration

Returns the duration of a single execution frame.

impl<M, B, X, V> InnerAccess for Scld<M, B, X, V> where
    M: PagedMemory8k, 

type Inner = Ula<M, B, X, V>

pub fn inner_ref(&self) -> &Self::Inner

Returns a reference to the inner chipset.

pub fn inner_mut(&mut self) -> &mut Self::Inner

Returns a mutable reference to the inner chipset.

pub fn into_inner(self) -> Self::Inner

Destructs self and returns the inner chipset.

impl<M, B, X, V> Io for Scld<M, B, X, V> where
    M: PagedMemory8k,
    B: BusDevice,
    B::Timestamp: From<VFrameTs<V>>,
    V: VideoFrame, 

type Timestamp = VideoTs

This type is being used for timestamping I/O operations. See also [Clock::Timestamp].

type WrIoBreak = ()

A value of this type is returned when a break is being requested by [Io::write_io].

type RetiBreak = ()

A value of this type is returned when a break is being requested by [Io::reti].

pub fn is_irq(&mut self, ts: VideoTs) -> bool

Should return true if the interrupt request signal - the INT line - is active.

pub fn read_io(&mut self, port: u16, ts: VideoTs) -> (u8, Option<NonZeroU16>)

Called during the IO_IORQ cycle when executing one of the IN instructions.

pub fn write_io(
    &mut self,
    port: u16,
    data: u8,
    ts: VideoTs
) -> (Option<()>, Option<NonZeroU16>)

Called during the IO_IORQ cycle when executing one of the OUT instructions.

pub fn irq_data(
    &mut self,
    pc: u16,
    timestamp: Self::Timestamp
) -> (u8, Option<NonZeroU16>)

Called during the INT_IORQ cycle when the maskable interrupt has been requested and accepted.

pub fn reti(
    &mut self,
    address: u16,
    timestamp: Self::Timestamp
) -> Option<Self::RetiBreak>

When RETI instruction is being executed this method is being called to update the device implementation instance, so another interrupt signal can be set up if necessary.

impl<M, B, X, V> KeyboardInterface for Scld<M, B, X, V> where
    M: PagedMemory8k, 

pub fn get_key_state(&self) -> ZXKeyboardMap

Reads the current state of the keyboard.

pub fn set_key_state(&mut self, keymap: ZXKeyboardMap)

Sets the state of the keyboard.

impl<M, B, X, V> Memory for Scld<M, B, X, V> where
    M: PagedMemory8k,
    X: MemoryExtension,
    V: VideoFrame, 

type Timestamp = VideoTs

This type is being used for timestamping memory operations. See also [Clock::Timestamp].

pub fn read_debug(&self, addr: u16) -> u8

Should return a single byte read from the memory present at the given address.

pub fn read_mem(&self, addr: u16, _ts: VideoTs) -> u8

Should return a single byte read from the memory present at the given address.

pub fn read_mem16(&self, addr: u16, _ts: VideoTs) -> u16

Should return the unaligned, 2 consecutive bytes from the memory present at the given address as a 16-bit unsigned integer in a LE (least significant byte first) order.

pub fn read_opcode(&mut self, pc: u16, _ir: u16, _ts: VideoTs) -> u8

Should return a single byte read from the memory present at the given pc address.

pub fn write_mem(&mut self, addr: u16, val: u8, ts: VideoTs)

Should write a byte value into the memory at the given address.

impl<M, B, X, V> MemoryAccess for Scld<M, B, X, V> where
    M: PagedMemory8k,
    X: MemoryExtension, 

type Memory = M

type MemoryExt = X

pub fn memory_ext_ref(&self) -> &Self::MemoryExt

Returns a read-only reference to the memory extension.

pub fn memory_ext_mut(&mut self) -> &mut Self::MemoryExt

Returns a mutable reference to the memory extension.

pub fn memory_mut(&mut self) -> &mut Self::Memory

Returns a mutable reference to the memory.

pub fn memory_ref(&self) -> &Self::Memory

Returns a reference to the memory.

pub fn memory_with_ext_mut(
    &mut self
) -> (&mut Self::Memory, &mut Self::MemoryExt)

Returns mutable references to both the memory and the memory extension.

impl<'a, M: 'a, B: 'a, X: 'a, V: 'a> MicOut<'a> for Scld<M, B, X, V> where
    M: PagedMemory8k,
    V: VideoFrame, 

type PulseIter = <Ula<M, B, X, V> as MicOut<'a>>::PulseIter

pub fn mic_out_pulse_iter(&'a self) -> Self::PulseIter

Returns a frame buffered MIC output as a pulse iterator.

impl<M, B, X, V> ScreenDataProvider for Scld<M, B, X, V> where
    M: ZxMemory + PagedMemory8k,
    X: MemoryExtension,
    V: VideoFrame, 

pub fn get_screen_mode(&self) -> ScrMode

Should return a currently selected screen mode.

pub fn set_screen_mode(&mut self, mode: ScrMode) -> bool

Should set a requested screen mode and return true. If the provided mode can not be set this method should return false.

pub fn screen_primary_ref(&self) -> &ScreenArray

Should return a reference to the primary screen data.

pub fn screen_primary_mut(&mut self) -> &mut ScreenArray

Should return a mutable reference to the primary screen data.

pub fn screen_secondary_ref(&self) -> &ScreenArray

Should return a reference to the secondary screen data.

pub fn screen_secondary_mut(&mut self) -> &mut ScreenArray

Should return a mutable reference to the secondary screen data.

pub fn screen_palette_ref(&self) -> &[u8; 64]

Should return a reference to the ULAplus palette.

pub fn screen_palette_mut(&mut self) -> &mut [u8; 64]

Should return a mutable reference to the ULAplus palette.

impl<M: PagedMemory8k, B, X, V> Serialize for Scld<M, B, X, V> where
    Ula<M, B, X, V>: Serialize, 

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

Serialize this value into the given Serde serializer.

impl<M, B, X, V> UlaControl for Scld<M, B, X, V> where
    M: PagedMemory8k,
    V: VideoFrame, 

pub fn has_late_timings(&self) -> bool

Returns the state of the "late timings" mode.

pub fn set_late_timings(&mut self, late_timings: bool)

Sets the "late timings" mode on or off.

pub fn scld_ctrl_port_value(&self) -> Option<ScldCtrlFlags>

Returns the last value sent to the memory port 0xFF.

pub fn set_scld_ctrl_port_value(&mut self, value: ScldCtrlFlags) -> bool

Sets the current value of the memory port 0xFF. Returns true if supported. Otherwise, returns false and no writing is performed.

pub fn scld_mmu_port_value(&self) -> Option<u8>

Returns the last value sent to the memory port 0xF4.

pub fn set_scld_mmu_port_value(&mut self, value: u8) -> bool

Sets the current value of the memory port 0xF4. Returns true if supported. Otherwise, returns false and no writing is performed.

pub fn ula128_mem_port_value(&self) -> Option<Ula128MemFlags>

Returns the last value sent to the memory port 0x7FFD if supported.

pub fn set_ula128_mem_port_value(&mut self, _value: Ula128MemFlags) -> bool

Sets the current value of the memory port 0x7FFD. Returns true if supported. Otherwise, returns false and no writing is performed.

pub fn ula3_ctrl_port_value(&self) -> Option<Ula3CtrlFlags>

Returns the last value sent to the memory port 0x1FFD if supported.

pub fn set_ula3_ctrl_port_value(&mut self, _value: Ula3CtrlFlags) -> bool

Sets the current value of the memory port 0x1FFD. Returns true if supported. Otherwise, returns false and no writing is performed.

pub fn ulaplus_reg_port_value(&self) -> Option<UlaPlusRegFlags>

Returns the last value sent to the register port 0xBF3B.

pub fn set_ulaplus_reg_port_value(&mut self, _value: UlaPlusRegFlags) -> bool

Sets the current value of the memory port 0xBF3B. Returns true if supported. Otherwise, returns false and no writing is performed.

pub fn ulaplus_data_port_value(&self) -> Option<u8>

Returns the last value sent to the data port 0xFF3B.

pub fn set_ulaplus_data_port_value(&mut self, _value: u8) -> bool

Sets the current value of the memory port 0xFF3B. Returns true if supported. Otherwise, returns false and no writing is performed.

impl<M, B, X, V> UlaControlExt for Scld<M, B, X, V> where
    M: PagedMemory8k,
    B: BusDevice,
    B::Timestamp: From<VFrameTs<V>>,
    V: VideoFrame, 

pub fn prepare_next_frame<C: MemoryContention>(
    &mut self,
    vtsc: VFrameTsCounter<V, C>
) -> VFrameTsCounter<V, C>

This method is used by wrappers with a different contention scheme.

pub fn ensure_next_frame_vtsc(
    &mut self
) -> VFrameTsCounter<Self::VideoFrame, Self::Contention>

impl<M, D, X, V> Video for Scld<M, D, X, V> where
    M: PagedMemory8k,
    V: VideoFrame, 

pub const PIXEL_DENSITY: u32

The horizontal pixel density.

type VideoFrame = V

The type implementing VideoFrame, that is being used by the chipset emulator.

type Contention = UlaMemoryContention

The type implementing MemoryContention, that is being used by the chipset emulator.

pub fn border_color(&self) -> BorderColor

Returns the current border color.

pub fn set_border_color(&mut self, border: BorderColor)

Force sets the border area to the given color.

pub fn render_video_frame<'a, B: PixelBuffer<'a>, P: Palette<Pixel = B::Pixel>>(
    &mut self,
    buffer: &'a mut [u8],
    pitch: usize,
    border_size: BorderSize
)

Renders last emulated frame's video data into the provided pixel buffer.

pub fn current_video_ts(&self) -> VideoTs

Returns the current value of the video T-state counter.

pub fn current_video_clock(
    &self
) -> VFrameTsCounter<Self::VideoFrame, Self::Contention>

Returns the current value of the video T-state clock.

pub fn set_video_ts(&mut self, vts: VideoTs)

Modifies the current value of the video T-state counter.

pub fn flash_state(&self) -> bool

Returns the temporary video flash attribute state.

pub fn render_size_pixels(border_size: BorderSize) -> (u32, u32)

Returns rendered screen pixel size (horizontal, vertical), including the border area, measured in pixels depending on Video::PIXEL_DENSITY.

pub fn pixel_density() -> u32

Returns the horizontal pixel density.

pub fn visible_screen_bank(&self) -> usize

Returns the screen bank index of the currently visible screen.