ShuriZma
/
BizHawk
mirror of https://github.com/TASEmulators/BizHawk.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

apply major discsystem refactorings to emulator cores and client. lots of undone things, most notably generalized RawTOCEntries -> TOCRaw -> Structure synthesis outside of the individual format/api disc loaders. IOW there's no DiscStructure right now. Probably lots of bugs too.

This commit is contained in:
zeromus 2015-07-03 04:11:07 -05:00
parent 71022de580
commit 6dcaa3ca04
22 changed files with 1154 additions and 790 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
BizHawk.Client.DBMan/DiscHash.cs
View File

@ -157,7 +157,7 @@ namespace BizHawk.Client.DBMan
foreach (var track in disc.Structure.Sessions[0].Tracks)
{
crc.Add(track.Start_ABA);
crc.Add(track.LengthInSectors);
crc.Add(track.Length);
}
//ZAMMO: change to disc sector reader, maybe a new class to read multiple
disc.ReadLBA_2352_Flat(0, discbuf, 0, discbuf.Length);

4
BizHawk.Client.DiscoHawk/AudioExtractor.cs
View File

@ -25,9 +25,9 @@ namespace BizHawk.Client.DiscoHawk
if (track.TrackType != DiscStructure.ETrackType.Audio)
continue;
var waveData = new byte[track.LengthInSectors * 2352];
var waveData = new byte[track.Length * 2352];
int startLba = track.Indexes[1].LBA;
for (int sector = 0; sector < track.LengthInSectors; sector++)
for (int sector = 0; sector < track.Length; sector++)
dsr.ReadLBA_2352(startLba + sector, waveData, sector * 2352);
string mp3Path = string.Format("{0} - Track {1:D2}.mp3", Path.Combine(path, filebase), track.Number);

2
BizHawk.Emulation.Cores/Consoles/PC Engine/PCEngine.cs
View File

@ -147,7 +147,7 @@ namespace BizHawk.Emulation.Cores.PCEngine
Init(game, rom);
// the default RomStatusDetails don't do anything with Disc
CoreComm.RomStatusDetails = string.Format("{0}\r\nDisk partial hash:{1}", game.Name, disc.GetHash());
CoreComm.RomStatusDetails = string.Format("{0}\r\nDisk partial hash:{1}", game.Name, new DiscSystem.DiscHasher(disc).OldHash());
SetControllerButtons();
}

17
BizHawk.Emulation.Cores/Consoles/PC Engine/ScsiCDBus.cs
View File

@ -175,7 +175,8 @@ namespace BizHawk.Emulation.Cores.PCEngine
if (DataIn.Count == 0)
{
// read in a sector and shove it in the queue
disc.ReadLBA_2048(CurrentReadingSector, DataIn.GetBuffer(), 0);
DiscSystem.DiscSectorReader dsr = new DiscSectorReader(disc); //TODO - cache reader
dsr.ReadLBA_2048(CurrentReadingSector, DataIn.GetBuffer(), 0);
DataIn.SignalBufferFilled(2048);
CurrentReadingSector++;
SectorsLeftToRead--;
@ -421,7 +422,7 @@ namespace BizHawk.Emulation.Cores.PCEngine
case 0x80: // Set start offset in track units
byte trackNo = CommandBuffer[2].BCDtoBin();
audioStartLBA = disc.Structure.Sessions[0].Tracks[trackNo - 1].Indexes[1].aba - 150;
audioStartLBA = disc.Structure.Sessions[0].Tracks[trackNo - 1].LBA;
break;
}
@ -459,7 +460,7 @@ namespace BizHawk.Emulation.Cores.PCEngine
if (trackNo - 1 >= disc.Structure.Sessions[0].Tracks.Count)
audioEndLBA = disc.LBACount;
else
audioEndLBA = disc.Structure.Sessions[0].Tracks[trackNo - 1].Indexes[1].aba - 150;
audioEndLBA = disc.Structure.Sessions[0].Tracks[trackNo - 1].LBA;
break;
}
@ -509,8 +510,8 @@ namespace BizHawk.Emulation.Cores.PCEngine
subcodeReader.ReadLBA_SubchannelQ(sectorNum, ref subchannelQ);
DataIn.Enqueue(subchannelQ.q_status); // I do not know what status is
DataIn.Enqueue(subchannelQ.q_tno); // track
DataIn.Enqueue(subchannelQ.q_index); // index
DataIn.Enqueue(subchannelQ.q_tno.BCDValue); // track //zero 03-jul-2015 - did I adapt this right>
DataIn.Enqueue(subchannelQ.q_index.BCDValue); // index //zero 03-jul-2015 - did I adapt this right>
DataIn.Enqueue(subchannelQ.min.BCDValue); // M(rel)
DataIn.Enqueue(subchannelQ.sec.BCDValue); // S(rel)
DataIn.Enqueue(subchannelQ.frame.BCDValue); // F(rel)
@ -560,9 +561,9 @@ namespace BizHawk.Emulation.Cores.PCEngine
int lbaPos;
if (track > tracks.Count)
lbaPos = disc.Structure.Sessions[0].length_aba - 150;
lbaPos = disc.TOCRaw.LeadoutLBA.Sector; //zero 03-jul-2015 - did I adapt this right?
else
lbaPos = tracks[track].Indexes[1].aba - 150;
lbaPos = tracks[track].LBA;
byte m, s, f;
Disc.ConvertLBAtoMSF(lbaPos, out m, out s, out f);
@ -572,7 +573,7 @@ namespace BizHawk.Emulation.Cores.PCEngine
DataIn.Enqueue(s.BinToBCD());
DataIn.Enqueue(f.BinToBCD());
if (track > tracks.Count || disc.Structure.Sessions[0].Tracks[track].TrackType == ETrackType.Audio)
if (track > tracks.Count || disc.Structure.Sessions[0].Tracks[track].IsAudio)
DataIn.Enqueue(0);
else
DataIn.Enqueue(4);

29
BizHawk.Emulation.Cores/Consoles/Sega/Saturn/Yabause.cs
View File

