// only used for deserializing
public XSID(sidPlayer player, BinaryReader reader, EventList events)
: base()
{
this.events = events;
this.m_player = player;
LoadFromReader(player.m_scheduler, reader);
if (xsidEvent_id == -1)
{
xsidEvent = null;
}
else
{
xsidEvent = events.GetEventById(xsidEvent_id) as xSIDEvent;
#if DEBUG
if (xsidEvent == null)
{
throw new Exception("XSID: xSIDEvent not found");
}
#endif
}
}
public void Dispose()
{
Stop();
wavePlayer?.Dispose();
sidTune = null;
player = null;
}
// only used for deserializing
public EventScheduler(sidPlayer player, BinaryReader reader, int id)
: base(string.Empty)
{
m_id = id;
m_player = player;
LoadFromReader(reader);
}
public sidPlayAudioCore(byte[] sidFileBytes, int sampleRate = 44100, int channels = 2)
{
try
{
sidTune = new SidTune(new MemoryStream(sidFileBytes));
sidTune.selectSong(0);
}
catch (Exception ex)
{
throw new AudioEngineException(0, "[sidPlayAudioCore] Exception when loading the tune...", ex);
}
player = new sidPlayer();
Title = sidTune.Info.InfoString1;
Author = sidTune.Info.InfoString2;
Copyright = sidTune.Info.InfoString3;
var tmpTuneLoaded = player.load(sidTune);
IsTuneLoaded = tmpTuneLoaded == 0;
IsTuneFaulty = tmpTuneLoaded == -2;
var sidCfg = player.config();
sidCfg.clockForced = false;
sidCfg.clockSpeed = SID2Types.sid2_clock_t.SID2_CLOCK_CORRECT;
sidCfg.clockDefault = SID2Types.sid2_clock_t.SID2_CLOCK_CORRECT;
sidCfg.frequency = sampleRate;
sidCfg.playback =
channels != 1 ? SID2Types.sid2_playback_t.sid2_stereo : SID2Types.sid2_playback_t.sid2_mono;
sidCfg.precision = 16;
sidCfg.sidModel = SID2Types.sid2_model_t.SID2_MODEL_CORRECT;
sidCfg.sidDefault = SID2Types.sid2_model_t.SID2_MODEL_CORRECT;
sidCfg.sidSamples = true;
sidCfg.environment = SID2Types.sid2_env_t.sid2_envR;
sidCfg.forceDualSids = false;
sidCfg.optimisation = 2;
if (player.config(sidCfg) != 0)
{
Dispose();
return;
}
try
{
wavePlayer = new WaveOut();
wavePlayer.Init(new sidWaveOut(sampleRate, channels, player));
}
catch (NAudio.MmException ex)
{
throw new AudioEngineException(0, "[sidPlayAudioCore] NAudio initialization exception!", ex);
}
IsPlaying = false;
IsPaused = false;
}
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);
}
public SID6510(EventScheduler context, sidPlayer owner, BinaryReader reader, EventList events)
: base(context, owner, reader, events)
{
delayCycle.func = new ProcessorCycle.FunctionDelegate(sid_delay);
if (procCycle_id == 2)
{
procCycle = new ProcessorCycle[] { delayCycle };
}
}
public SID6510(EventScheduler context, sidPlayer owner)
: base(context, owner)
{
m_mode = SID2Types.sid2_env_t.sid2_envR;
m_framelock = false;
// The hacks for de.quippy.sidplay.sidplay are done with overridden methods of MOS6510
// Used to insert busy delays into the CPU emulation
delayCycle.func = new ProcessorCycle.FunctionDelegate(sid_delay);
}
public XSID(sidPlayer player, SIDEmu sid)
: base()
{
xsidEvent = new xSIDEvent(this);
ch4 = new Channel("CH4", player.m_scheduler, this);
ch5 = new Channel("CH5", player.m_scheduler, this);
muted = (false);
suppressed = (false);
wasRunning = (false);
sidSamples(true);
m_player = player;
m_sid = sid;
m_gain = 100;
}
// only used for deserializing
public SID6526(sidPlayer player, BinaryReader reader, EventList events)
{
m_player = player;
m_eventContext = m_player.m_scheduler;
LoadFromReader(reader);
m_taEvent = events.GetEventById(m_taEvent_id) as CiaEvent;
m_taEvent.m_cia = this;
#if DEBUG
if (m_taEvent == null)
{
throw new Exception("SID6526: CiaEvent not found");
}
#endif
}
// Must lock the SID before using the standard functions
/// <summary>
/// Set execution environment and lock sid to it
/// </summary>
/// <param name="player"></param>
/// <returns></returns>
public bool _lock(sidPlayer player)
{
if (player == null)
{
if (!m_locked)
{
return(false);
}
m_locked = false;
m_context = null;
}
else
{
if (m_locked)
{
return(false);
}
m_locked = true;
m_context = player.m_scheduler;
}
return(true);
}
public EventMixer(sidPlayer player)
: base("Mixer")
{
m_player = player;
}
public C64cia1(sidPlayer player)
: base(player.m_scheduler)
{
m_player = (player);
}
public C64cia2(sidPlayer player)
: base(player.m_scheduler)
{
m_player = player;
}
// only used for deserializing
public C64cia2(sidPlayer player, BinaryReader reader, EventList events)
: base(player.m_scheduler, reader, events)
{
m_player = player;
}
// deserializing
protected void LoadFromReader(sidPlayer player, EventScheduler context, BinaryReader reader)
{
int count = reader.ReadInt32();
for (int i = 0; i < count; i++)
{
int id = reader.ReadInt32();
Event.EventType typ = (Event.EventType)reader.ReadInt16();
switch (typ)
{
case Event.EventType.ciaEvt:
this.Add(new CiaEvent(context, reader, id));
break;
case Event.EventType.cpuEvt:
this.Add(new CPUEvent(context, reader, id));
break;
case Event.EventType.GalwayEvt:
this.Add(new GalwayEvent(context, reader, id));
break;
case Event.EventType.mixerEvt:
this.Add(new EventMixer(player, context, reader, id));
break;
case Event.EventType.RtcEvt:
this.Add(new EventRTC(context, reader, id));
break;
case Event.EventType.SampleEvt:
this.Add(new SampleEvent(context, reader, id));
break;
case Event.EventType.TaEvt:
this.Add(new EventTa(context, reader, id));
break;
case Event.EventType.TbEvt:
this.Add(new EventTb(context, reader, id));
break;
case Event.EventType.TimeWarpEvt:
this.Add(new EventTimeWarp(context, reader, id));
break;
case Event.EventType.TodEvt:
this.Add(new EventTod(context, reader, id));
break;
case Event.EventType.vicEvt:
this.Add(new C64VIC(context.m_player, reader, id));
break;
case Event.EventType.xSidEvt:
this.Add(new xSIDEvent(context, reader, id));
break;
default:
#if DEBUG
throw new Exception("EventList.LoadFromReader: unknown Event id");
#else
break;
#endif
}
}
context.m_next = GetEventById(context.m_next_id);
context.m_prev = GetEventById(context.m_prev_id);
foreach (Event ev in this)
{
ev.m_next = GetEventById(ev.m_next_id, context);
ev.m_prev = GetEventById(ev.m_prev_id, context);
#if DEBUG
if (ev.m_next_id > -1 && ev.m_next == null)
{
throw new Exception("EventList.LoadFromReader: next Event id not found: " + ev.m_next_id.ToString());
}
if (ev.m_prev_id > -1 && ev.m_prev == null)
{
throw new Exception("EventList.LoadFromReader: prev Event id not found: " + ev.m_prev_id.ToString());
}
#endif
}
}
// only used for deserializing
public EventList(sidPlayer player, EventScheduler context, BinaryReader reader)
: base()
{
LoadFromReader(player, context, reader);
}
public sidWaveOut(int sampleRate, int channels, sidPlayer player)
{
WaveFormat = new WaveFormat(sampleRate, 16, channels);
p = player;
}
// only used for deserializing
public EventMixer(sidPlayer player, EventScheduler context, BinaryReader reader, int newId)
: base(context, reader, newId)
{
m_player = player;
}
// only used for deserializing
public C64VIC(sidPlayer player, BinaryReader reader, int newid)
: base(player.m_scheduler, reader, newid)
{
m_player = player;
}
