/// <summary>
/// Add event to ordered pending queue
/// </summary>
/// <param name="_event"></param>
/// <param name="cycles"></param>
/// <param name="phase"></param>
public void schedule(Event _event, long cycles, event_phase_t phase)
{
if (!_event.m_pending)
{
long clk = m_clk + (cycles << 1);
clk += (((m_absClk + clk) & 1) ^ (phase == event_phase_t.EVENT_CLOCK_PHI1 ? 0 : 1));
// Now put in the correct place so we don't need to keep searching the list later.
Event e = m_next;
long count = m_events;
while ((count-- != 0) && (e.m_clk <= clk))
{
e = e.m_next;
}
_event.m_next = e;
_event.m_prev = e.m_prev;
e.m_prev.m_next = _event;
e.m_prev = _event;
_event.m_pending = true;
_event.m_clk = clk;
m_events++;
}
else
{
cancelPending(_event);
schedule(_event, cycles, phase);
}
}
protected MOS656X(EventScheduler context)
: base("VIC Raster")
{
event_context = context;
m_phase = event_phase_t.EVENT_CLOCK_PHI1;
chip(mos656x_model_t.MOS6569);
}
// deserializing
protected override void LoadFromReader(BinaryReader reader)
{
base.LoadFromReader(reader);
for (int i = 0; i < 0x40; i++)
{
regs[i] = reader.ReadInt16();
}
icr = reader.ReadInt16();
idr = reader.ReadInt16();
ctrl1 = reader.ReadInt16();
yrasters = reader.ReadInt32();
xrasters = reader.ReadInt32();
raster_irq = reader.ReadInt32();
raster_x = reader.ReadInt32();
raster_y = reader.ReadInt32();
first_dma_line = reader.ReadInt32();
last_dma_line = reader.ReadInt32();
y_scroll = reader.ReadInt32();
bad_lines_enabled = reader.ReadBoolean();
bad_line = reader.ReadBoolean();
vblanking = reader.ReadBoolean();
lp_triggered = reader.ReadBoolean();
lpx = reader.ReadInt16();
lpy = reader.ReadInt16();
sprite_dma = reader.ReadInt16();
sprite_expand_y = reader.ReadInt16();
for (int i = 0; i < 8; i++)
{
sprite_mc_base[i] = reader.ReadInt16();
}
m_rasterClk = reader.ReadInt64();
m_phase = (event_phase_t)reader.ReadInt16();
}
// deserializing
protected override void LoadFromReader(EventScheduler context, BinaryReader reader)
{
m_phase = (event_phase_t)reader.ReadInt16();
m_accessClk = reader.ReadInt64();
m_gain = reader.ReadInt64();
m_status = reader.ReadBoolean();
m_locked = reader.ReadBoolean();
m_optimisation = reader.ReadByte();
m_sid = new SID(reader);
}
public SID6526(sidPlayer player)
{
m_player = player;
m_eventContext = m_player.m_scheduler;
m_phase = event_phase_t.EVENT_CLOCK_PHI1;
rnd = 0;
m_taEvent = new CiaEvent(this);
clock(0xffff);
reset(false);
}
protected MOS6526(EventScheduler context)
{
m_id = id++;
idr = 0;
event_context = context;
m_phase = event_phase_t.EVENT_CLOCK_PHI1;
m_todPeriod = ~0 & 0xffffffffL;
event_ta = new EventTa(this);
event_tb = new EventTb(this);
event_tod = new EventTod(this);
reset();
}
public ReSID()
: base()
{
m_context = null;
m_phase = event_phase_t.EVENT_CLOCK_PHI1;
m_sid = new SID();
m_gain = 100;
m_status = true;
m_locked = false;
m_optimisation = 0;
reset((short)0);
}
internal Channel(string name, EventScheduler context, XSID xsid)
{
m_id = id++;
m_name = name;
m_context = context;
m_phase = event_phase_t.EVENT_CLOCK_PHI1;
m_xsid = xsid;
sampleEvent = new SampleEvent(this);
galwayEvent = new GalwayEvent(this);
for (int i = 0; i < reg.Length; i++)
{
reg[i] = 0;
}
active = true;
reset();
}
// deserializing
protected void LoadFromReader(BinaryReader reader)
{
m_taEvent_id = reader.ReadInt32();
m_accessClk = reader.ReadInt64();
m_phase = (event_phase_t)reader.ReadInt16();
for (int i = 0; i < 0x10; i++)
{
regs[i] = reader.ReadInt16();
}
cra = reader.ReadInt16();
ta_latch = reader.ReadInt32();
ta = reader.ReadInt32();
rnd = reader.ReadInt64();
m_count = reader.ReadInt32();
locked = reader.ReadBoolean();
}
// deserializing
protected virtual void LoadFromReader(BinaryReader reader)
{
event_ta_id = reader.ReadInt32();
event_tb_id = reader.ReadInt32();
event_tod_id = reader.ReadInt32();
for (int i = 0; i < 0x10; i++)
{
regs[i] = reader.ReadInt16();
}
cnt_high = reader.ReadBoolean();
cra = reader.ReadInt16();
cra_latch = reader.ReadInt16();
dpa = reader.ReadInt16();
ta = reader.ReadInt32();
ta_latch = reader.ReadInt32();
ta_underflow = reader.ReadBoolean();
crb = reader.ReadInt16();
tb = reader.ReadInt32();
tb_latch = reader.ReadInt32();
tb_underflow = reader.ReadBoolean();
sdr_out = reader.ReadInt16();
sdr_buffered = reader.ReadBoolean();
sdr_count = reader.ReadInt32();
icr = reader.ReadInt16();
idr = reader.ReadInt16();
m_accessClk = reader.ReadInt64();
m_phase = (event_phase_t)reader.ReadInt16();
m_todlatched = reader.ReadBoolean();
m_todstopped = reader.ReadBoolean();
for (int i = 0; i < 4; i++)
{
m_todclock[i] = reader.ReadInt16();
m_todalarm[i] = reader.ReadInt16();
m_todlatch[i] = reader.ReadInt16();
}
m_todCycles = reader.ReadInt64();
m_todPeriod = reader.ReadInt64();
}
// deserializing
protected void LoadFromReader(BinaryReader reader)
{
m_id = reader.ReadInt32();
m_name = reader.ReadString();
sampleEvent_id = reader.ReadInt32();
galwayEvent_id = reader.ReadInt32();
m_phase = (event_phase_t)reader.ReadInt16();
for (int i = 0; i < 0x10; i++)
{
reg[i] = reader.ReadInt16();
}
mode = reader.ReadInt32();
active = reader.ReadBoolean();
address = reader.ReadInt32();
cycleCount = reader.ReadInt32();
volShift = reader.ReadInt16();
sampleLimit = reader.ReadInt16();
sample = reader.ReadByte();
samRepeat = reader.ReadInt16();
samScale = reader.ReadInt16();
samOrder = reader.ReadInt16();
samNibble = reader.ReadInt16();
samEndAddr = reader.ReadInt32();
samRepeatAddr = reader.ReadInt32();
samPeriod = reader.ReadInt32();
galTones = reader.ReadInt16();
galInitLength = reader.ReadInt16();
galLength = reader.ReadInt16();
galVolume = reader.ReadInt16();
galLoopWait = reader.ReadInt16();
galNullWait = reader.ReadInt16();
cycles = reader.ReadInt64();
outputs = reader.ReadInt64();
}
public long getTime(long clock, event_phase_t phase)
{
return(((getTime(phase) - clock) << 1) >> 1); // 31 bit res.
}
/// <summary>
/// Get time with respect to a specific clock phase
/// </summary>
/// <param name="phase"></param>
/// <returns></returns>
public long getTime(event_phase_t phase)
{
return((m_absClk + m_clk + (((phase == event_phase_t.EVENT_CLOCK_PHI1) ? 0 : 1) ^ 1)) >> 1);
}
/**
* Get clocks since specified clock in given phase.
*
* @param clock the time to compare to
* @param phase the phase to comapre to
* @return the time between specified clock and now
*/
public Int64 getTime(Int64 clock, event_phase_t phase)
{
return(getTime(phase) - clock);
}
/**
* Get time with respect to a specific clock phase.
*
* @param phase the phase
* @return the time according to specified phase.
*/
public Int64 getTime(event_phase_t phase)
{
return((currentTime + ((Int64)phase ^ 1)) >> 1);
}
/**
* Add event to pending queue.
*
* At PHI2, specify cycles=0 and Phase=PHI1 to fire on the very next PHI1.
*
* @param event the event to add
* @param cycles how many cycles from now to fire
* @param phase the phase when to fire the event
*/
public void schedule(IEvent event_, UInt32 cycles, event_phase_t phase)
{
// this strange formulation always selects the next available slot regardless of specified phase.
event_.SetTriggerTime(currentTime + ((currentTime & 1) ^ (int)phase) + (cycles << 1));
schedule(event_);
}
