Struct spectrusty::chip::ula::Ula

pub struct Ula<M, B, X, V> { /* fields omitted */ }

Generic 16k/48k Ferranti ULA (Uncommitted Logic Array).

• M - ZxMemory
• B - BusDevice
• X - MemoryExtension
• V - VideoFrame

The type used for <B as BusDevice>::Timestamp should at least satisfy the condition: From<VFrameTs<V>>.

Trait Implementations

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

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<B, M, D, X, V> AyAudioFrame<B> for Ula<M, D, X, V> where
    B: Blep,
    D: AyAudioBusDevice + BusDevice,
    D::Timestamp: From<VFrameTs<V>>,
    V: VideoFrame, 

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

Renders square-wave pulses via Blep interface.

impl<M: Clone, B: Clone, X: Clone, V: Clone> Clone for Ula<M, B, X, V>

pub fn clone(&self) -> Ula<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 Ula<M, B, X, V> where
    M: ZxMemory,
    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 Ula<M, B, X, V> where
    M: ZxMemory,
    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 Ula<M, B, X, V> where
    M: Default,
    B: Default,
    X: Default, 

pub fn default() -> Self

Returns the "default value" for a type.

impl<'de, M, B, X, V> Deserialize<'de> for Ula<M, B, X, V> where
    V: VideoFrame,
    M: Deserialize<'de>,
    B: Deserialize<'de>,
    X: 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 Ula<M, B, X, V> where
    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>, 

It's most optimal to be done after ensure_next_frame is called, but is not necessary.

Panics

Panics if adding the delta would exceed the TsCounter max_value (Ts::max_value() as u32 * V::HTS_COUNT as u32).

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, V> EarInAudioFrame<A> for Ula<M, B, X, V> where
    A: Blep,
    V: VideoFrame, 

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

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

impl<A, M, B, X, V> EarMicOutAudioFrame<A> for Ula<M, B, X, V> where
    A: Blep,
    V: VideoFrame, 

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

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

impl<M, B, X, V: VideoFrame> FrameState for Ula<M, B, X, V>

pub fn current_frame(&self) -> u64

Returns the value of the current execution frame counter. The FrameState implementation should count passing frames infinitely wrapping at 2^64.

pub fn set_frame_counter(&mut self, fc: u64)

Sets the frame counter to the specified value.

pub fn frame_tstate(&self) -> (u64, FTs)

Returns a normalized frame counter and a T-state counter as a tuple.

pub fn current_tstate(&self) -> FTs

Returns the current value of the T-state counter.

pub fn set_frame_tstate(&mut self, ts: FTs)

Sets the T-state counter to the specified value modulo <Self as Video>::FRAME_TSTATES_COUNT.

pub fn is_frame_over(&self) -> bool

Returns true if the value of the current T-state counter has reached a certain arbitrary limit which is very close to the maximum number of T-states per frame.

impl<M: ZxMemory, B, X> HostConfig for Ula<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> Io for Ula<M, B, X, V> where
    M: ZxMemory,
    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, VideoTs { vc, hc }: 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 Ula<M, B, X, V>

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 Ula<M, B, X, V> where
    M: ZxMemory,
    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 Ula<M, B, X, V> where
    M: ZxMemory,
    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, F: 'a> MicOut<'a> for Ula<M, B, X, F> where
    F: VideoFrame, 

type PulseIter = MicPulseIter<Iter<'a, VideoTsData2>, F>

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 Ula<M, B, X, V> where
    M: ZxMemory,
    X: MemoryExtension, 

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) -> &[u8; 6912]

Should return a reference to the secondary screen data.

pub fn screen_secondary_mut(&mut self) -> &mut [u8; 6912]

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, B, X, V> Serialize for Ula<M, B, X, V> where
    V: VideoFrame,
    M: Serialize,
    B: Serialize,
    X: 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 Ula<M, B, X, V>

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 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 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 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 Ula<M, B, X, V> where
    M: ZxMemory,
    B: BusDevice,
    B::Timestamp: From<VFrameTs<V>>,
    V: VideoFrame, 

pub fn prepare_next_frame<C: MemoryContention>(
    &mut self,
    mut 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<'a, M, B, X, V> UlaPlusInner<'a> for Ula<M, B, X, V> where
    M: ZxMemory,
    X: MemoryExtension,
    V: VideoFrame, 

type ScreenSwapIter = Empty<VideoTs>

pub fn is_ula_port(port: u16) -> bool

Returns true if port matches the ULA port.

pub fn ula_write_earmic(&mut self, flags: UlaPortFlags, ts: VideoTs)

Sets the state of EarMic flags and optionally records an EarMic change.

pub fn push_screen_change(&mut self, _ts: VideoTs)

Records a shadow screen swap.

pub fn update_last_border_color(&mut self, border: BorderColor) -> bool

Updates the border color, returns true if the border color has changed.

pub fn page1_screen0_shadow_bank(&self) -> Option<bool>

Returns Some(is_shadow) if a screen memory is accessible at page address: 0x4000-0x5FFF.

pub fn page1_screen1_shadow_bank(&self) -> Option<bool>

Returns Some(is_shadow) if a screen memory is accessible at page address: 0x6000-0x7FFF.

pub fn page3_screen0_shadow_bank(&self) -> Option<bool>

Returns Some(is_shadow) if a screen memory is accessible at page address: 0xC000-0xDFFF.

pub fn page3_screen1_shadow_bank(&self) -> Option<bool>

Returns Some(is_shadow) if a screen memory is accessible at page address: 0xE000-0xFFFF.

pub fn frame_cache_mut_mem_ref(
    &mut self
) -> (&mut UlaFrameCache<Self::VideoFrame>, &Self::Memory)

Returns a mutable reference to the normal frame cache and a memory reference.

pub fn shadow_frame_cache_mut_mem_ref(
    &mut self
) -> (&mut UlaFrameCache<Self::VideoFrame>, &Self::Memory)

Returns a mutable reference to the shadow frame cache and a memory reference.

pub fn beg_screen_shadow(&self) -> bool

Returns true if the shadow screen is displayed at the beginning of the video frame.

pub fn cur_screen_shadow(&self) -> bool

Returns true if the shadow screen is currently being displayed.

pub fn video_render_data_view(
    &mut self
) -> VideoRenderDataView<'_, Self::ScreenSwapIter, Self::Memory, Self::VideoFrame>

Returns references to components necessary for video rendering.

impl<M: ZxMemory, D, X, V: VideoFrame> Video for Ula<M, D, X, V>

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<V, UlaMemoryContention>

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 const PIXEL_DENSITY: u32

The horizontal pixel density.

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.