@ -41,6 +41,7 @@ namespace BizHawk.Emulation.Cores.Sega.Saturn
static Yabause AttachedCore = null;
GCHandle VideoHandle;
Disc CD;
DiscSectorReader DiscSectorReader;
GCHandle SoundHandle;
bool Disposed = false;
@ -59,9 +60,10 @@ namespace BizHawk.Emulation.Cores.Sega.Saturn
{
ServiceProvider = new BasicServiceProvider(this);
byte[] bios = CoreComm.CoreFileProvider.GetFirmware("SAT", "J", true, "Saturn BIOS is required.");
CoreComm.RomStatusDetails = string.Format("Disk partial hash:{0}", CD.GetHash());
CoreComm.RomStatusDetails = string.Format("Disk partial hash:{0}", new DiscSystem.DiscHasher(CD).OldHash());
this.CoreComm = CoreComm;
this.CD = CD;
DiscSectorReader = new DiscSystem.DiscSectorReader(CD);
SyncSettings = (SaturnSyncSettings)syncSettings ?? new SaturnSyncSettings();
@ -391,7 +393,7 @@ namespace BizHawk.Emulation.Cores.Sega.Saturn
{
// this stuff from yabause's cdbase.c. don't ask me to explain it
var TOC = CD.ReadStructure();
var TOC = CD.Structure;
int[] rTOC = new int[102];
var ses = TOC.Sessions[0];
int ntrk = ses.Tracks.Count;
@ -402,19 +404,13 @@ namespace BizHawk.Emulation.Cores.Sega.Saturn
{
var trk = ses.Tracks[i];
uint t = (uint)trk.Indexes[1].aba;
uint t = (uint)trk.LBA + 150;
if(trk.IsAudio)
t |= 0x01000000;
else
t |= 0x41000000;
switch (trk.TrackType)
{
case DiscSystem.ETrackType.Audio:
t |= 0x01000000;
break;
case DiscSystem.ETrackType.Mode1_2048:
case DiscSystem.ETrackType.Mode1_2352:
case DiscSystem.ETrackType.Mode2_2352:
t |= 0x41000000;
break;
}
rTOC[i] = (int)t;
}
else
@ -425,7 +421,8 @@ namespace BizHawk.Emulation.Cores.Sega.Saturn
rTOC[99] = (int)(rTOC[0] & 0xff000000 | 0x010000);
rTOC[100] = (int)(rTOC[ntrk - 1] & 0xff000000 | (uint)(ntrk << 16));
rTOC[101] = (int)(rTOC[ntrk - 1] & 0xff000000 | (uint)(ses.length_aba));
rTOC[101] = (int)(rTOC[ntrk - 1] & 0xff000000 | (uint)(CD.TOCRaw.LeadoutLBA.Sector)); //zero 03-jul-2014 - maybe off by 150
Marshal.Copy(rTOC, 0, dest, 102);
return 408;
@ -443,7 +440,7 @@ namespace BizHawk.Emulation.Cores.Sega.Saturn
try
{
//CD.ReadABA_2352(FAD, data, 0);
CD.ReadLBA_2352(FAD-150, data, 0); //zero 21-jun-2015 - did I adapt this right?
DiscSectorReader.ReadLBA_2352(FAD - 150, data, 0); //zero 21-jun-2015 - did I adapt this right?
}
catch (Exception e)
{

10
BizHawk.Emulation.Cores/Consoles/Sega/gpgx/GPGX.cs
View File

@ -31,6 +31,7 @@ namespace BizHawk.Emulation.Cores.Consoles.Sega.gpgx
static GPGX AttachedCore = null;
DiscSystem.Disc CD;
DiscSystem.DiscSectorReader DiscSectorReader;
byte[] romfile;
bool drivelight;
@ -92,6 +93,7 @@ namespace BizHawk.Emulation.Cores.Consoles.Sega.gpgx
this.romfile = rom;
this.CD = CD;
this.DiscSectorReader = new DiscSystem.DiscSectorReader(CD);
LibGPGX.INPUT_SYSTEM system_a = LibGPGX.INPUT_SYSTEM.SYSTEM_NONE;
LibGPGX.INPUT_SYSTEM system_b = LibGPGX.INPUT_SYSTEM.SYSTEM_NONE;
@ -292,7 +294,7 @@ namespace BizHawk.Emulation.Cores.Consoles.Sega.gpgx
byte[] data = new byte[2352];
if (lba < CD.LBACount)
{
CD.ReadLBA_2352(lba, data, 0);
DiscSectorReader.ReadLBA_2352(lba, data, 0);
}
else
{
@ -305,7 +307,7 @@ namespace BizHawk.Emulation.Cores.Consoles.Sega.gpgx
else
{
byte[] data = new byte[2048];
CD.ReadLBA_2048(lba, data, 0);
DiscSectorReader.ReadLBA_2048(lba, data, 0);
Marshal.Copy(data, 0, dest, 2048);
drivelight = true;
}
@ -328,8 +330,8 @@ namespace BizHawk.Emulation.Cores.Consoles.Sega.gpgx
{
if (i < ntrack)
{
ret.tracks[i].start = ses.Tracks[i].Indexes[1].aba - 150;
ret.tracks[i].end = ses.Tracks[i].LengthInSectors + ret.tracks[i].start;
ret.tracks[i].start = ses.Tracks[i].LBA;
ret.tracks[i].end = ses.Tracks[i].Length + ret.tracks[i].start;
if (i == ntrack - 1)
{
ret.end = ret.tracks[i].end;

902
BizHawk.Emulation.Cores/Consoles/Sega/gpgx/GPGXDynamic.cs Normal file
View File

@ -0,0 +1,902 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using BizHawk.Common.BufferExtensions;
using BizHawk.Emulation.Common;
using BizHawk.Common;
using System.Runtime.InteropServices;
using System.IO;
using System.ComponentModel;
namespace BizHawk.Emulation.Cores.Consoles.Sega.gpgx
{
[CoreAttributes(
"Genplus-gx",
"",
isPorted: true,
isReleased: true,
portedVersion: "r874",
portedUrl: "https://code.google.com/p/genplus-gx/",
singleInstance: false
)]
public class GPGXDynamic : IEmulator, ISyncSoundProvider, IVideoProvider, ISaveRam, IStatable,
IInputPollable, IDebuggable, ISettable<GPGXDynamic.GPGXSettings, GPGXDynamic.GPGXSyncSettings>, IDriveLight
{
DiscSystem.Disc CD;
DiscSystem.DiscSectorReader CDReader;
byte[] romfile;
bool drivelight;
bool disposed = false;
LibGPGXDynamic gpgx;
ElfRunner elf;
LibGPGXDynamic.load_archive_cb LoadCallback = null;
LibGPGXDynamic.input_cb InputCallback = null;
LibGPGXDynamic.InputData input = new LibGPGXDynamic.InputData();
public enum ControlType
{
None,
OnePlayer,
Normal,
Xea1p,
Activator,
Teamplayer,
Wayplay,
Mouse
};
//[CoreConstructor("GEN")]
public GPGXDynamic(CoreComm comm, byte[] file, object Settings, object SyncSettings)
: this(comm, file, null, Settings, SyncSettings)
{
}
public GPGXDynamic(CoreComm comm, byte[] rom, DiscSystem.Disc CD, object Settings, object SyncSettings)
{
ServiceProvider = new BasicServiceProvider(this);
(ServiceProvider as BasicServiceProvider).Register<ITraceable>(_tracer);
// this can influence some things internally
string romextension = "GEN";
// three or six button?
// http://www.sega-16.com/forum/showthread.php?4398-Forgotten-Worlds-giving-you-GAME-OVER-immediately-Fix-inside&highlight=forgotten%20worlds
//hack, don't use
//romfile = File.ReadAllBytes(@"D:\encodes\bizhawksrc\output\SANIC CD\PierSolar (E).bin");
if (rom != null && rom.Length > 16 * 1024 * 1024)
{
throw new InvalidOperationException("ROM too big! Did you try to load a CD as a ROM?");
}
elf = new ElfRunner(Path.Combine(comm.CoreFileProvider.DllPath(), "gpgx.elf"));
try
{
gpgx = new LibGPGXDynamic();
elf.PopulateInterface(gpgx);
_SyncSettings = (GPGXSyncSettings)SyncSettings ?? new GPGXSyncSettings();
CoreComm = comm;
LoadCallback = new LibGPGXDynamic.load_archive_cb(load_archive);
this.romfile = rom;
this.CD = CD;
CDReader = new DiscSystem.DiscSectorReader(CD);
LibGPGXDynamic.INPUT_SYSTEM system_a = LibGPGXDynamic.INPUT_SYSTEM.SYSTEM_NONE;
LibGPGXDynamic.INPUT_SYSTEM system_b = LibGPGXDynamic.INPUT_SYSTEM.SYSTEM_NONE;
switch (this._SyncSettings.ControlType)
{
case ControlType.None:
default:
break;
case ControlType.Activator:
system_a = LibGPGXDynamic.INPUT_SYSTEM.SYSTEM_ACTIVATOR;
system_b = LibGPGXDynamic.INPUT_SYSTEM.SYSTEM_ACTIVATOR;
break;
case ControlType.Normal:
system_a = LibGPGXDynamic.INPUT_SYSTEM.SYSTEM_MD_GAMEPAD;
system_b = LibGPGXDynamic.INPUT_SYSTEM.SYSTEM_MD_GAMEPAD;
break;
case ControlType.OnePlayer:
system_a = LibGPGXDynamic.INPUT_SYSTEM.SYSTEM_MD_GAMEPAD;
break;
case ControlType.Xea1p:
system_a = LibGPGXDynamic.INPUT_SYSTEM.SYSTEM_XE_A1P;
break;
case ControlType.Teamplayer:
system_a = LibGPGXDynamic.INPUT_SYSTEM.SYSTEM_TEAMPLAYER;
system_b = LibGPGXDynamic.INPUT_SYSTEM.SYSTEM_TEAMPLAYER;
break;
case ControlType.Wayplay:
system_a = LibGPGXDynamic.INPUT_SYSTEM.SYSTEM_WAYPLAY;
system_b = LibGPGXDynamic.INPUT_SYSTEM.SYSTEM_WAYPLAY;
break;
case ControlType.Mouse:
system_a = LibGPGXDynamic.INPUT_SYSTEM.SYSTEM_MD_GAMEPAD;
// seems like mouse in port 1 would be supported, but not both at the same time
system_b = LibGPGXDynamic.INPUT_SYSTEM.SYSTEM_MOUSE;
break;
}
if (!gpgx.gpgx_init(romextension, LoadCallback, this._SyncSettings.UseSixButton, system_a, system_b, this._SyncSettings.Region))
throw new Exception("gpgx_init() failed");
{
int fpsnum = 60;
int fpsden = 1;
gpgx.gpgx_get_fps(ref fpsnum, ref fpsden);
CoreComm.VsyncNum = fpsnum;
CoreComm.VsyncDen = fpsden;
DisplayType = CoreComm.VsyncRate > 55 ? DisplayType.NTSC : DisplayType.PAL;
}
// compute state size
{
byte[] tmp = new byte[gpgx.gpgx_state_max_size()];
int size = gpgx.gpgx_state_size(tmp, tmp.Length);
if (size <= 0)
throw new Exception("Couldn't Determine GPGX internal state size!");
savebuff = new byte[size];
savebuff2 = new byte[savebuff.Length + 13];
Console.WriteLine("GPGX Internal State Size: {0}", size);
}
SetControllerDefinition();
// pull the default video size from the core
update_video_initial();
SetMemoryDomains();
InputCallback = new LibGPGXDynamic.input_cb(input_callback);
gpgx.gpgx_set_input_callback(InputCallback);
if (CD != null)
DriveLightEnabled = true;
PutSettings((GPGXSettings)Settings ?? new GPGXSettings());
InitMemCallbacks();
KillMemCallbacks();
}
catch
{
Dispose();
throw;
}
}
public IEmulatorServiceProvider ServiceProvider { get; private set; }
public bool DriveLightEnabled { get; private set; }
public bool DriveLightOn { get; private set; }
/// <summary>
/// core callback for file loading
/// </summary>
/// <param name="filename">string identifying file to be loaded</param>
/// <param name="buffer">buffer to load file to</param>
/// <param name="maxsize">maximum length buffer can hold</param>
/// <returns>actual size loaded, or 0 on failure</returns>
int load_archive(string filename, IntPtr buffer, int maxsize)
{
byte[] srcdata = null;
if (buffer == IntPtr.Zero)
{
Console.WriteLine("Couldn't satisfy firmware request {0} because buffer == NULL", filename);
return 0;
}
if (filename == "PRIMARY_ROM")
{
if (romfile == null)
{
Console.WriteLine("Couldn't satisfy firmware request PRIMARY_ROM because none was provided.");
return 0;
}
srcdata = romfile;
}
else if (filename == "PRIMARY_CD" || filename == "SECONDARY_CD")
{
if (filename == "PRIMARY_CD" && romfile != null)
{
Console.WriteLine("Declined to satisfy firmware request PRIMARY_CD because PRIMARY_ROM was provided.");
return 0;
}
else
{
if (CD == null)
{
Console.WriteLine("Couldn't satisfy firmware request {0} because none was provided.", filename);
return 0;
}
srcdata = GetCDData();
if (srcdata.Length != maxsize)
{
Console.WriteLine("Couldn't satisfy firmware request {0} because of struct size.", filename);
return 0;
}
}
}
else
{
// use fromtend firmware interface
string firmwareID = null;
switch (filename)
{
case "CD_BIOS_EU": firmwareID = "CD_BIOS_EU"; break;
case "CD_BIOS_JP": firmwareID = "CD_BIOS_JP"; break;
case "CD_BIOS_US": firmwareID = "CD_BIOS_US"; break;
default:
break;
}
if (firmwareID != null)
{
// this path will be the most common PEBKAC error, so be a bit more vocal about the problem
srcdata = CoreComm.CoreFileProvider.GetFirmware("GEN", firmwareID, false, "GPGX firmwares are usually required.");
if (srcdata == null)
{
Console.WriteLine("Frontend couldn't satisfy firmware request GEN:{0}", firmwareID);
return 0;
}
}
else
{
Console.WriteLine("Unrecognized firmware request {0}", filename);
return 0;
}
}
if (srcdata != null)
{
if (srcdata.Length > maxsize)
{
Console.WriteLine("Couldn't satisfy firmware request {0} because {1} > {2}", filename, srcdata.Length, maxsize);
return 0;
}
else
{
Marshal.Copy(srcdata, 0, buffer, srcdata.Length);
Console.WriteLine("Firmware request {0} satisfied at size {1}", filename, srcdata.Length);
return srcdata.Length;
}
}
else
{
throw new Exception();
//Console.WriteLine("Couldn't satisfy firmware request {0} for unknown reasons", filename);
//return 0;
}
}
void CDRead(int lba, IntPtr dest, bool audio)
{
if (audio)
{
byte[] data = new byte[2352];
if (lba < CD.LBACount)
{
CDReader.ReadLBA_2352(lba, data, 0);
}
else
{
// audio seems to read slightly past the end of disks; probably innoculous
// just send back 0s.
// Console.WriteLine("!!{0} >= {1}", lba, CD.LBACount);
}
Marshal.Copy(data, 0, dest, 2352);
}
else
{
byte[] data = new byte[2048];
CDReader.ReadLBA_2048(lba, data, 0);
Marshal.Copy(data, 0, dest, 2048);
drivelight = true;
}
}
LibGPGXDynamic.cd_read_cb cd_callback_handle;
unsafe byte[] GetCDData()
{
LibGPGXDynamic.CDData ret = new LibGPGXDynamic.CDData();
int size = Marshal.SizeOf(ret);
ret.readcallback = cd_callback_handle = new LibGPGXDynamic.cd_read_cb(CDRead);
var ses = CD.Structure.Sessions[0];
int ntrack = ses.Tracks.Count;
// bet you a dollar this is all wrong
for (int i = 0; i < LibGPGXDynamic.CD_MAX_TRACKS; i++)
{
if (i < ntrack)
{
ret.tracks[i].start = ses.Tracks[i].LBA;
ret.tracks[i].end = ses.Tracks[i].Length + ret.tracks[i].start;
if (i == ntrack - 1)
{
ret.end = ret.tracks[i].end;
ret.last = ntrack;
}
}
else
{
ret.tracks[i].start = 0;
ret.tracks[i].end = 0;
}
}
byte[] retdata = new byte[size];
fixed (byte* p = &retdata[0])
{
Marshal.StructureToPtr(ret, (IntPtr)p, false);
}
return retdata;
}
#region controller
/// <summary>
/// size of native input struct
/// </summary>
int inputsize;
GPGXControlConverterDynamic ControlConverter;
public ControllerDefinition ControllerDefinition { get; private set; }
public IController Controller { get; set; }
void SetControllerDefinition()
{
inputsize = Marshal.SizeOf(typeof(LibGPGXDynamic.InputData));
if (!gpgx.gpgx_get_control(input, inputsize))
throw new Exception("gpgx_get_control() failed");
ControlConverter = new GPGXControlConverterDynamic(input);
ControllerDefinition = ControlConverter.ControllerDef;
}
public LibGPGXDynamic.INPUT_DEVICE[] GetDevices()
{
return (LibGPGXDynamic.INPUT_DEVICE[])input.dev.Clone();
}
// core callback for input
void input_callback()
{
InputCallbacks.Call();
IsLagFrame = false;
}
private readonly InputCallbackSystem _inputCallbacks = new InputCallbackSystem();
public IInputCallbackSystem InputCallbacks { get { return _inputCallbacks; } }
private readonly TraceBuffer _tracer = new TraceBuffer();
#endregion
// TODO: use render and rendersound
public void FrameAdvance(bool render, bool rendersound = true)
{
if (Controller["Reset"])
gpgx.gpgx_reset(false);
if (Controller["Power"])
gpgx.gpgx_reset(true);
// do we really have to get each time? nothing has changed
if (!gpgx.gpgx_get_control(input, inputsize))
throw new Exception("gpgx_get_control() failed!");
ControlConverter.ScreenWidth = vwidth;
ControlConverter.ScreenHeight = vheight;
ControlConverter.Convert(Controller, input);
if (!gpgx.gpgx_put_control(input, inputsize))
throw new Exception("gpgx_put_control() failed!");
IsLagFrame = true;
Frame++;
drivelight = false;
gpgx.gpgx_advance();
update_video();
update_audio();
if (IsLagFrame)
LagCount++;
if (CD != null)
DriveLightOn = drivelight;
}
public int Frame { get; private set; }
public int LagCount { get; private set; }
public bool IsLagFrame { get; private set; }
public string SystemId { get { return "GEN"; } }
public bool DeterministicEmulation { get { return true; } }
public string BoardName { get { return null; } }
public CoreComm CoreComm { get; private set; }
#region saveram
byte[] DisposedSaveRam = null;
public byte[] CloneSaveRam()
{
if (disposed)
{
if (DisposedSaveRam != null)
{
return (byte[])DisposedSaveRam.Clone();
}
else
{
return new byte[0];
}
}
else
{
int size = 0;
IntPtr area = IntPtr.Zero;
gpgx.gpgx_get_sram(ref area, ref size);
if (size <= 0 || area == IntPtr.Zero)
return new byte[0];
gpgx.gpgx_sram_prepread();
byte[] ret = new byte[size];
Marshal.Copy(area, ret, 0, size);
return ret;
}
}
public void StoreSaveRam(byte[] data)
{
if (disposed)
{
throw new ObjectDisposedException(typeof(GPGX).ToString());
}
else
{
int size = 0;
IntPtr area = IntPtr.Zero;
gpgx.gpgx_get_sram(ref area, ref size);
if (size <= 0 || area == IntPtr.Zero)
return;
if (size != data.Length)
throw new Exception("Unexpected saveram size");
Marshal.Copy(data, 0, area, size);
gpgx.gpgx_sram_commitwrite();
}
}
public bool SaveRamModified
{
get
{
if (disposed)
{
return DisposedSaveRam != null;
}
else
{
int size = 0;
IntPtr area = IntPtr.Zero;
gpgx.gpgx_get_sram(ref area, ref size);
return size > 0 && area != IntPtr.Zero;
}
}
}
#endregion
public void ResetCounters()
{
Frame = 0;
IsLagFrame = false;
LagCount = 0;
}
#region savestates
private byte[] savebuff;
private byte[] savebuff2;
public void SaveStateText(System.IO.TextWriter writer)
{
var temp = SaveStateBinary();
temp.SaveAsHexFast(writer);
// write extra copy of stuff we don't use
writer.WriteLine("Frame {0}", Frame);
}
public void LoadStateText(System.IO.TextReader reader)
{
string hex = reader.ReadLine();
byte[] state = new byte[hex.Length / 2];
state.ReadFromHexFast(hex);
LoadStateBinary(new System.IO.BinaryReader(new System.IO.MemoryStream(state)));
}
public void SaveStateBinary(System.IO.BinaryWriter writer)
{
if (!gpgx.gpgx_state_save(savebuff, savebuff.Length))
throw new Exception("gpgx_state_save() returned false");
writer.Write(savebuff.Length);
writer.Write(savebuff);
// other variables
writer.Write(Frame);
writer.Write(LagCount);
writer.Write(IsLagFrame);
}
public void LoadStateBinary(System.IO.BinaryReader reader)
{
int newlen = reader.ReadInt32();
if (newlen != savebuff.Length)
throw new Exception("Unexpected state size");
reader.Read(savebuff, 0, savebuff.Length);
if (!gpgx.gpgx_state_load(savebuff, savebuff.Length))
throw new Exception("gpgx_state_load() returned false");
// other variables
Frame = reader.ReadInt32();
LagCount = reader.ReadInt32();
IsLagFrame = reader.ReadBoolean();
update_video();
}
public byte[] SaveStateBinary()
{
var ms = new System.IO.MemoryStream(savebuff2, true);
var bw = new System.IO.BinaryWriter(ms);
SaveStateBinary(bw);
bw.Flush();
ms.Close();
return savebuff2;
}
public bool BinarySaveStatesPreferred { get { return true; } }
#endregion
#region debugging tools
private IMemoryDomains MemoryDomains;
unsafe void SetMemoryDomains()
{
var mm = new List<MemoryDomain>();
for (int i = LibGPGXDynamic.MIN_MEM_DOMAIN; i <= LibGPGXDynamic.MAX_MEM_DOMAIN; i++)
{
IntPtr area = IntPtr.Zero;
int size = 0;
IntPtr pname = gpgx.gpgx_get_memdom(i, ref area, ref size);
if (area == IntPtr.Zero || pname == IntPtr.Zero || size == 0)
continue;
string name = Marshal.PtrToStringAnsi(pname);
if (name == "VRAM")
{
// vram pokes need to go through hook which invalidates cached tiles
byte* p = (byte*)area;
mm.Add(new MemoryDomain(name, size, MemoryDomain.Endian.Unknown,
delegate(long addr)
{
if (addr < 0 || addr >= 65536)
throw new ArgumentOutOfRangeException();
return p[addr ^ 1];
},
delegate(long addr, byte val)
{
if (addr < 0 || addr >= 65536)
throw new ArgumentOutOfRangeException();
gpgx.gpgx_poke_vram(((int)addr) ^ 1, val);
},
byteSize: 2));
}
else
{
var byteSize = name.Contains("Z80") ? 1 : 2;
mm.Add(MemoryDomain.FromIntPtrSwap16(name, size, MemoryDomain.Endian.Big, area, writable: true, byteSize: byteSize));
}
}
MemoryDomains = new MemoryDomainList(mm);
(ServiceProvider as BasicServiceProvider).Register<IMemoryDomains>(MemoryDomains);
}
public IDictionary<string, RegisterValue> GetCpuFlagsAndRegisters()
{
LibGPGXDynamic.RegisterInfo[] regs = new LibGPGXDynamic.RegisterInfo[gpgx.gpgx_getmaxnumregs()];
int n = gpgx.gpgx_getregs(regs);
if (n > regs.Length)
throw new InvalidOperationException("A buffer overrun has occured!");
var ret = new Dictionary<string, RegisterValue>();
for (int i = 0; i < n; i++)
{
// el hacko
string name = Marshal.PtrToStringAnsi(regs[i].Name);
byte size = 32;
if (name.Contains("68K SR") || name.StartsWith("Z80"))
size = 16;
ret[Marshal.PtrToStringAnsi(regs[i].Name)] =
new RegisterValue { BitSize = size, Value = (ulong)regs[i].Value };
}
return ret;
}
public bool CanStep(StepType type) { return false; }
[FeatureNotImplemented]
public void Step(StepType type) { throw new NotImplementedException(); }
[FeatureNotImplemented]
public void SetCpuRegister(string register, int value)
{
throw new NotImplementedException();
}
public void UpdateVDPViewContext(LibGPGXDynamic.VDPView view)
{
gpgx.gpgx_get_vdp_view(view);
gpgx.gpgx_flush_vram(); // fully regenerate internal caches as needed
}
private readonly MemoryCallbackSystem _memoryCallbacks = new MemoryCallbackSystem();
public IMemoryCallbackSystem MemoryCallbacks { get { return _memoryCallbacks; } }
LibGPGXDynamic.mem_cb ExecCallback;
LibGPGXDynamic.mem_cb ReadCallback;
LibGPGXDynamic.mem_cb WriteCallback;
void InitMemCallbacks()
{
ExecCallback = new LibGPGXDynamic.mem_cb(a => MemoryCallbacks.CallExecutes(a));
ReadCallback = new LibGPGXDynamic.mem_cb(a => MemoryCallbacks.CallReads(a));
WriteCallback = new LibGPGXDynamic.mem_cb(a => MemoryCallbacks.CallWrites(a));
_memoryCallbacks.ActiveChanged += RefreshMemCallbacks;
}
void RefreshMemCallbacks()
{
gpgx.gpgx_set_mem_callback(
MemoryCallbacks.HasReads ? ReadCallback : null,
MemoryCallbacks.HasWrites ? WriteCallback : null,
MemoryCallbacks.HasExecutes ? ExecCallback : null);
}
void KillMemCallbacks()
{
gpgx.gpgx_set_mem_callback(null, null, null);
}
#endregion
public void Dispose()
{
if (!disposed)
{
// if (SaveRamModified)
// DisposedSaveRam = CloneSaveRam();
// KillMemCallbacks();
if (CD != null)
{
CD.Dispose();
}
if (elf != null)
{
elf.Dispose();
elf = null;
gpgx = null;
}
disposed = true;
}
}
#region SoundProvider
short[] samples = new short[4096];
int nsamp = 0;
public ISoundProvider SoundProvider { get { return null; } }
public ISyncSoundProvider SyncSoundProvider { get { return this; } }
public bool StartAsyncSound() { return false; }
public void EndAsyncSound() { }
public void GetSamples(out short[] samples, out int nsamp)
{
nsamp = this.nsamp;
samples = this.samples;
this.nsamp = 0;
}
public void DiscardSamples()
{
this.nsamp = 0;
}
void update_audio()
{
IntPtr src = IntPtr.Zero;
gpgx.gpgx_get_audio(ref nsamp, ref src);
if (src != IntPtr.Zero)
{
Marshal.Copy(src, samples, 0, nsamp * 2);
}
}
#endregion
#region VideoProvider
public DisplayType DisplayType { get; private set; }
int[] vidbuff = new int[0];
int vwidth;
int vheight;
public int[] GetVideoBuffer() { return vidbuff; }
public int VirtualWidth { get { return BufferWidth; } } // TODO
public int VirtualHeight { get { return BufferHeight; } } // TODO
public int BufferWidth { get { return vwidth; } }
public int BufferHeight { get { return vheight; } }
public int BackgroundColor { get { return unchecked((int)0xff000000); } }
void update_video_initial()
{
// hack: you should call update_video() here, but that gives you 256x192 on frame 0
// and we know that we only use GPGX to emulate genesis games that will always be 320x224 immediately afterwards
// so instead, just assume a 320x224 size now; if that happens to be wrong, it'll be fixed soon enough.
vwidth = 320;
vheight = 224;
vidbuff = new int[vwidth * vheight];
for (int i = 0; i < vidbuff.Length; i++)
vidbuff[i] = unchecked((int)0xff000000);
}
unsafe void update_video()
{
int pitch = 0;
IntPtr src = IntPtr.Zero;
gpgx.gpgx_get_video(ref vwidth, ref vheight, ref pitch, ref src);
if (vidbuff.Length < vwidth * vheight)
vidbuff = new int[vwidth * vheight];
int rinc = (pitch / 4) - vwidth;
fixed (int* pdst_ = &vidbuff[0])
{
int* pdst = pdst_;
int* psrc = (int*)src;
for (int j = 0; j < vheight; j++)
{
for (int i = 0; i < vwidth; i++)
*pdst++ = *psrc++;// | unchecked((int)0xff000000);
psrc += rinc;
}
}
}
#endregion
#region Settings
GPGXSyncSettings _SyncSettings;
GPGXSettings _Settings;
public GPGXSettings GetSettings() { return _Settings.Clone(); }
public GPGXSyncSettings GetSyncSettings() { return _SyncSettings.Clone(); }
public bool PutSettings(GPGXSettings o)
{
_Settings = o;
gpgx.gpgx_set_draw_mask(_Settings.GetDrawMask());
return false;
}
public bool PutSyncSettings(GPGXSyncSettings o)
{
bool ret = GPGXSyncSettings.NeedsReboot(_SyncSettings, o);
_SyncSettings = o;
return ret;
}
public class GPGXSettings
{
[DisplayName("Background Layer A")]
[Description("True to draw BG layer A")]
[DefaultValue(true)]
public bool DrawBGA { get; set; }
[DisplayName("Background Layer B")]
[Description("True to draw BG layer B")]
[DefaultValue(true)]
public bool DrawBGB { get; set; }
[DisplayName("Background Layer W")]
[Description("True to draw BG layer W")]
[DefaultValue(true)]
public bool DrawBGW { get; set; }
public GPGXSettings()
{
SettingsUtil.SetDefaultValues(this);
}
public GPGXSettings Clone()
{
return (GPGXSettings)MemberwiseClone();
}
public LibGPGXDynamic.DrawMask GetDrawMask()
{
LibGPGXDynamic.DrawMask ret = 0;
if (DrawBGA) ret |= LibGPGXDynamic.DrawMask.BGA;
if (DrawBGB) ret |= LibGPGXDynamic.DrawMask.BGB;
if (DrawBGW) ret |= LibGPGXDynamic.DrawMask.BGW;
return ret;
}
}
public class GPGXSyncSettings
{
[DisplayName("Use Six Button Controllers")]
[Description("Controls the type of any attached normal controllers; six button controllers are used if true, otherwise three button controllers. Some games don't work correctly with six button controllers. Not relevant if other controller types are connected.")]
[DefaultValue(true)]
public bool UseSixButton { get; set; }
[DisplayName("Control Type")]
[Description("Sets the type of controls that are plugged into the console. Some games will automatically load with a different control type.")]
[DefaultValue(ControlType.Normal)]
public ControlType ControlType { get; set; }
[DisplayName("Autodetect Region")]
[Description("Sets the region of the emulated console. Many games can run on multiple regions and will behave differently on different ones. Some games may require a particular region.")]
[DefaultValue(LibGPGXDynamic.Region.Autodetect)]
public LibGPGXDynamic.Region Region { get; set; }
public GPGXSyncSettings()
{
SettingsUtil.SetDefaultValues(this);
}
public GPGXSyncSettings Clone()
{
return (GPGXSyncSettings)MemberwiseClone();
}
public static bool NeedsReboot(GPGXSyncSettings x, GPGXSyncSettings y)
{
return !DeepEquality.DeepEquals(x, y);
}
}
#endregion
}
}

6
BizHawk.Emulation.Cores/Consoles/Sony/PSX/Octoshock.cs
View File

@ -177,7 +177,7 @@ namespace BizHawk.Emulation.Cores.Sony.PSX
////the lead-out track is to be synthesized
tracks101[read_target->last_track + 1].adr = 1;
tracks101[read_target->last_track + 1].control = 0;
tracks101[read_target->last_track + 1].lba = (uint)Disc.TOCRaw.LeadoutTimestamp.Sector;
tracks101[read_target->last_track + 1].lba = (uint)Disc.TOCRaw.LeadoutLBA.Sector;
//element 100 is to be copied as the lead-out track
tracks101[100] = tracks101[read_target->last_track + 1];
@ -198,7 +198,9 @@ namespace BizHawk.Emulation.Cores.Sony.PSX
if (subcodeLog) Console.Write("{0}|", lba);
else if (readLog) Console.WriteLine("Read Sector: " + lba);
Disc.ReadLBA_2352(lba, SectorBuffer, 0);
//todo - cache reader
DiscSystem.DiscSectorReader dsr = new DiscSystem.DiscSectorReader(Disc);
dsr.ReadLBA_2352(lba, SectorBuffer, 0);
Marshal.Copy(SectorBuffer, 0, new IntPtr(dst), 2352);
Disc.ReadLBA_SectorEntry(lba).SubcodeSector.ReadSubcodeDeinterleaved(SectorBuffer, 0);
Marshal.Copy(SectorBuffer, 0, new IntPtr((byte*)dst + 2352), 96);

3
BizHawk.Emulation.Cores/FileID.cs
View File

@ -218,8 +218,9 @@ namespace BizHawk.Emulation.Cores
FileIDResults IdentifyDisc(IdentifyJob job)
{
var discIdentifier = new DiscSystem.DiscIdentifier(job.Disc);
//DiscSystem could use some newer approaches from this file (instead of parsing ISO filesystem... maybe?)
switch (job.Disc.DetectDiscType())
switch (discIdentifier.DetectDiscType())
{
case DiscSystem.DiscType.SegaSaturn:
return new FileIDResults(new FileIDResult(FileIDType.Saturn, 100));

10
BizHawk.Emulation.DiscSystem/API/Disc.API.cs
View File

@ -100,16 +100,6 @@ namespace BizHawk.Emulation.DiscSystem
/// </summary>
public int ABACount { get { return Sectors.Count; } }
/// <summary>
/// main api for reading the structure from a disc.
/// TODO - this is weak sauce. Why this one method to read something which is nothing but returning a structure? Lame.
/// Either get rid of this, or rethink the disc API wrapper concept
/// </summary>
public DiscStructure ReadStructure()
{
return Structure;
}
// converts LBA to minute:second:frame format.
//TODO - somewhat redundant with Timestamp, which is due for refactoring into something not cue-related
public static void ConvertLBAtoMSF(int lba, out byte m, out byte s, out byte f)

14
BizHawk.Emulation.DiscSystem/API/OldHash.cs → BizHawk.Emulation.DiscSystem/API/DiscHasher.cs
View File

@ -4,9 +4,9 @@ using BizHawk.Common.BufferExtensions;
namespace BizHawk.Emulation.DiscSystem
{
public class OldHasher
public class DiscHasher
{
public OldHasher(Disc disc)
public DiscHasher(Disc disc)
{
this.disc = disc;
}
@ -16,18 +16,18 @@ namespace BizHawk.Emulation.DiscSystem
// gets an identifying hash. hashes the first 512 sectors of
// the first data track on the disc.
//TODO - this is a very platform-specific thing. hashing the TOC may be faster and be just as effective. so, rename it appropriately
public string GetHash()
public string OldHash()
{
byte[] buffer = new byte[512 * 2352];
DiscSectorReader dsr = new DiscSectorReader(disc);
foreach (var track in disc.Structure.Sessions[0].Tracks)
{
if (track.TrackType == DiscStructure.ETrackType.Audio)
if (track.IsAudio)
continue;
int lba_len = Math.Min(track.LengthInSectors, 512);
for (int s = 0; s < 512 && s < track.LengthInSectors; s++)
dsr.ReadLBA_2352(track.Indexes[1].LBA + s, buffer, s * 2352);
int lba_len = Math.Min(track.Length, 512);
for (int s = 0; s < 512 && s < track.Length; s++)
dsr.ReadLBA_2352(track.LBA + s, buffer, s * 2352);
return buffer.HashMD5(0, lba_len * 2352);
}

4
BizHawk.Emulation.DiscSystem/API/DiscSectorReader.cs
View File

@ -182,6 +182,10 @@ namespace BizHawk.Emulation.DiscSystem
/// <summary>
/// reads 2048 bytes of user data from a sector.
/// This is only valid for Mode 1 and XA Mode 2 (Form 1) sectors.
/// Attempting it on any other sectors is ill-defined.
/// If any console is trying to do that, we'll have to add a policy for it, or handle it in the console.
/// (We can add a method to this API that checks the type of a sector to make that easier)
/// </summary>
public int ReadLBA_2048(int lba, byte[] buffer, int offset)
{

11
BizHawk.Emulation.DiscSystem/API/DiscStream.cs
View File

@ -49,6 +49,8 @@ namespace BizHawk.Emulation.DiscSystem
/// NOTE - actually even THAT is probably a bad idea. sector types can change on the fly.
/// this class promises something it can't deliver. (it's only being used to scan an ISO disc)
/// Well, we could make code that is full of red flags and warnings like "if this ISNT a 2048 byte sector ISO disc, then this wont work"
///
/// TODO - Receive some information about the track that this stream is modeling, and have the stream return EOF at the end of the track?
/// </summary>
public class DiscStream : System.IO.Stream
{
@ -57,8 +59,8 @@ namespace BizHawk.Emulation.DiscSystem
Disc Disc;
long currPosition;
int cachedSector;
byte[] cachedSectorBuffer;
int cachedSector;
DiscSectorReader dsr;
public DiscStream(Disc disc, EDiscStreamView view, int from_lba)
@ -103,13 +105,13 @@ namespace BizHawk.Emulation.DiscSystem
}
//TODO - I'm not sure everything in here makes sense right now..
public override int Read(byte[] buffer, int offset, int count)
{
long remainInDisc = Length - currPosition;
if (count > remainInDisc)
count = (int)Math.Min(remainInDisc, int.MaxValue);
int sectorBufferHint = -1;
int remain = count;
int readed = 0;
while (remain > 0)
@ -120,12 +122,11 @@ namespace BizHawk.Emulation.DiscSystem
int remains_in_lba = SectorSize - lba_within;
if (remains_in_lba < todo)
todo = remains_in_lba;
if (sectorBufferHint != lba)
if (cachedSector != lba)
{
//todo - read sector to cachedSectorBuffer
dsr.ReadLBA_2048(lba, cachedSectorBuffer, 0);
cachedSector = lba;
}
sectorBufferHint = lba;
Array.Copy(cachedSectorBuffer, lba_within, buffer, offset, todo);
offset += todo;
remain -= todo;

2
BizHawk.Emulation.DiscSystem/BizHawk.Emulation.DiscSystem.csproj
View File

@ -52,9 +52,9 @@
</Compile>
<Compile Include="API\Disc.API.cs" />
<Compile Include="API\Disc.ID.cs" />
<Compile Include="API\DiscHasher.cs" />
<Compile Include="API\DiscSectorReader.cs" />
<Compile Include="API\DiscStream.cs" />
<Compile Include="API\OldHash.cs" />
<Compile Include="Blobs\Blob_ECM.cs" />
<Compile Include="Blobs\Blob_RawFile.cs" />
<Compile Include="Blobs\Blob_WaveFile.cs" />

100
BizHawk.Emulation.DiscSystem/CCD_format.cs
View File

@ -397,20 +397,24 @@ namespace BizHawk.Emulation.DiscSystem
sw.WriteLine("PFrame={0}", entry.QData.ap_frame.DecimalValue);
sw.WriteLine("PLBA={0}", entry.QData.AP_Timestamp.Sector - 150); //remember to adapt the absolute MSF to an LBA (this field is redundant...)
}
for (int i = 0; i < disc.Structure.Sessions[0].Tracks.Count; i++)
{
var st = disc.Structure.Sessions[0].Tracks[i];
sw.WriteLine("[TRACK {0}]", st.Number);
sw.WriteLine("MODE={0}", st.ModeHeuristic); //MAYBE A BAD PLAN!
//dont write an index=0 identical to an index=1. It might work, or it might not.
int idx = 0;
if (st.Indexes[0].LBA == st.Indexes[1].LBA)
idx = 1;
for (; idx < st.Indexes.Count; idx++)
{
sw.WriteLine("INDEX {0}={1}", st.Indexes[idx].Number, st.Indexes[idx].LBA);
}
}
//TODO - this is nonsense, right? the whole CCD track and index list isn't really needed.
//at least not for us when we'll always be writing a .sub file
//for (int i = 0; i < disc.Structure.Sessions[0].Tracks.Count; i++)
//{
// var st = disc.Structure.Sessions[0].Tracks[i];
// sw.WriteLine("[TRACK {0}]", st.Number);
// sw.WriteLine("MODE={0}", st.ModeHeuristic); //MAYBE A BAD PLAN!
// //dont write an index=0 identical to an index=1. It might work, or it might not.
// int idx = 0;
// if (st.Indexes[0].LBA == st.Indexes[1].LBA)
// idx = 1;
// for (; idx < st.Indexes.Count; idx++)
// {
// sw.WriteLine("INDEX {0}={1}", st.Indexes[idx].Number, st.Indexes[idx].LBA);
// }
//}
}
//dump the img and sub
@ -538,45 +542,45 @@ namespace BizHawk.Emulation.DiscSystem
tocSynth.Run();
disc.TOCRaw = tocSynth.Result;
disc.Structure = new DiscStructure();
var ses = new DiscStructure.Session();
disc.Structure.Sessions.Add(ses);
//disc.Structure = new DiscStructure();
//var ses = new DiscStructure.Session();
//disc.Structure.Sessions.Add(ses);
for(int i=1;i<=99;i++)
{
if(!ccdf.TracksByNumber.ContainsKey(i))
continue;
var ccdt = ccdf.TracksByNumber[i];
//for(int i=1;i<=99;i++)
//{
// if(!ccdf.TracksByNumber.ContainsKey(i))
// continue;
// var ccdt = ccdf.TracksByNumber[i];
DiscStructure.Track track = new DiscStructure.Track() { Number = i };
ses.Tracks.Add(track);
// DiscStructure.Track track = new DiscStructure.Track() { Number = i };
// ses.Tracks.Add(track);
//if index 0 is missing, add it
if (!ccdt.Indexes.ContainsKey(0))
track.Indexes.Add(new DiscStructure.Index { Number = 0, LBA = ccdt.Indexes[1] });
for(int j=1;j<=99;j++)
if (ccdt.Indexes.ContainsKey(j))
track.Indexes.Add(new DiscStructure.Index { Number = j, LBA = ccdt.Indexes[j] });
// //if index 0 is missing, add it
// if (!ccdt.Indexes.ContainsKey(0))
// track.Indexes.Add(new DiscStructure.Index { Number = 0, LBA = ccdt.Indexes[1] });
// for(int j=1;j<=99;j++)
// if (ccdt.Indexes.ContainsKey(j))
// track.Indexes.Add(new DiscStructure.Index { Number = j, LBA = ccdt.Indexes[j] });
//TODO - this should only be used in case the .sub needs reconstructing
//determination should be done from heuristics.
//if we keep this, it should just be as a memo that later heuristics can use. For example: 'use guidance from original disc image'
track.ModeHeuristic = ccdt.Mode;
// //TODO - this should only be used in case the .sub needs reconstructing
// //determination should be done from heuristics.
// //if we keep this, it should just be as a memo that later heuristics can use. For example: 'use guidance from original disc image'
// track.ModeHeuristic = ccdt.Mode;
//TODO - this should be deleted anyway (
switch (ccdt.Mode)
{
case 0:
track.TrackType = DiscStructure.ETrackType.Audio; //for CCD, this means audio, apparently.
break;
case 1:
case 2:
track.TrackType = DiscStructure.ETrackType.Data;
break;
default:
throw new InvalidOperationException("Unsupported CCD mode");
}
}
// //TODO - this should be deleted anyway (
// switch (ccdt.Mode)
// {
// case 0:
// track.TrackType = DiscStructure.ETrackType.Audio; //for CCD, this means audio, apparently.
// break;
// case 1:
// case 2:
// track.TrackType = DiscStructure.ETrackType.Data;
// break;
// default:
// throw new InvalidOperationException("Unsupported CCD mode");
// }
//}
//add sectors for the "mandatory track 1 pregap", which isn't stored in the CCD file
//THIS IS JUNK. MORE CORRECTLY SYNTHESIZE IT

12
BizHawk.Emulation.DiscSystem/CDAudio.cs
View File

@ -53,8 +53,8 @@ namespace BizHawk.Emulation.DiscSystem
if (track < 1 || track > Disc.Structure.Sessions[0].Tracks.Count)
return;
StartLBA = Disc.Structure.Sessions[0].Tracks[track - 1].Indexes[1].aba - 150;
EndLBA = StartLBA + Disc.Structure.Sessions[0].Tracks[track - 1].LengthInSectors;
StartLBA = Disc.Structure.Sessions[0].Tracks[track - 1].LBA;
EndLBA = StartLBA + Disc.Structure.Sessions[0].Tracks[track - 1].Length;
PlayingTrack = track;
CurrentSector = StartLBA;
SectorOffset = 0;
@ -66,12 +66,12 @@ namespace BizHawk.Emulation.DiscSystem
public void PlayStartingAtLba(int lba)
{
var point = Disc.Structure.SeekPoint(lba);
if (point == null || point.Track == null) return;
var track = Disc.Structure.SeekTrack(lba);
if (track == null) return;
PlayingTrack = point.TrackNum;
PlayingTrack = track.Number;
StartLBA = lba;
EndLBA = point.Track.Indexes[1].aba + point.Track.LengthInSectors - 150;
EndLBA = track.LBA + track.Length;
CurrentSector = StartLBA;
SectorOffset = 0;

331
BizHawk.Emulation.DiscSystem/Disc.API.cs
View File

@ -1,331 +0,0 @@
using System;
using System.Collections.Generic;
using BizHawk.Common.BufferExtensions;
//main apis for emulator core routine use
namespace BizHawk.Emulation.DiscSystem
{
[Serializable]
public class DiscReferenceException : Exception
{
public DiscReferenceException(string fname, Exception inner)
: base(string.Format("A disc attempted to reference a file which could not be accessed or loaded: {0}", fname),inner)
{
}
public DiscReferenceException(string fname, string extrainfo)
: base(string.Format("A disc attempted to reference a file which could not be accessed or loaded:\n\n{0}\n\n{1}", fname, extrainfo))
{
}
}
public class ProgressReport
{
public string Message;
public bool InfoPresent;
public double ProgressEstimate;
public double ProgressCurrent;
public int TaskCount;
public int TaskCurrent;
public bool CancelSignal;
}
public class DiscHopper
{
public Disc CurrentDisc;
public Queue<Disc> Queue = new Queue<Disc>();
public void Enqueue(Disc disc)
{
Queue.Enqueue(disc);
}
public void Next()
{
if (Queue.Count != 0) Queue.Dequeue();
}
public void Eject()
{
CurrentDisc = null;
}
public void Insert()
{
if (Queue.Count > 0)
CurrentDisc = Queue.Peek();
}
public void Clear()
{
CurrentDisc = null;
Queue.Clear();
}
}
/// <summary>
/// Simplifies access to the subcode data in a disc
/// </summary>
public class SubcodeReader
{
public SubcodeReader(Disc disc)
{
this.disc = disc;
}
public void ReadLBA_SubchannelQ(int lba, ref SubchannelQ sq)
{
var se = disc.ReadLBA_SectorEntry(lba);
se.SubcodeSector.ReadSubcodeChannel(1, buffer, 0);
int offset = 0;
sq.q_status = buffer[offset + 0];
sq.q_tno = buffer[offset + 1];
sq.q_index = buffer[offset + 2];
sq.min.BCDValue = buffer[offset + 3];
sq.sec.BCDValue = buffer[offset + 4];
sq.frame.BCDValue = buffer[offset + 5];
//nothing in byte[6]
sq.ap_min.BCDValue = buffer[offset + 7];
sq.ap_sec.BCDValue = buffer[offset + 8];
sq.ap_frame.BCDValue = buffer[offset + 9];
//CRC is stored inverted and big endian.. so... do the opposite
byte hibyte = (byte)(~buffer[offset + 10]);
byte lobyte = (byte)(~buffer[offset + 11]);
sq.q_crc = (ushort)((hibyte << 8) | lobyte);
}
Disc disc;
byte[] buffer = new byte[96];
}
/// <summary>
/// Allows you to stream data off a disc
/// </summary>
public class DiscStream : System.IO.Stream
{
int SectorSize;
int NumSectors;
Disc Disc;
long currPosition;
int cachedSector;
byte[] cachedSectorBuffer;
public static DiscStream Open_LBA_2048(Disc disc)
{
var ret = new DiscStream();
ret._Open_LBA_2048(disc);
return ret;
}
void _Open_LBA_2048(Disc disc)
{
SectorSize = 2048;
Disc = disc;
NumSectors = disc.LBACount;
currPosition = 0;
cachedSector = -1;
cachedSectorBuffer = new byte[SectorSize];
}
public override bool CanRead { get { return true; } }
public override bool CanSeek { get { return true; } }
public override bool CanWrite { get { return false; } }
public override void Flush() { throw new NotImplementedException(); }
public override long Length { get { return NumSectors * SectorSize; } }
public override long Position
{
get { return currPosition; }
set
{
currPosition = value;
//invalidate the cached sector..
//as a later optimization, we could actually intelligently decide if this is necessary
cachedSector = -1;
}
}
public override int Read(byte[] buffer, int offset, int count)
{
long remain = Length - currPosition;
if (count > remain)
count = (int)Math.Min(remain,int.MaxValue);
Disc.READLBA_Flat_Implementation(currPosition, buffer, offset, count, (a, b, c) => Disc.ReadLBA_2048(a, b, c), SectorSize, cachedSectorBuffer, ref cachedSector);
currPosition += count;
return count;
}
public override long Seek(long offset, System.IO.SeekOrigin origin)
{
switch (origin)
{
case System.IO.SeekOrigin.Begin: Position = offset; break;
case System.IO.SeekOrigin.Current: Position += offset; break;
case System.IO.SeekOrigin.End: Position = Length - offset; break;
}
return Position;
}
public override void SetLength(long value) { throw new NotImplementedException(); }
public override void Write(byte[] buffer, int offset, int count) { throw new NotImplementedException(); }
}
sealed public partial class Disc
{
/// <summary>
/// Main API to read a 2352-byte sector from a disc, identified by LBA.
/// </summary>
public void ReadLBA_2352(int lba, byte[] buffer, int offset)
{
ReadABA_2352(lba + 150, buffer, offset);
}
/// <summary>
/// Main API to read a 2048-byte sector from a disc, identified by LBA.
/// </summary>
public void ReadLBA_2048(int lba, byte[] buffer, int offset)
{
ReadABA_2048(lba + 150, buffer, offset);
}
/// <summary>
/// Main API to read a 2352-byte sector from a disc, identified by ABA
/// </summary>
public void ReadABA_2352(int aba, byte[] buffer, int offset)
{
Sectors[aba].Sector.Read_2352(buffer, offset);
}
/// <summary>
/// Main API to read a 2048-byte sector from a disc, identified by ABA
/// </summary>
public void ReadABA_2048(int aba, byte[] buffer, int offset)
{
Sectors[aba].Sector.Read_2048(buffer, offset);
}
/// <summary>
/// reads logical data from a flat (logical) disc address space. disc_offset=0 represents LBA=0.
/// useful for plucking data from a known location on the disc
/// </summary>
public void ReadLBA_2352_Flat(long disc_offset, byte[] buffer, int offset, int length)
{
const int secsize = 2352;
byte[] lba_buf = new byte[secsize];
int sectorHint = -1;
READLBA_Flat_Implementation(disc_offset, buffer, offset, length, (a, b, c) => ReadLBA_2352(a, b, c), secsize, lba_buf, ref sectorHint);
}
/// <summary>
/// reads logical data from a flat (absolute) disc address space. disc_offset=0 represents LBA=0.
/// useful for plucking data from a known location on the disc
/// </summary>
public void ReadLBA_2048_Flat(long disc_offset, byte[] buffer, int offset, int length)
{
const int secsize = 2048;
byte[] lba_buf = new byte[secsize];
int sectorHint = -1;
READLBA_Flat_Implementation(disc_offset, buffer, offset, length, (a, b, c) => ReadLBA_2048(a, b, c), secsize, lba_buf, ref sectorHint);
}
internal void READLBA_Flat_Implementation(long disc_offset, byte[] buffer, int offset, int length, Action<int, byte[], int> sectorReader, int sectorSize, byte[] sectorBuf, ref int sectorBufferHint)
{
//hint is the sector number which is already read. to avoid repeatedly reading the sector from the disc in case of several small reads, so that sectorBuf can be used as a sector cache
while (length > 0)
{
int lba = (int)(disc_offset / sectorSize);
int lba_within = (int)(disc_offset % sectorSize);
int todo = length;
int remains_in_lba = sectorSize - lba_within;
if (remains_in_lba < todo)
todo = remains_in_lba;
if(sectorBufferHint != lba)
sectorReader(lba, sectorBuf, 0);
sectorBufferHint = lba;
Array.Copy(sectorBuf, lba_within, buffer, offset, todo);
offset += todo;
length -= todo;
disc_offset += todo;
}
}
/// <summary>
/// Returns a SectorEntry from which you can retrieve various interesting pieces of information about the sector.
/// The SectorEntry's interface is not likely to be stable, though, but it may be more convenient.
/// </summary>
public SectorEntry ReadLBA_SectorEntry(int lba)
{
return Sectors[lba + 150];
}
/// <summary>
/// Main API to determine how many LBAs are available on the disc.
/// This counts from LBA 0 to the final sector available.
/// </summary>
public int LBACount { get { return ABACount - 150; } }
/// <summary>
/// Main API to determine how many ABAs (sectors) are available on the disc.
/// This counts from ABA 0 to the final sector available.
/// </summary>
public int ABACount { get { return Sectors.Count; } }
/// <summary>
/// indicates whether this disc took significant work to load from the hard drive (i.e. decoding of ECM or audio data)
/// In this case, the user may appreciate a prompt to export the disc so that it won't take so long next time.
/// </summary>
public bool WasSlowLoad { get; private set; }
/// <summary>
/// main api for reading the structure from a disc.
/// TODO - this is weak sauce. Why this one method to read something which is nothing but returning a structure? Lame.
/// Either get rid of this, or rethink the disc API wrapper concept
/// </summary>
public DiscStructure ReadStructure()
{
return Structure;
}
// converts LBA to minute:second:frame format.
//TODO - somewhat redundant with Timestamp, which is due for refactoring into something not cue-related
public static void ConvertLBAtoMSF(int lba, out byte m, out byte s, out byte f)
{
lba += 150;
m = (byte)(lba / 75 / 60);
s = (byte)((lba - (m * 75 * 60)) / 75);
f = (byte)(lba - (m * 75 * 60) - (s * 75));
}
// converts MSF to LBA offset
public static int ConvertMSFtoLBA(byte m, byte s, byte f)
{
return f + (s * 75) + (m * 75 * 60) - 150;
}
// gets an identifying hash. hashes the first 512 sectors of
// the first data track on the disc.
//TODO - this is a very platform-specific thing. hashing the TOC may be faster and be just as effective. so, rename it appropriately
public string GetHash()
{
byte[] buffer = new byte[512 * 2352];
foreach (var track in Structure.Sessions[0].Tracks)
{
if (track.TrackType == ETrackType.Audio)
continue;
int lba_len = Math.Min(track.LengthInSectors, 512);
for (int s = 0; s < 512 && s < track.LengthInSectors; s++)
ReadABA_2352(track.Indexes[1].aba + s, buffer, s * 2352);
return buffer.HashMD5(0, lba_len * 2352);
}
return "no data track found";
}
}
}

108
BizHawk.Emulation.DiscSystem/Disc.cs
View File

@ -95,21 +95,18 @@ namespace BizHawk.Emulation.DiscSystem
/// <summary>
/// The raw TOC entries found in the lead-in track.
/// NOTE: it seems unlikey that we'll ever get these exactly.
/// The cd reader is supposed to read the multiple copies and pick the best-of-3 and turn them into a TOCRaw
/// So really this only needs to stick around so we can make the TOCRaw from it.
/// Not much of a different view, but.. different
/// These aren't very useful, but theyre one of the most lowest-level data structures from which other TOC-related stuff is derived
/// </summary>
public List<RawTOCEntry> RawTOCEntries = new List<RawTOCEntry>();
/// <summary>
/// The DiscTOCRaw corresponding to the RawTOCEntries.
/// Note: these should be retrieved differently, through a view accessor
/// TODO - rename to TOC
/// </summary>
public DiscTOCRaw TOCRaw;
/// <summary>
/// The DiscStructure corresponding the the TOCRaw
/// The DiscStructure corresponding to the TOCRaw
/// </summary>
public DiscStructure Structure;
@ -151,7 +148,7 @@ namespace BizHawk.Emulation.DiscSystem
//TODO: encode_mode2_form2_sector
var sz = new Sector_Zero();
var leadoutTs = Disc.TOCRaw.LeadoutTimestamp;
var leadoutTs = Disc.TOCRaw.LeadoutLBA;
var lastTrackTOCItem = Disc.TOCRaw.TOCItems[Disc.TOCRaw.LastRecordedTrackNumber]; //NOTE: in case LastRecordedTrackNumber is al ie, this will malfunction
//leadout flags.. let's set them the same as the last track.
@ -200,30 +197,6 @@ namespace BizHawk.Emulation.DiscSystem
return job.OUT_Disc;
}
/// <summary>
/// Synthesizes a crudely estimated TOCRaw from the disc structure.
/// </summary>
public void Synthesize_TOCRawFromStructure()
{
TOCRaw = new DiscTOCRaw();
TOCRaw.FirstRecordedTrackNumber = 1;
TOCRaw.LastRecordedTrackNumber = Structure.Sessions[0].Tracks.Count;
int lastEnd = 0;
for (int i = 0; i < Structure.Sessions[0].Tracks.Count; i++)
{
var track = Structure.Sessions[0].Tracks[i];
TOCRaw.TOCItems[i + 1].Control = track.Control;
TOCRaw.TOCItems[i + 1].Exists = true;
//TOCRaw.TOCItems[i + 1].LBATimestamp = new Timestamp(track.Start_ABA - 150); //AUGH. see comment in Start_ABA
//TOCRaw.TOCItems[i + 1].LBATimestamp = new Timestamp(track.Indexes[1].LBA); //ZOUNDS!
//TOCRaw.TOCItems[i + 1].LBATimestamp = new Timestamp(track.Indexes[1].LBA + 150); //WHATEVER, I DONT KNOW. MAKES IT MATCH THE CCD, BUT THERES MORE PROBLEMS
TOCRaw.TOCItems[i + 1].LBATimestamp = new Timestamp(track.Indexes[1].LBA); //WHAT?? WE NEED THIS AFTER ALL! ZOUNDS MEANS, THERE WAS JUST SOME OTHER BUG
lastEnd = track.LengthInSectors + track.Indexes[1].LBA;
}
}
class SS_PatchQ : ISectorSynthJob2448
{
public ISectorSynthJob2448 Original;
@ -289,79 +262,6 @@ namespace BizHawk.Emulation.DiscSystem
}
}
/// <summary>
/// Creates the subcode (really, just subchannel Q) for this disc from its current TOC.
/// Depends on the TOCPoints existing in the structure
/// TODO - do we need a fully 0xFF P-subchannel for PSX?
/// </summary>
void Synthesize_SubcodeFromStructure()
{
int aba = 0;
int dpIndex = 0;
//TODO - from mednafen (on PC-FX chip chan kick)
//If we're more than 2 seconds(150 sectors) from the real "start" of the track/INDEX 01, and the track is a data track,
//and the preceding track is an audio track, encode it as audio(by taking the SubQ control field from the preceding
//NOTE: discs may have subcode which is nonsense or possibly not recoverable from a sensible disc structure.
//but this function does what it says.
//SO: heres the main idea of how this works.
//we have the Structure.Points (whose name we dont like) which is a list of sectors where the tno/index changes.
//So for each sector, we see if we've advanced to the next point.
//TODO - check if this is synthesized correctly when producing a structure from a TOCRaw
while (aba < Sectors.Count)
{
if (dpIndex < Structure.Points.Count - 1)
{
while (aba >= Structure.Points[dpIndex + 1].ABA)
{
dpIndex++;
}
}
var dp = Structure.Points[dpIndex];
var se = Sectors[aba];
EControlQ control = dp.Control;
bool pause = true;
if (dp.Num != 0) //TODO - shouldnt this be IndexNum?
pause = false;
if ((dp.Control & EControlQ.DATA)!=0)
pause = false;
int adr = dp.ADR;
SubchannelQ sq = new SubchannelQ();
sq.q_status = SubchannelQ.ComputeStatus(adr, control);
sq.q_tno = BCD2.FromDecimal(dp.TrackNum);
sq.q_index = BCD2.FromDecimal(dp.IndexNum);
int track_relative_aba = aba - dp.Track.Indexes[1].aba;
track_relative_aba = Math.Abs(track_relative_aba);
Timestamp track_relative_timestamp = new Timestamp(track_relative_aba);
sq.min = BCD2.FromDecimal(track_relative_timestamp.MIN);
sq.sec = BCD2.FromDecimal(track_relative_timestamp.SEC);
sq.frame = BCD2.FromDecimal(track_relative_timestamp.FRAC);
sq.zero = 0;
Timestamp absolute_timestamp = new Timestamp(aba);
sq.ap_min = BCD2.FromDecimal(absolute_timestamp.MIN);
sq.ap_sec = BCD2.FromDecimal(absolute_timestamp.SEC);
sq.ap_frame = BCD2.FromDecimal(absolute_timestamp.FRAC);
var bss = new BufferedSubcodeSector();
bss.Synthesize_SubchannelQ(ref sq, true);
//TEST: need this for psx?
if(pause) bss.Synthesize_SubchannelP(true);
se.SubcodeSector = bss;
aba++;
}
}
static byte IntToBCD(int n)
{
int ones;

40
BizHawk.Emulation.DiscSystem/Jobs/DiscMountJob.MednaDisc.cs
View File

@ -145,27 +145,31 @@ namespace BizHawk.Emulation.DiscSystem
tocSynth.Run();
disc.TOCRaw = tocSynth.Result;
//DO THIS IN A MORE UNIFORM WAY PLEASE
//setup the DiscStructure
disc.Structure = new DiscStructure();
var ses = new DiscStructure.Session();
disc.Structure.Sessions.Add(ses);
for (int i = 1; i < 100; i++)
{
var m_te = md.TOCTracks[i];
if (!m_te.Valid) continue;
//disc.Structure = new DiscStructure();
//var ses = new DiscStructure.Session();
//disc.Structure.Sessions.Add(ses);
//for (int i = 1; i < 100; i++)
//{
// var m_te = md.TOCTracks[i];
// if (!m_te.Valid) continue;
DiscStructure.Track track = new DiscStructure.Track() { Number = i };
ses.Tracks.Add(track);
if ((m_te.control & (int)EControlQ.DATA) == 0)
track.TrackType = DiscStructure.ETrackType.Audio;
else
track.TrackType = DiscStructure.ETrackType.Data;
// DiscStructure.Track track = new DiscStructure.Track() { Number = i };
// ses.Tracks.Add(track);
// if ((m_te.control & (int)EControlQ.DATA) == 0)
// track.IsData = false;
// else
// track.IsData = true;
//from mednafen, we couldnt build the index 0, and that's OK, since that's not really a sensible thing in CD terms anyway.
//I need to refactor this thing to oblivion
track.Indexes.Add(new DiscStructure.Index { Number = 0, LBA = (int)m_te.lba }); //<-- not accurate, but due for deletion
track.Indexes.Add(new DiscStructure.Index { Number = 1, LBA = (int)m_te.lba });
}
// track.Start_LBA = (int)m_te.lba;
// track.
// //from mednafen, we couldnt build the index 0, and that's OK, since that's not really a sensible thing in CD terms anyway.
// //I need to refactor this thing to oblivion
// //track.Indexes.Add(new DiscStructure.Index { Number = 0, LBA = (int)m_te.lba }); //<-- not accurate, but due for deletion
// //track.Indexes.Add(new DiscStructure.Index { Number = 1, LBA = (int)m_te.lba });
//}
//NOT FULLY COMPLETE

9
BizHawk.Emulation.DiscSystem/Jobs/DiscMountJob.cs
View File

@ -36,12 +36,13 @@ namespace BizHawk.Emulation.DiscSystem
/// <summary>
/// Mednafen loads SBI files oddly
/// </summary>
public bool SBO_As_Mednafen = true;
public bool SBI_As_Mednafen = true;
public void SetForPSX()
{
//probably set CUE_PauseContradictionModeA to follow mednafen, but not proven yet
//almost surely set CUE_PregapMode2_As_XA_Form2 to follow mednafen
CUE_PregapContradictionModeA = false;
CUE_PregapMode2_As_XA_Form2 = true;
SBI_As_Mednafen = true;
}
}
@ -168,7 +169,7 @@ namespace BizHawk.Emulation.DiscSystem
var sbiJob = new SBI.LoadSBIJob();
sbiJob.IN_Path = sbiPath;
sbiJob.Run();
OUT_Disc.ApplySBI(sbiJob.OUT_Data, IN_DiscMountPolicy.SBO_As_Mednafen);
OUT_Disc.ApplySBI(sbiJob.OUT_Data, IN_DiscMountPolicy.SBI_As_Mednafen);
}
}
else if (ext == ".ccd")

326
BizHawk.Emulation.DiscSystem/TOC/DiscStructure.cs
View File

@ -7,30 +7,15 @@ namespace BizHawk.Emulation.DiscSystem
/// <summary>
/// Contains structural information for the disc broken down into c# data structures for easy interrogation.
/// This represents a best-effort interpretation of the raw disc image.
/// You cannot assume a disc can be round-tripped into its original format through this (especially if it came from a format more detailed)
/// TODO - index 0s arent populated
/// IDEA: Make this be generated by a module which is aware of the 'firmware' being emulated, so firmware-specific rules can be applied.
/// </summary>
public class DiscStructure
{
/// <summary>
/// Right now support for anything other than 1 session is totally not working
/// This is a 0-indexed list of sessions (session 1 is at [0])
/// Support for multiple sessions is thoroughly not working yet
/// </summary>
public List<Session> Sessions = new List<Session>();
/// <summary>
/// List of Points described by the TOC.
/// TODO - this is kind of garbage.
/// TODO - rename this
/// TODO - generate it during loading of ccd/cue
/// TODO - is this 98% redundant with the Tracks list? I think so. Maybe it can encode more detail, but the DiscStructure is lossy anyway
/// Really, what it is, is a series of points where the tno/index change. Kind of an agenda.
/// Maybe I should rename it something different, or at least comment it
/// Or, you could look at this as a kind of compressed disc map
/// NOTE: While this class is actually pretty useless for robust stuff, this list of TOCPoints could be considered robust once fully evaluated
/// </summary>
public List<TOCPoint> Points;
/// <summary>
/// How many sectors in the disc, including the 150 lead-in sectors, up to the end of the last track (before the lead-out track)
/// TODO - does anyone ever need this as the ABA Count? Rename it LBACount or ABACount
@ -45,6 +30,7 @@ namespace BizHawk.Emulation.DiscSystem
/// <summary>
/// How many bytes of data in the disc (including lead-in). Disc sectors are really 2352 bytes each, so this is LengthInSectors * 2352
/// TODO - this is garbage
/// </summary>
public long BinarySize
{
@ -52,162 +38,70 @@ namespace BizHawk.Emulation.DiscSystem
}
/// <summary>
/// Synthesizes the DiscStructure from RawTOCEntriesJob
/// TODO - move to attic, not being used
/// WOULD BE NICE TO USE FOR CUE
/// Determines which track of session 0 is at the specified LBA.
/// Returns null if it's before track 1
/// </summary>
public class SynthesizeFromRawTOCEntriesJob
public Track SeekTrack(int lba)
{
public IEnumerable<RawTOCEntry> Entries;
public DiscStructure Result;
public void Run()
var ses = Sessions[0];
for (int i = 0; i < ses.Tracks.Count; i++)
{
Result = new DiscStructure();
var session = new Session();
Result.Sessions.Add(session);
//TODO - are these necessarily in order?
foreach (var te in Entries)
{
int pt = te.QData.q_index.DecimalValue;
int lba = te.QData.Timestamp.Sector;
var bcd2 = new BCD2 { BCDValue = (byte)pt };
if (bcd2.DecimalValue > 99) //A0 A1 A2 leadout and crap
continue;
var track = new Track { Start_ABA = lba, Number = pt };
track.Indexes.Add(new Index()); //dummy index 0
track.Indexes.Add(new Index() { Number = 1, LBA = lba });
session.Tracks.Add(track);
}
var track = ses.Tracks[i];
if (track.LBA > lba)
return (i==0)?null:ses.Tracks[i - 1];
}
return ses.Tracks[ses.Tracks.Count - 1];
}
/// <summary>
/// seeks the point immediately before (or equal to) this LBA
/// </summary>
public TOCPoint SeekPoint(int lba)
{
int aba = lba + 150;
for(int i=0;i<Points.Count;i++)
{
TOCPoint tp = Points[i];
if (tp.ABA > aba)
return Points[i - 1];
}
return Points[Points.Count - 1];
}
///// <summary>
///// Synthesizes the DiscStructure from RawTOCEntriesJob
///// </summary>
//public class SynthesizeFromRawTOCEntriesJob
//{
// public IEnumerable<RawTOCEntry> Entries;
// public DiscStructure Result;
// public void Run()
// {
// Result = new DiscStructure();
// var session = new Session();
// Result.Sessions.Add(session);
/// <summary>
/// Uhm... I'm back to thinking this is a good idea. It's a pretty lean log of the shape of the disc and a good thing to generate a DiscStructure from (and maybe avoid using the DiscStructure altogether)
/// Rename it to DiscMapEntry?
/// </summary>
public class TOCPoint
{
public int Num;
public int ABA, TrackNum, IndexNum;
public Track Track;
public int ADR; //meh...
public EControlQ Control;
public int LBA
{
get { return ABA - 150; }
}
}
/// <summary>
/// Generates the Points list from the current logical TOC
/// </summary>
public void Synthesize_TOCPointsFromSessions()
{
Points = new List<TOCPoint>();
int num = 0;
foreach (var ses in Sessions)
{
for(int t=0;t<ses.Tracks.Count;t++)
{
int tnum = t + 1;
var track = ses.Tracks[t];
for(int i=0;i<track.Indexes.Count;i++)
{
var index = track.Indexes[i];
bool repeat = false;
int aba = index.aba;
REPEAT:
var tp = new TOCPoint
{
Num = num++,
ABA = aba,
TrackNum = track.Number,
IndexNum = index.Number,
Track = track,
//ADR = 1, //It's hard to understand what other value could go here
Control = track.Control
};
//special case!
//yellow-book says:
//pre-gap for "first part of a digital data track not containing user data and encoded as a pause"
//first interval: at least 75 sectors coded as preceding track
//second interval: at least 150 sectors coded as user data track.
//TODO - add pause flag tracking to TOCPoint
//see mednafen's "TODO: Look into how we're supposed to handle subq control field in the four combinations of track types(data/audio)."
if (tnum != 1 && i == 0 && track.TrackType != ETrackType.Audio && !repeat)
{
//NOTE: we dont implement this exactly the same as mednafen, I think my logic is closer to the docs, but who knows, its complicated
int distance = track.Indexes[i + 1].aba - track.Indexes[i].aba;
//well, how do we know to apply this logic?
//we assume the 150 sector pregap is more important. so if thats all there is, theres no 75 sector pregap like the old track
//if theres a longer pregap, then we generate weird old track pregap to contain the rest.
if (distance > 150)
{
int weirdPregapSize = distance - 150;
//need a new point. fix the old one
tp.ADR = Points[Points.Count - 1].ADR;
tp.Control = Points[Points.Count - 1].Control;
Points.Add(tp);
aba += weirdPregapSize;
repeat = true;
goto REPEAT;
}
}
Points.Add(tp);
}
}
var tpLeadout = new TOCPoint();
var lastTrack = ses.Tracks[ses.Tracks.Count - 1];
tpLeadout.Num = num++;
tpLeadout.ABA = lastTrack.Indexes[1].aba + lastTrack.LengthInSectors;
tpLeadout.IndexNum = 0;
tpLeadout.TrackNum = 100;
tpLeadout.Track = null; //no leadout track.. now... or ever?
Points.Add(tpLeadout);
}
}
// //TODO - are these necessarily in order?
// foreach (var te in Entries)
// {
// int pt = te.QData.q_index.DecimalValue;
// int lba = te.QData.Timestamp.Sector;
// var bcd2 = new BCD2 { BCDValue = (byte)pt };
// if (bcd2.DecimalValue > 99) //A0 A1 A2 leadout and crap
// continue;
// var track = new Track { Start_LBA = lba, Number = pt };
// session.Tracks.Add(track);
// }
// }
//}
public class Session
{
public int num;
/// <summary>
/// The session number
/// </summary>
public int Number;
/// <summary>
/// All the tracks in the session.. but... Tracks[0] should be "Track 1". So beware of this.
/// SO SUCKY!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
/// We might should keep this organized as a dictionary as well.
/// Tracks.Count will be good for counting the useful user information tracks on the disc.
/// </summary>
public List<Track> Tracks = new List<Track>();
//I've thought about how to solve this, but it's not easy.
//At some point we may need to add a true track 0, too.
//Ideas: Dictionary, or a separate PhysicalTracks and UserTracks list, or add a null and make all loops just cope with that
//But, the DiscStructure is kind of weak. It might be better to just optimize it for end-users
//It seems that the current end-users are happy with tracks being implemented the way it is
//the length of the session (should be the sum of all track lengths)
public int length_aba;
public Timestamp FriendlyLength { get { return new Timestamp(length_aba); } }
//removed:
////the length of the session (should be the sum of all track lengths)
//public int length_aba;
}
/// <summary>
@ -232,101 +126,93 @@ namespace BizHawk.Emulation.DiscSystem
Audio
}
/// <summary>
/// Information about a Track.
/// </summary>
public class Track
{
//Notable omission:
//a list of Indices. It's difficult to reliably construct it.
//Notably, mednafen can't readily produce it.
//Indices may need scanning sector by sector.
//It's unlikely that any software would be needing indices anyway.
//We should add another index scanning service if that's ever needed.
//(note: a CCD should contain indices, but it's not clear whether it's required. logically it wshouldnt be)
//Notable omission:
//Mode (0,1,2)
//Modes 1 and 2 can't be generally distinguished.
//It's a relatively easy heuristic, though: just read the first sector of each track.
//These omissions could be handled by ReadStructure() policies which permit the scanning of the entire disc.
//After that, they could be cached in here.
/// <summary>
/// The number of the track (1-indexed)
/// </summary>
public int Number;
/// <summary>
/// Is this track audio or data?
/// The Mode of the track (0 is Audio, 1 and 2 are data)
/// This is heuristically determined.
/// Actual sector contents may vary
/// </summary>
public ETrackType TrackType;
public int Mode;
/// <summary>
/// The mode of a track.
/// 0 Will be audio, 1 and 2 will be data.
/// XA sub-forms are expected to be variable within a track
/// This is named as a Heuristic because it is a very ill-defined concept.
/// There's virtually nothing that tells us what the Mode of a track is. You just have to guess.
/// By contrast, the Control field is implied (and maybe specified) to be consistent and match the TOC
/// Is this track a Data track?
/// </summary>
public int ModeHeuristic;
public bool IsData { get { return !IsAudio; } }
/// <summary>
/// Is this track an Audio track?
/// </summary>
public bool IsAudio { get { return Mode == 0; } }
/// <summary>
/// The 'control' properties of the track indicated by the subchannel Q.
/// While in principle these could vary during the track, illegally (or maybe legally according to weird redbook rules)
/// they normally don't; they're useful for describing what type of contents the track is.
/// This is as indicated by the disc TOC.
/// Actual sector contents may vary.
/// </summary>
public EControlQ Control;
/// <summary>
/// Well, it seems a track can have an ADR property (used to fill the subchannel Q). This is delivered from a CCD file but may have to be guessed from
/// The starting LBA of the track (index 1).
/// </summary>
//public int ADR = 1; //??
public int LBA;
/// <summary>
/// All the indexes related to the track. These will be 0-Indexed, but they could be non-consecutive.
/// The length of the track, counted from its index 1 to the next track.
/// TODO - Shouldn't it exclude the post-gap?
/// NO - in at least one place (CDAudio) this is used.. and.. it should probably play through the post-gap
/// That just goes to show how ill-defined this concept is
/// </summary>
public List<Index> Indexes = new List<Index>();
public int Length;
/// <summary>
/// a track logically starts at index 1.
/// so this is the length from this index 1 to the next index 1 (or the end of the disc)
/// the time before track 1 index 1 is the lead-in [edit: IS IT?] and isn't accounted for in any track...
/// </summary>
public int LengthInSectors;
/// <summary>
/// The beginning ABA of the track (index 1). This isn't well-supported, yet
/// WHAT? IS THIS NOT AN ABA SOMETIMES?
/// IS IT THE INDEX 0 OF THE TRACK? THATS FUCKED UP. COMPARE TO TOCRAW ENTRIES. IT SHOULD BE MATCHING THAT
/// HEY??? SHOULD THIS EVEN BE HERE? YOURE SUPPOSED TO USE THE INDEXES INSTEAD.
/// WELL, IF WE KEEP THIS THE MEANING SHOULD BE SAME AS INDEX[1].LBA (or ABA) SO BE SURE TO WRITE THAT COMMENT HERE
/// </summary>
public int Start_ABA;
/// <summary>
/// The length as a timestamp (for accessing as a MM:SS:FF)
/// </summary>
public Timestamp FriendlyLength { get { return new Timestamp(LengthInSectors); } }
///// <summary>
///// The length as a timestamp (for accessing as a MM:SS:FF)
///// </summary>
//public Timestamp FriendlyLength { get { return new Timestamp(Length); } }
}
public class Index
{
public int Number;
public int aba;
public int LBA
{
get { return aba - 150; }
set { aba = value + 150; }
}
//the length of the section
//HEY! This is commented out because it is a bad idea.
//The length of a `section`? (what's a section?) is almost useless, and if you want it, you are probably making an error.
//public int length_lba;
//public Cue.Timestamp FriendlyLength { get { return new Cue.Timestamp(length_lba); } }
public int LBA;
}
public void AnalyzeLengthsFromIndexLengths()
{
//this is a little more complex than it looks, because the length of a thing is not determined by summing it
//but rather by the difference in lbas between start and end
LengthInSectors = 0;
foreach (var session in Sessions)
{
var firstTrack = session.Tracks[0];
var lastTrack = session.Tracks[session.Tracks.Count - 1];
session.length_aba = lastTrack.Indexes[0].aba + lastTrack.LengthInSectors - firstTrack.Indexes[0].aba;
LengthInSectors += session.length_aba;
}
}
//public void AnalyzeLengthsFromIndexLengths()
//{
// //this is a little more complex than it looks, because the length of a thing is not determined by summing it
// //but rather by the difference in lbas between start and end
// LengthInSectors = 0;
// foreach (var session in Sessions)
// {
// var firstTrack = session.Tracks[0];
// var lastTrack = session.Tracks[session.Tracks.Count - 1];
// session.length_aba = lastTrack.Indexes[0].aba + lastTrack.Length - firstTrack.Indexes[0].aba;
// LengthInSectors += session.length_aba;
// }
//}
}
}

2
BizHawk.Emulation.DiscSystem/TOC/TOCRaw.cs
View File

@ -146,6 +146,6 @@ namespace BizHawk.Emulation.DiscSystem
/// <summary>
/// The timestamp of the leadout track. In other words, the end of the user area.
/// </summary>
public Timestamp LeadoutTimestamp { get { return TOCItems[100].LBATimestamp; } }
public Timestamp LeadoutLBA { get { return TOCItems[100].LBATimestamp; } }
}
}