public void ChangeROM(IMemoryManager memoryManager, IROM rom)
{
this.rom = rom;
this.memoryManager = memoryManager;
LoadDataFromROM(memoryManager, rom);
}
public ROMWriterStream(IROM rom, ManagedPointer areaToWriteTo)
{
this.rom = rom;
this.areaToWriteTo = areaToWriteTo;
offset = areaToWriteTo.Offset;
buffer = rom.ReadData(areaToWriteTo);
}
private void OpenROM(string file)
{
var newRomToEdit = new SimpleGBAROM();
textBox1.Text = Path.GetFileName(file);
newRomToEdit.OpenROM(file);
romToEdit = newRomToEdit;
memoryManager = new Lazy();
}
public LazyReserver(int offset, int size, IROM rom, IMemoryManager manager)
{
this.offset = offset;
this.size = size;
this.rom = rom;
this.man = manager;
dataPointer = null;
}
List <int> breakPoints = new List <int>(); // list contains pcs of all breakpoints
public void init(ROM rom, InterruptController interruptController, Memory memory, Decoder decoder, Executer executer, Prescaler prescaler)
{
this.rom = rom;
this.interruptController = interruptController;
this.memory = memory;
this.decoder = decoder;
this.executer = executer;
this.prescaler = prescaler;
reset();
}
public SNESSystem(ICPU cpu, IRenderer renderer, IROM rom, IPPU ppu, IAPU apu, IAudioHandler audioHandler)
{
CPU = cpu;
Renderer = renderer;
AudioHandler = audioHandler;
ROM = rom;
rom?.SetSystem(this);
PPU = ppu;
PPU?.SetSystem(this);
APU = apu;
CPU?.SetSystem(this);
}
public GeneralizedPointerTableEntry(IROM rom, IMemoryManager manager, FE6RawFormat rawFormat)
{
this.rom = rom;
this.manager = manager;
this.fromFE6Format = true;
MainPortraitOffset = GetPtr(rawFormat.MainPortraitPointer);
MiniPortraitOffset = GetPtr(rawFormat.MiniPortraitPointer);
PaletteOffset = GetPtr(rawFormat.PalettePointer);
MouthOffset = 0;
GenericOffset = 0;
MouthPosition = new Point(rawFormat.MouthXPosition, rawFormat.MouthYPosition);
EyePosition = Point.Empty;
EyeControl = EyeControl.Open;
}
public GeneralizedPointerTableEntry(IROM rom, IMemoryManager manager, FE78RawFormat rawFormat)
{
this.rom = rom;
this.manager = manager;
this.fromFE6Format = false;
MainPortraitOffset = GetPtr(rawFormat.MainPortraitPointer);
MiniPortraitOffset = GetPtr(rawFormat.MiniPortraitPointer);
PaletteOffset = GetPtr(rawFormat.PalettePointer);
MouthOffset = GetPtr(rawFormat.MouthPointer);
GenericOffset = GetPtr(rawFormat.GenericPointer);
MouthPosition = new Point(rawFormat.MouthXPosition, rawFormat.MouthYPosition);
EyePosition = new Point(rawFormat.EyeXPosition, rawFormat.EyeYPosition);
EyeControl = rawFormat.EyeControl;
}
public PortraitIndexManager(IMemoryManager memoryManager, IROM rom, bool edited)
{
currentGame = GameEnumHelpers.GetGame(rom.GameCode);
var defaultInfo = defaultInfos[currentGame];
portraitDataPointerPointer = memoryManager.Reserve(defaultInfo.tablePointerOffset, 4);
int tableRawPtr = BitConverter.ToInt32(rom.ReadData(portraitDataPointerPointer), 0);
int tableEntryCount;
if (edited)
{
string data = rom.GetCustomData(portraitProperty);
if (data != null)
{
tableEntryCount = Convert.ToInt32(data);
}
else
{
//Let's just hope for the best...
tableEntryCount = defaultInfo.indexAmount;
rom.AddCustomData(portraitProperty, tableEntryCount.ToString());
}
}
else
{
tableEntryCount = defaultInfo.indexAmount;
rom.AddCustomData(portraitProperty, tableEntryCount.ToString());
}
portraitDataPointer =
memoryManager.Reserve(
Pointer.GetOffset(tableRawPtr + defaultInfo.IndexSize),
tableEntryCount);
entries = new List<GeneralizedPointerTableEntry>(tableEntryCount);
LoadDataFromROM(memoryManager, rom, defaultInfo.fe6format, tableEntryCount);
}
public void CreateROM(int addrWidth, int dataWidth, int capacity, int readLatency, out Component part, out IROM rom)
{
if (readLatency != 1)
throw new NotSupportedException("Read latency must be 1");
var romi = new ROM(1u << addrWidth, (uint)dataWidth);
part = romi;
rom = romi;
}
private void LoadDataFromROM(IMemoryManager memoryManager, IROM rom, bool useFE6Format, int indexCount)
{
byte[] portraitData = rom.ReadData(portraitDataPointer);
unsafe
{
if (useFE6Format)
{
FE6RawFormat[] rawData = new FE6RawFormat[indexCount];
fixed (FE6RawFormat* ptr = rawData)
{
IntPtr ptr2 = (IntPtr)ptr;
Marshal.Copy(portraitData, 0, ptr2, portraitData.Length);
}
for (int i = 0; i < rawData.Length; i++)
{
entries.Add(new GeneralizedPointerTableEntry(
rom, memoryManager, rawData[i]));
}
}
else
{
FE78RawFormat[] rawData = new FE78RawFormat[indexCount];
fixed (FE78RawFormat* ptr = rawData)
{
IntPtr ptr2 = (IntPtr)ptr;
Marshal.Copy(portraitData, 0, ptr2, portraitData.Length);
}
for (int i = 0; i < rawData.Length; i++)
{
entries.Add(new GeneralizedPointerTableEntry(
rom, memoryManager, rawData[i]));
}
}
}
}
private void LoadDataFromROM(IMemoryManager memoryManager, IROM rom)
{
int portraitPtrOffset;
int defaultIndexAmount;
bool FE6Format;
switch (game = GameEnumHelpers.GetGame(rom.GameCode))
{
case GameEnum.FE6Trans:
case GameEnum.FE6:
portraitPtrOffset = 0x007FD8;
defaultIndexAmount = 0xE6;
FE6Format = true;
break;
case GameEnum.FE7U:
portraitPtrOffset = 0x006B30;
defaultIndexAmount = 0xE4;
FE6Format = false;
break;
case GameEnum.FE8U:
portraitPtrOffset = 0x005524;
defaultIndexAmount = 0xAC;
FE6Format = false;
break;
//Unknown
case GameEnum.FE7J:
case GameEnum.FE8J:
case GameEnum.FE7E:
case GameEnum.FE8E:
default:
throw new Exception("Game not supported.");
}
portraitDataPointerPointer = memoryManager.Reserve(portraitPtrOffset, 4);
int tableRawPtr = BitConverter.ToInt32(rom.ReadData(portraitDataPointerPointer), 0);
int indexSize = Marshal.SizeOf(FE6Format ? typeof(FE6RawFormat) : typeof(FE78RawFormat));
portraitDataPointer =
memoryManager.Reserve(
Pointer.GetOffset(tableRawPtr + indexSize),
defaultIndexAmount * indexSize);
byte[] portraitData = rom.ReadData(portraitDataPointer);
portraitEntries.Clear();
unsafe
{
if (FE6Format)
{
FE6RawFormat[] rawData = new FE6RawFormat[defaultIndexAmount];
fixed (FE6RawFormat* ptr = rawData)
{
IntPtr ptr2 = (IntPtr)ptr;
Marshal.Copy(portraitData, 0, ptr2, portraitData.Length);
}
for (int i = 0; i < rawData.Length; i++)
{
portraitEntries.Add(new GeneralizedPointerTableEntry(
rom, memoryManager, rawData[i]));
}
}
else
{
FE78RawFormat[] rawData = new FE78RawFormat[defaultIndexAmount];
fixed (FE78RawFormat* ptr = rawData)
{
IntPtr ptr2 = (IntPtr)ptr;
Marshal.Copy(portraitData, 0, ptr2, portraitData.Length);
}
for (int i = 0; i < rawData.Length; i++)
{
portraitEntries.Add(new GeneralizedPointerTableEntry(
rom, memoryManager, rawData[i]));
}
}
}
CurrentIndex = 0;
form.MaxIndex = portraitEntries.Count - 1;
}
private CanCauseError<Bitmap> GetBitmat(GeneralizedPointerTableEntry entry, IROM rom)
{
return from face in entry.MainPortraitOffset == 0 ? CanCauseError<byte[]>.NoError(null) :
GetData(rom,
entry.MainPortraitOffset,
CompressedPortrait,
this.MainPortraitSizeBytes,
"Main portrait")
from mini in entry.MiniPortraitOffset == 0 ? CanCauseError<byte[]>.NoError(null) :
GetData(rom,
entry.MiniPortraitOffset,
this.CompressedMini,
this.MiniPortraitSizeBytes,
"Mini portrait")
from generic in entry.GenericOffset == 0 ? CanCauseError<byte[]>.NoError(null) :
GetData(rom,
entry.GenericOffset,
true,
this.GenericSizeBytes,
"Generic portrait")
from palette in entry.PaletteOffset == 0 ? CanCauseError<byte[]>.NoError(null) :
GetData(rom,
entry.PaletteOffset,
false,
this.PaletteSizeBytes,
"Palette")
from mouth in entry.MouthOffset == 0 || !this.SeparateMouthFrames ? CanCauseError<byte[]>.NoError(null) :
GetData(rom,
entry.MouthOffset,
false,
this.MouthSizeBytes,
"Mouth")
from result in GetPortraitFromRaw(face, mini, palette, mouth, generic)
select result;
}
/// <summary>
///
/// </summary>
/// <param name="picture"></param>
/// <param name="format"></param>
/// <param name="allocator"></param>
/// <param name="rom"></param>
/// <returns>
/// first is main portrait offset,
/// second is miniportrait,
/// third is palette and
/// fourth is mouth frames if separate
/// </returns>
private static CanCauseError<ManagedPointer[]> WriteData(PortraitFormat format, Bitmap picture,
IAllocator<ManagedPointer> allocator, IROM rom)
{
List<ManagedPointer> pointers = new List<ManagedPointer>(4);
//Get palette
Color[] palette;
bool palettedBitmap = picture.PixelFormat.HasFlag(PixelFormat.Indexed);
if (!palettedBitmap)
{
var colors = picture.GetColors();
colors = GBAPalette.GetGBAColors(colors);
if (colors.Count > 16)
{
return CanCauseError<ManagedPointer[]>.Error("Over 16 colours.");
}
palette = colors.ToArray();
}
else
{
palette = picture.Palette.Entries;
}
//Split to separate portraits
Bitmap mainPortrait = new Bitmap(
format.PortraitSize.Width,
format.PortraitSize.Height, picture.PixelFormat);
Move(picture, mainPortrait, format.PictureMapping);
Bitmap mouthbm;
if (format.SeparateMouthFrames)
{
mouthbm = new Bitmap(format.MouthSize.Width, format.MouthSize.Height, picture.PixelFormat);
}
else
{
mouthbm = mainPortrait;
}
Move(picture, mouthbm, format.MouthMapping);
Bitmap mini = new Bitmap(format.MiniSize.Width, format.MiniSize.Height, picture.PixelFormat);
Move(picture, mouthbm, format.MiniMapping);
//Write data
pointers.Add(Insert(mainPortrait, palette, format.BlockAdd, format.CompressedPortrait, rom, allocator));
pointers.Add(Insert(mini, palette, 0, format.CompressedMini, rom, allocator));
byte[] rawPalette = GBAPalette.toRawGBAPalette(palette);
var ptr = allocator.Allocate(rawPalette.Length, 4);
if (!ptr.IsNull)
{
rom.WriteData(ptr, rawPalette, 0, rawPalette.Length);
}
pointers.Add(ptr);
if (mouthbm != mainPortrait)
{
pointers.Add(Insert(mouthbm, palette, 0, true, rom, allocator));
}
return pointers.ToArray();
}
static int LZ77Length(int offset, IROM rom)
{
int result;
using (var reader = new System.IO.BinaryReader(new ROMReaderStream(rom)))
{
result = LZ77.GetCompressedDataLenght(reader, offset);
}
return result;
}
public void CreateROM(int addrWidth, int dataWidth, int capacity, int readLatency, out Component part, out IROM rom)
{
if (readLatency != 1)
{
throw new NotSupportedException("Read latency must be 1");
}
var romi = new ROM(1u << addrWidth, (uint)dataWidth);
part = romi;
rom = romi;
}
public void CreateROM(int addrWidth, int dataWidth, int capacity, int readLatency,
out Component part, out IROM rom)
{
bool regPrim, regOut;
switch (readLatency)
{
case 1:
regPrim = false;
regOut = false;
break;
case 2:
regPrim = true;
regOut = false;
break;
case 3:
regPrim = true;
regOut = true;
break;
default:
throw new NotSupportedException();
}
BlockMem bmem = new BlockMem()
{
IPAlgorithm = BlockMem.EIPAlgorithm.MinimumArea,
AssumeSynchronousClk = false,
ECC = false,
ECCType = BlockMem.EECCType.NoECC,
EnableA = BlockMem.EENAUsage.UseENAPin,
EnableB = BlockMem.EENBUsage.AlwaysEnabled,
ErrorInjectionType = BlockMem.EErrorInjectionType.SingleBitErrorInjection,
MemoryType = BlockMem.EMemoryType.SinglePortROM,
OperatingModeA = BlockMem.EOperatingMode.WriteFirst,
OperatingModeB = BlockMem.EOperatingMode.WriteFirst,
PipelineStages = readLatency - 1,
ReadWidthA = dataWidth,
ReadWidthB = dataWidth,
RegisterPortAInputOfSoftECC = false,
RegisterPortAOutputOfMemoryCore = regOut,
RegisterPortAOutputOfMemoryPrimitives = regPrim,
RegisterPortBOutputOfMemoryCore = false,
RegisterPortBOutputOfMemoryPrimitives = false,
RegisterPortBOutputOfSoftECC = false,
ResetMemoryLatchA = false,
ResetMemoryLatchB = false,
ResetPriorityA = BlockMem.EResetPriority.CE,
ResetPriorityB = BlockMem.EResetPriority.CE,
ResetType = BlockMem.EResetType.Sync,
SoftECC = false,
UseByteWriteEnable = false,
UseErrorInjectionPins = false,
UseRegCeAPin = false,
UseRegCeBPin = false,
UseRstAPin = false,
UseRstBPin = false,
WriteDepthA = MathExt.CeilPow2(capacity),
WriteWidthA = dataWidth,
WriteWidthB = dataWidth
};
part = bmem;
rom = bmem.SideA;
}
private void UpdateGUI()
{
IROM[] roms = fileToEdit.GetROMs();
comboBoxRom.Items.Clear();
comboBoxRom.Items.AddRange(roms);
currentRom = roms[0];
comboBoxRom.SelectedIndex = 0;
//SetRomInfo(CurrentRom);
}
private void comboBoxRom_SelectedIndexChanged(object sender, EventArgs e)
{
if (comboBoxRom.SelectedItem != null)
{
currentRom = comboBoxRom.SelectedItem as IROM;
SetRomInfo(currentRom);
}
}
public static CanCauseError<Bitmap> GetPortrait(GeneralizedPointerTableEntry entry, IROM rom)
{
var format = GetFormat(rom.GameCode);
return format.GetBitmat(entry, rom);
}
public void init(ROM rom)
{
romInstance = rom;
}
private static ManagedPointer Insert(Bitmap toInsert, Color[] palette, int blockAdded, bool compressed,
IROM rom, IAllocator<ManagedPointer> allocator)
{
var bytes = GBAGraphics.ToGBARaw(toInsert, palette, GraphicsMode.Tile4bit);
int insertedLength;
int bytesAdded = blockAdded * 32;
if (compressed)
{
bytes = LZ77.Compress(bytes, 0, bytes.Length - bytesAdded);
insertedLength = bytes.Length;
}
else
{
insertedLength = bytes.Length - bytesAdded;
}
var ptr = allocator.Allocate(insertedLength, 4);
if (!ptr.IsNull)
{
rom.WriteData(ptr, bytes, 0, insertedLength);
}
return ptr;
}
/// <summary>
///
/// </summary>
/// <param name="picture"></param>
/// <param name="allocator"></param>
/// <param name="rom"></param>
/// <returns>
/// first is main portrait offset,
/// second is miniportrait,
/// third is palette and
/// fourth is mouth frames if separate
/// </returns>
public static CanCauseError<ManagedPointer[]> WriteData(Bitmap picture,
IAllocator<ManagedPointer> allocator, IROM rom)
{
var format = GetFormat(rom.GameCode);
return WriteData(format, picture, allocator, rom);
}
public void ChangeROM(IMemoryManager memoryManager, IROM rom)
{
throw new NotImplementedException();
}
private void SetRomInfo(IROM rom)
{
textBoxCode.Text = rom.Code;
numericUpDownSongList.Value = rom.SongListOffset;
textBoxCreator.Text = rom.Creator;
textBoxScreenShot.Text = rom.Screenshot;
textBoxTagger.Text = rom.Tagger;
IPlaylist[] playlists = rom.GetPlaylists();
comboBoxPlaylist.Items.Clear();
comboBoxPlaylist.Items.AddRange(playlists);
currentPlaylist = playlists[0];
comboBoxPlaylist.SelectedIndex = 0;
//IPlaylist playlist = CurrentPlaylist;
//SetSongInfo(playlist);
}
static byte[] Decomp(IROM rom, int offset)
{
byte[] result;
using (var input = new ROMReaderStream(rom))
{
input.Position = offset;
using (MemoryStream output = new MemoryStream(0x1000))
{
if (LZ77.Decompress(input, output))
{
result = output.ToArray();
}
else
{
result = null;
}
}
}
return result;
}
static CanCauseError<byte[]> GetData(IROM rom, int offset, bool compressed, int size, string error)
{
CanCauseError<byte[]> result;
if (compressed)
{
result = Decomp(rom, offset);
if (result.Result == null)
{
result = CanCauseError<byte[]>.Error(error + " failed to decompress");
}
else if (result.Result.Length != size)
{
result = CanCauseError<byte[]>.Error(error + " is wrong size");
}
}
else
{
result = rom.ReadData(offset, size);
}
return result;
}
public ROMReaderStream(IROM romToRead)
{
rom = romToRead;
}
