Struct spectrusty::chip::ula128::Ula128

pub struct Ula128<B = VFNullDevice<Ula128VidFrame>, X = NoMemoryExtension> { /* private fields */ }

128k ULA (Uncommitted Logic Array).

See Ula for description of generic parameters.

Trait Implementations

impl<B, D, X> AudioFrame<B> for Ula128<D, X>where
    B: Blep,
    Ula<Memory128k, D, X, Ula128VidFrame>: AudioFrame<B>,

fn ensure_audio_frame_time(&self, blep: &mut B, 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.

fn get_audio_frame_end_time(&self) -> FTs

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

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

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

impl<B, D, X> AyAudioFrame<B> for Ula128<D, X>where
    B: Blep,
    D: AyAudioBusDevice + BusDevice,
    D::Timestamp: From<VFrameTs<Ula128VidFrame>>,

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<B: Clone, X: Clone> Clone for Ula128<B, X>

fn clone(&self) -> Ula128<B, X>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<B, X> ControlUnit for Ula128<B, X>where
    B: BusDevice,
    B::Timestamp: From<VFrameTs<Ula128VidFrame>>,
    X: MemoryExtension,

type BusDevice = B

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

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.

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

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

fn into_bus_device(self) -> Self::BusDevice

Destructs self and returns the instance of the bus device.

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

Performs a system reset.

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

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

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.

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.

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<B, X> Debug for Ula128<B, X>where
    B: BusDevice,
    X: MemoryExtension,

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

Formats the value using the given formatter.

impl<B: Default, X: Default> Default for Ula128<B, X>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, B, X> Deserialize<'de> for Ula128<B, X>where
    B: Deserialize<'de>,
    X: Deserialize<'de>,

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

Deserialize this value from the given Serde deserializer.

impl<D, X> EarIn for Ula128<D, X>

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.

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.

fn purge_ear_in_changes(&mut self, ear_in: bool)

Removes all buffered so far EAR IN changes.

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.

fn read_ear_mode(&self) -> ReadEarMode

Returns the current mode.

fn set_read_ear_mode(&mut self, mode: ReadEarMode)

Changes the current mode.

impl<B, D, X> EarInAudioFrame<B> for Ula128<D, X>where
    B: Blep,

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

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

impl<B, D, X> EarMicOutAudioFrame<B> for Ula128<D, X>where
    B: Blep,

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

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

impl<B, X> HostConfig for Ula128<B, X>

const CPU_HZ: u32 = 3_546_900u32

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

const FRAME_TSTATES: FTs = 70_908i32

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

fn effective_cpu_rate(multiplier: f64) -> f64

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

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.

fn effective_frame_duration(multiplier: f64) -> Duration

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

fn frame_duration_nanos() -> u32

Returns the duration of a single execution frame in nanoseconds.

fn frame_duration() -> Duration

Returns the duration of a single execution frame.

impl<B, X> InnerAccess for Ula128<B, X>

type Inner = Ula<MemPageableRomRamExRom<{MEM32K_SIZE + MEM128K_SIZE}, MEM16K_SIZE, {MEM64K_SIZE/MEM16K_SIZE}>, B, X, Ula128VidFrame>

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

Returns a reference to the inner chipset.

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

Returns a mutable reference to the inner chipset.

fn into_inner(self) -> Self::Inner

Destructs self and returns the inner chipset.

impl<B, X> Io for Ula128<B, X>where
    B: BusDevice,
    B::Timestamp: From<VFrameTs<Ula128VidFrame>>,

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].

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

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

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.

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.

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.

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<B, X> KeyboardInterface for Ula128<B, X>

fn get_key_state(&self) -> ZXKeyboardMap

Reads the current state of the keyboard.

fn set_key_state(&mut self, keymap: ZXKeyboardMap)

Sets the state of the keyboard.

impl<B, X> Memory for Ula128<B, X>where
    X: MemoryExtension,

type Timestamp = VideoTs

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

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

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

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

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

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.

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.

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

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

impl<B, X> MemoryAccess for Ula128<B, X>where
    X: MemoryExtension,

type Memory = MemPageableRomRamExRom<{MEM32K_SIZE + MEM128K_SIZE}, MEM16K_SIZE, {MEM64K_SIZE/MEM16K_SIZE}>

type MemoryExt = X

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

Returns a read-only reference to the memory extension.

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

Returns a mutable reference to the memory extension.

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

Returns a mutable reference to the memory.

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

Returns a reference to the memory.

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, D: 'a, X: 'a> MicOut<'a> for Ula128<D, X>

type PulseIter = <Ula<MemPageableRomRamExRom<{MEM32K_SIZE + MEM128K_SIZE}, MEM16K_SIZE, {MEM64K_SIZE/MEM16K_SIZE}>, D, X, Ula128VidFrame> as MicOut<'a>>::PulseIter

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

Returns a frame buffered MIC output as a pulse iterator.

impl<B, X: MemoryExtension> ScreenDataProvider for Ula128<B, X>

fn get_screen_mode(&self) -> ScrMode

Should return a currently selected screen mode.

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.

fn screen_primary_ref(&self) -> &ScreenArray

Should return a reference to the primary screen data.

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

Should return a mutable reference to the primary screen data.

fn screen_secondary_ref(&self) -> &[u8; 6912]

Should return a reference to the secondary screen data.

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

Should return a mutable reference to the secondary screen data.

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

Should return a reference to the ULAplus palette.

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

Should return a mutable reference to the ULAplus palette.

impl<B, X> Serialize for Ula128<B, X>where
    B: Serialize,
    X: Serialize,

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

Serialize this value into the given Serde serializer.

impl<B, X> UlaControl for Ula128<B, X>

fn has_late_timings(&self) -> bool

Returns the state of the “late timings” mode.

fn set_late_timings(&mut self, late_timings: bool)

Sets the “late timings” mode on or off.

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

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

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.

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

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

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.

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

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

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.

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

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

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.

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

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

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.

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

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

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<B, X> UlaControlExt for Ula128<B, X>where
    B: BusDevice,
    B::Timestamp: From<VFrameTs<Ula128VidFrame>>,

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

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

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

impl<'a, B, X> UlaPlusInner<'a> for Ula128<B, X>where
    X: MemoryExtension,

type ScreenSwapIter = Drain<'a, VideoTs, Global>

fn is_ula_port(port: u16) -> bool

Returns true if port matches the ULA port.

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

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

fn push_screen_change(&mut self, ts: VideoTs)

Records a shadow screen swap.

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

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

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

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

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

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

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

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

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

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

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.

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.

fn beg_screen_shadow(&self) -> bool

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

fn cur_screen_shadow(&self) -> bool

Returns true if the shadow screen is currently being displayed.

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

Returns references to components necessary for video rendering.

impl<D, X> Video for Ula128<D, X>

type VideoFrame = Ula128VidFrame

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

type Contention = Ula128MemContention

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

fn border_color(&self) -> BorderColor

Returns the current border color.

fn set_border_color(&mut self, border: BorderColor)

Force sets the border area to the given color.

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.

fn visible_screen_bank(&self) -> usize

Returns the screen bank index of the currently visible screen.

fn current_video_ts(&self) -> VideoTs

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

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

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

fn set_video_ts(&mut self, vts: VideoTs)

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

fn flash_state(&self) -> bool

Returns the temporary video flash attribute state.

const PIXEL_DENSITY: u32 = 1u32

The horizontal pixel density.

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.

fn pixel_density() -> u32

Returns the horizontal pixel density.