public override UInt32 ReadBlock(GR.Memory.ByteBuffer BufferTarget, UInt32 BytesToRead)
{
if (m_Stream == null)
{
return(0);
}
int bytesInCache = (int)m_Cache.Length - m_CacheBytesUsed;
// full in cache
if (BytesToRead <= bytesInCache)
{
BufferTarget.Resize(BytesToRead);
m_Cache.CopyTo(BufferTarget, m_CacheBytesUsed, (int)BytesToRead);
m_CacheBytesUsed += (int)BytesToRead;
return(BytesToRead);
}
UInt32 bytesRead = 0;
// partially in cache
BufferTarget.Resize((uint)bytesInCache);
m_Cache.CopyTo(BufferTarget, m_CacheBytesUsed, bytesInCache);
m_CacheBytesUsed += bytesInCache;
BytesToRead -= (uint)bytesInCache;
bytesRead = (UInt32)bytesInCache;
UInt32 BytesToReadNow = BytesToRead;
if (m_Stream.Position + BytesToRead > m_Stream.Length)
{
BytesToReadNow = (UInt32)(m_Stream.Length - m_Stream.Position);
}
UInt32 OriginalLength = (UInt32)BufferTarget.Length;
BufferTarget.Resize((UInt32)(BufferTarget.Length + BytesToReadNow));
m_Stream.Read(BufferTarget.Data(), (int)OriginalLength, (int)BytesToReadNow);
bytesRead += BytesToReadNow;
return(bytesRead);
}
public bool SetData(GR.Memory.ByteBuffer ImageData)
{
if (ImageData.Length != m_ImageData.Length)
{
return(false);
}
ImageData.CopyTo(m_ImageData);
return(true);
}
public override bool Load(string Filename)
{
_LastError = "";
GR.Memory.ByteBuffer diskData = GR.IO.File.ReadAllBytes(Filename);
if (diskData == null)
{
_LastError = "Could not open/read file";
return(false);
}
/*
* 70 track, no errors 349696
* 70 track, 1366 error bytes 351062
*/
if ((diskData.Length != 349696) &&
(diskData.Length != 351062))
{
_LastError = "disk image size is not supported";
return(false);
}
CreateEmptyMedia();
int dataPos = 0;
for (int i = 0; i < Tracks.Count; ++i)
{
for (int j = 0; j < Tracks[i].Sectors.Count; ++j)
{
diskData.CopyTo(Tracks[i].Sectors[j].Data, dataPos, 256);
dataPos += 256;
}
}
for (int i = 0; i < Tracks.Count; ++i)
{
for (int j = 0; j < Tracks[i].Sectors.Count; ++j)
{
Tracks[i].Sectors[j].Free = !IsSectorMarkedAsUsedInBAM(i + 1, j);
}
}
if (diskData.Length == 351062)
{
// error info appended
for (int i = 0; i < Tracks.Count; ++i)
{
for (int j = 0; j < Tracks[i].Sectors.Count; ++j)
{
Tracks[i].Sectors[j].SectorErrorCode = diskData.ByteAt(dataPos);
++dataPos;
}
}
}
return(true);
}
private int HandleCharFile(GR.Text.ArgumentParser ArgParser)
{
if (!ValidateExportType("charset file", ArgParser.Parameter("TYPE"), new string[] { "CHARS" }))
{
return(1);
}
GR.Memory.ByteBuffer data = GR.IO.File.ReadAllBytes(ArgParser.Parameter("CHARS"));
if (data == null)
{
System.Console.WriteLine("Couldn't read binary char file " + ArgParser.Parameter("CHARS"));
return(1);
}
int firstUnit = 0;
int count = -1;
if (ArgParser.IsParameterSet("OFFSET"))
{
firstUnit = GR.Convert.ToI32(ArgParser.Parameter("OFFSET"));
}
if (ArgParser.IsParameterSet("COUNT"))
{
count = GR.Convert.ToI32(ArgParser.Parameter("COUNT"));
}
if (count == -1)
{
count = (int)data.Length / 8;
}
if ((firstUnit < 0) ||
(firstUnit >= (int)data.Length / 8))
{
System.Console.WriteLine("OFFSET is invalid");
return(1);
}
if ((count <= 0) ||
(firstUnit + count > (int)data.Length / 8))
{
System.Console.WriteLine("COUNT is invalid");
return(1);
}
GR.Memory.ByteBuffer spriteData = new GR.Memory.ByteBuffer((uint)(count * 8));
data.CopyTo(spriteData, firstUnit * 8, count * 8);
if (!GR.IO.File.WriteAllBytes(ArgParser.Parameter("EXPORT"), spriteData))
{
Console.WriteLine("Could not write to file " + ArgParser.Parameter("EXPORT"));
return(1);
}
return(0);
}
private int HandleSpriteFile(GR.Text.ArgumentParser ArgParser)
{
if (!ValidateExportType("sprite file", ArgParser.Parameter("TYPE"), new string[] { "SPRITES" }))
{
return(1);
}
GR.Memory.ByteBuffer data = GR.IO.File.ReadAllBytes(ArgParser.Parameter("SPRITES"));
if (data == null)
{
System.Console.WriteLine("Couldn't read binary sprite file " + ArgParser.Parameter("SPRITES"));
return(1);
}
int firstSprite = 0;
int count = -1;
if (ArgParser.IsParameterSet("OFFSET"))
{
firstSprite = GR.Convert.ToI32(ArgParser.Parameter("OFFSET"));
}
if (ArgParser.IsParameterSet("COUNT"))
{
count = GR.Convert.ToI32(ArgParser.Parameter("COUNT"));
}
if (count == -1)
{
count = (int)data.Length / 64;
}
if ((firstSprite < 0) ||
(firstSprite >= (int)data.Length / 64))
{
System.Console.WriteLine("OFFSET is invalid");
return(1);
}
if ((count <= 0) ||
(firstSprite + count > (int)data.Length / 64))
{
System.Console.WriteLine("COUNT is invalid");
return(1);
}
GR.Memory.ByteBuffer spriteData = new GR.Memory.ByteBuffer((uint)(count * 64));
data.CopyTo(spriteData, firstSprite * 64, count * 64);
if (!GR.IO.File.WriteAllBytes(ArgParser.Parameter("EXPORT"), spriteData))
{
return(1);
}
return(0);
}
public override bool Load(string Filename)
{
_LastError = "";
GR.Memory.ByteBuffer diskData = GR.IO.File.ReadAllBytes(Filename);
if (diskData == null)
{
_LastError = "Could not open/read file";
return(false);
}
if ((diskData.Length != 822400) && // with error bytes
(diskData.Length != 819200))
{
_LastError = "disk image size is not equal 819200 or 822400 bytes";
return(false);
}
CreateEmptyMedia();
int dataPos = 0;
for (int i = 0; i < Tracks.Count; ++i)
{
for (int j = 0; j < Tracks[i].Sectors.Count; ++j)
{
diskData.CopyTo(Tracks[i].Sectors[j].Data, dataPos, 256);
dataPos += 256;
}
}
for (int i = 0; i < Tracks.Count; ++i)
{
for (int j = 0; j < Tracks[i].Sectors.Count; ++j)
{
Tracks[i].Sectors[j].Free = !IsSectorMarkedAsUsedInBAM(i + 1, j);
}
}
if (diskData.Length == 822400)
{
// error info appended
for (int i = 0; i < Tracks.Count; ++i)
{
for (int j = 0; j < Tracks[i].Sectors.Count; ++j)
{
Tracks[i].Sectors[j].SectorErrorCode = diskData.ByteAt(dataPos);
++dataPos;
}
}
}
return(true);
}
public override bool RenameFile(GR.Memory.ByteBuffer Filename, GR.Memory.ByteBuffer NewFilename)
{
_LastError = "";
foreach (FileEntry file in TapFiles)
{
if (file.Filename.Compare(Filename) == 0)
{
NewFilename.CopyTo(file.Filename, 0, 16);
return(true);
}
}
_LastError = "file not found";
return(false);
}
public override bool RenameFile(GR.Memory.ByteBuffer Filename, GR.Memory.ByteBuffer NewFilename)
{
_LastError = "";
int fileIndex = 0;
foreach (FileRecord file in FileRecords)
{
if (file.EntryType == 1)
{
if (file.Filename == Filename)
{
NewFilename.CopyTo(file.Filename, 0, 16);
return(true);
}
}
++fileIndex;
}
_LastError = "file not found";
return(false);
}
public bool MoveFileUp(Types.FileInfo File)
{
_LastError = "";
if (File.DirEntryIndex == 0)
{
return(false);
}
DirEntryLocation dirLocOrig = LocateDirEntry(File.DirEntryIndex);
if (dirLocOrig == null)
{
return(false);
}
DirEntryLocation dirLocPrev = LocateDirEntry(File.DirEntryIndex - 1);
Sector secOrig = Tracks[dirLocOrig.Track - 1].Sectors[dirLocOrig.Sector];
Sector secPrev = Tracks[dirLocPrev.Track - 1].Sectors[dirLocPrev.Sector];
// exchange dir entry content
GR.Memory.ByteBuffer tempData = secOrig.Data.SubBuffer(0x20 * dirLocOrig.DirEntry + 2, 30);
secPrev.Data.CopyTo(secOrig.Data, 0x20 * dirLocPrev.DirEntry + 2, 30, 0x20 * dirLocOrig.DirEntry + 2);
tempData.CopyTo(secPrev.Data, 0, 30, 0x20 * dirLocPrev.DirEntry + 2);
return(true);
}
public override bool WriteFile(GR.Memory.ByteBuffer Filename, GR.Memory.ByteBuffer Content, C64Studio.Types.FileType Type)
{
_LastError = "";
GR.Memory.ByteBuffer dataToWrite = new GR.Memory.ByteBuffer(Content);
if (dataToWrite.Length > FreeBytes())
{
_LastError = "file too large";
return(false);
}
Sector bam = Tracks[TRACK_BAM - 1].Sectors[SECTOR_BAM];
int trackIndex = 1;
int prevSector = 0;
int interleave = 10;
int bytesToWrite = (int)dataToWrite.Length;
int writeOffset = 0;
Sector previousSector = null;
int searchSector = -1;
int startSector = -1;
int startTrack = -1;
int sectorsWritten = 0;
write_next_sector :;
trackIndex = 1;
foreach (Track track in Tracks)
{
if (trackIndex == TRACK_DIRECTORY)
{
// directory track
++trackIndex;
continue;
}
if (track.FreeSectors == 0)
{
++trackIndex;
continue;
}
int sectorsPerTrack = track.Sectors.Count;
searchSector = (prevSector + interleave) % sectorsPerTrack;
while (true)
{
if (track.Sectors[searchSector].Free)
{
AllocSector(trackIndex, searchSector);
if (previousSector != null)
{
previousSector.Data.SetU8At(0, (byte)trackIndex);
previousSector.Data.SetU8At(1, (byte)searchSector);
}
else
{
// first sector, add directory entry
startSector = searchSector;
startTrack = trackIndex;
}
previousSector = track.Sectors[searchSector];
if (bytesToWrite > 254)
{
//Debug.Log( "Write to T/S " + trackIndex + "," + searchSector );
dataToWrite.CopyTo(previousSector.Data, writeOffset, 254, 2);
previousSector.Free = false;
writeOffset += 254;
bytesToWrite -= 254;
++sectorsWritten;
prevSector = searchSector;
goto write_next_sector;
}
// last sector
//Debug.Log( "Write to T/S " + trackIndex + "," + searchSector );
previousSector.Free = false;
previousSector.Data.SetU8At(0, 0);
previousSector.Data.SetU8At(1, (byte)(1 + bytesToWrite));
dataToWrite.CopyTo(previousSector.Data, writeOffset, bytesToWrite, 2);
writeOffset += bytesToWrite;
bytesToWrite = 0;
++sectorsWritten;
AddDirectoryEntry(Filename, startTrack, startSector, sectorsWritten, Type);
return(true);
}
else
{
++searchSector;
if (searchSector >= sectorsPerTrack)
{
searchSector = 0;
}
}
}
}
_LastError = "disk is full";
return(false);
}
public int Handle(string[] args)
{
if (args.Length == 0)
{
System.Console.WriteLine("MediaManager V" + System.Windows.Forms.Application.ProductVersion);
System.Console.WriteLine("");
System.Console.WriteLine("Call with mediamanager");
System.Console.WriteLine(" [-d64 <disk image>]");
System.Console.WriteLine(" [-t64 <tape file>]");
System.Console.WriteLine(" [-import <file name>[,load address]]");
System.Console.WriteLine(" [-export <file name>]");
System.Console.WriteLine(" [-rename <file name>]");
System.Console.WriteLine(" [-renameto <file name>]");
System.Console.WriteLine(" [-delete <file name>]");
System.Console.WriteLine(" [-listfiles]");
System.Console.WriteLine("");
System.Console.WriteLine("load address can be given as decimal, hexadecimal (prefix $ or 0x). If load address is given it is prepended to the import file data.");
System.Console.WriteLine("The filename given to -renameto is used for the actually written file when exporting");
System.Console.WriteLine("The filename given to -renameto is used for the file info entry when importing");
return(1);
}
bool expectingParameter = false;
string expectingParameterName = "";
string methodToUse = "";
GR.Collections.Map <string, string> paramMap = new GR.Collections.Map <string, string>();
for (int i = 0; i < args.Length; ++i)
{
if (expectingParameter)
{
paramMap[expectingParameterName] = args[i];
expectingParameter = false;
}
else if ((args[i].ToUpper() == "-D64") ||
(args[i].ToUpper() == "-T64") ||
(args[i].ToUpper() == "-IMPORT") ||
(args[i].ToUpper() == "-DELETE") ||
(args[i].ToUpper() == "-RENAME") ||
(args[i].ToUpper() == "-RENAMETO") ||
(args[i].ToUpper() == "-EXPORT"))
{
expectingParameter = true;
expectingParameterName = args[i].ToUpper();
if ((expectingParameterName == "-IMPORT") ||
(expectingParameterName == "-EXPORT") ||
(expectingParameterName == "-DELETE") ||
(expectingParameterName == "-RENAME"))
{
methodToUse = expectingParameterName;
}
}
else if (args[i].ToUpper() == "-LISTFILES")
{
paramMap[args[i].ToUpper()] = "";
methodToUse = args[i].ToUpper();
}
else
{
System.Console.Error.WriteLine("Unsupported option " + args[i]);
return(1);
}
}
if (expectingParameter)
{
System.Console.Error.WriteLine("Missing value for " + expectingParameterName);
return(1);
}
// do we have a container?
if ((!paramMap.ContainsKey("-D64")) &&
(!paramMap.ContainsKey("-T64")))
{
System.Console.Error.WriteLine("Missing medium");
return(1);
}
// load
C64Studio.Formats.MediaFormat medium = null;
string mediumFilename = "";
if (paramMap.ContainsKey("-D64"))
{
medium = new C64Studio.Formats.D64();
mediumFilename = paramMap["-D64"];
}
else if (paramMap.ContainsKey("-T64"))
{
medium = new C64Studio.Formats.T64();
mediumFilename = paramMap["-T64"];
}
if (!medium.Load(mediumFilename))
{
System.Console.WriteLine("No image found, start empty");
medium.CreateEmptyMedia();
}
// handle command
if (methodToUse == "-LISTFILES")
{
List <C64Studio.Types.FileInfo> files = medium.Files();
foreach (C64Studio.Types.FileInfo file in files)
{
string filename = C64Studio.Util.FilenameToReadableUnicode(file.Filename);
filename = filename.PadRight(16);
System.Console.WriteLine("\"" + filename + "\" " + file.Blocks + " blocks " + file.Type.ToString() + " " + file.Filename);
}
System.Console.WriteLine(files.Count + " files");
}
else if (methodToUse == "-EXPORT")
{
C64Studio.Types.FileInfo fileInfo = medium.LoadFile(C64Studio.Util.ToFilename(paramMap["-EXPORT"]));
if (fileInfo != null)
{
string outputFilename = paramMap["-EXPORT"];
if (paramMap.ContainsKey("-RENAMETO"))
{
outputFilename = paramMap["-RENAMETO"];
}
GR.IO.File.WriteAllBytes(outputFilename, fileInfo.Data);
System.Console.WriteLine("File " + paramMap["-EXPORT"] + " exported");
}
else
{
System.Console.Error.WriteLine("File " + paramMap["-EXPORT"] + " not found in medium");
}
}
else if (methodToUse == "-DELETE")
{
C64Studio.Types.FileInfo fileInfo = medium.LoadFile(C64Studio.Util.ToFilename(paramMap["-DELETE"]));
if (fileInfo != null)
{
if (!medium.DeleteFile(C64Studio.Util.ToFilename(paramMap["-DELETE"])))
{
System.Console.Error.WriteLine("File could not be deleted: " + medium.LastError);
}
else
{
System.Console.WriteLine("File deleted");
medium.Save(mediumFilename);
}
}
else
{
System.Console.Error.WriteLine("File " + paramMap["-DELETE"] + " not found in medium");
}
}
else if (methodToUse == "-IMPORT")
{
bool addAddress = false;
ushort startAddress = 0x0801;
string filenameImport = paramMap["-IMPORT"];
string[] paramList = filenameImport.Split(',');
if ((paramList.Length == 0) ||
(paramList.Length > 2))
{
System.Console.Error.WriteLine("Invalid parameter value for -IMPORT");
return(1);
}
filenameImport = paramList[0];
if (paramList.Length >= 2)
{
addAddress = true;
string loadAdressPart = paramList[1];
if (loadAdressPart.StartsWith("0x"))
{
ushort.TryParse(loadAdressPart.Substring(2), System.Globalization.NumberStyles.HexNumber, System.Globalization.CultureInfo.InvariantCulture, out startAddress);
}
else if (loadAdressPart.StartsWith("$"))
{
ushort.TryParse(loadAdressPart.Substring(1), System.Globalization.NumberStyles.HexNumber, System.Globalization.CultureInfo.InvariantCulture, out startAddress);
}
else
{
ushort.TryParse(loadAdressPart, out startAddress);
}
}
GR.Memory.ByteBuffer data = GR.IO.File.ReadAllBytes(filenameImport);
if (data == null)
{
System.Console.Error.WriteLine("Could not read file " + paramMap["-IMPORT"]);
return(1);
}
// insert load address
if (addAddress)
{
GR.Memory.ByteBuffer newData = new GR.Memory.ByteBuffer(2 + data.Length);
newData.SetU16At(0, startAddress);
data.CopyTo(newData, 0, (int)data.Length, 2);
data = newData;
}
if (paramMap.ContainsKey("-RENAMETO"))
{
filenameImport = paramMap["-RENAMETO"];
}
if (!medium.WriteFile(C64Studio.Util.ToFilename(filenameImport), data, C64Studio.Types.FileType.PRG))
{
System.Console.Error.WriteLine("Could not write file to medium: " + medium.LastError);
return(1);
}
System.Console.WriteLine("File imported");
medium.Save(mediumFilename);
}
else if (methodToUse == "-RENAME")
{
if (!paramMap.ContainsKey("-RENAMETO"))
{
System.Console.Error.WriteLine("Missing -renameto directive");
return(1);
}
string origFilename = paramMap["-RENAME"];
GR.Memory.ByteBuffer origFilenameBuffer = C64Studio.Util.ToFilename(origFilename);
string targetFilename = paramMap["-RENAMETO"];
GR.Memory.ByteBuffer targetFilenameBuffer = C64Studio.Util.ToFilename(targetFilename);
if (!medium.RenameFile(origFilenameBuffer, targetFilenameBuffer))
{
System.Console.Error.WriteLine("Failed to rename file");
return(1);
}
System.Console.WriteLine("File renamed");
medium.Save(mediumFilename);
}
else
{
System.Console.Error.WriteLine("Unsupported method " + methodToUse);
}
return(0);
}
public override bool RenameFile(GR.Memory.ByteBuffer Filename, GR.Memory.ByteBuffer NewFilename)
{
_LastError = "";
NewFilename.CopyTo(this.Filename, 0, 16);
return(true);
}
public bool ReadFromBuffer(GR.Memory.ByteBuffer DataIn)
{
if (DataIn == null)
{
return(false);
}
SpriteLayers.Clear();
GR.IO.MemoryReader memIn = DataIn.MemoryReader();
uint Version = memIn.ReadUInt32();
int numSprites = 256;
if (Version >= 1)
{
numSprites = memIn.ReadInt32();
}
Sprites = new List <SpriteData>();
for (int i = 0; i < numSprites; ++i)
{
Sprites.Add(new SpriteData());
CustomRenderer.PaletteManager.ApplyPalette(Sprites[i].Image);
}
string name = memIn.ReadString();
for (int i = 0; i < numSprites; ++i)
{
Sprites[i].Color = memIn.ReadInt32();
}
for (int i = 0; i < numSprites; ++i)
{
Sprites[i].Multicolor = (memIn.ReadUInt8() != 0);
}
BackgroundColor = memIn.ReadInt32();
MultiColor1 = memIn.ReadInt32();
MultiColor2 = memIn.ReadInt32();
bool genericMultiColor = (memIn.ReadUInt32() != 0);
for (int i = 0; i < numSprites; ++i)
{
GR.Memory.ByteBuffer tempBuffer = new GR.Memory.ByteBuffer();
memIn.ReadBlock(tempBuffer, 64);
tempBuffer.CopyTo(Sprites[i].Data, 0, 63);
}
UsedSprites = memIn.ReadUInt32();
ExportFilename = memIn.ReadString();
string exportPathSpriteFile = memIn.ReadString();
for (int i = 0; i < numSprites; ++i)
{
string desc = memIn.ReadString();
}
int spriteTestCount = memIn.ReadInt32();
for (int i = 0; i < spriteTestCount; ++i)
{
int spriteIndex = memIn.ReadInt32();
byte spriteColor = memIn.ReadUInt8();
bool spriteMultiColor = (memIn.ReadUInt8() != 0);
int spriteX = memIn.ReadInt32();
int spriteY = memIn.ReadInt32();
}
GR.IO.FileChunk chunk = new GR.IO.FileChunk();
while (chunk.ReadFromStream(memIn))
{
switch (chunk.Type)
{
case Types.FileChunk.SPRITESET_LAYER:
{
Layer layer = new Layer();
SpriteLayers.Add(layer);
var chunkReader = chunk.MemoryReader();
GR.IO.FileChunk subChunk = new GR.IO.FileChunk();
while (subChunk.ReadFromStream(chunkReader))
{
var subChunkReader = subChunk.MemoryReader();
if (subChunk.Type == Types.FileChunk.SPRITESET_LAYER_ENTRY)
{
LayerSprite sprite = new LayerSprite();
sprite.Index = subChunkReader.ReadInt32();
sprite.Color = subChunkReader.ReadUInt8();
sprite.X = subChunkReader.ReadInt32();
sprite.Y = subChunkReader.ReadInt32();
sprite.ExpandX = (subChunkReader.ReadUInt8() != 0);
sprite.ExpandY = (subChunkReader.ReadUInt8() != 0);
layer.Sprites.Add(sprite);
}
else if (subChunk.Type == Types.FileChunk.SPRITESET_LAYER_INFO)
{
layer.Name = subChunkReader.ReadString();
layer.BackgroundColor = subChunkReader.ReadUInt8();
}
}
}
break;
}
}
return(true);
}
public bool ReadFromBuffer(GR.Memory.ByteBuffer DataIn)
{
if (DataIn == null)
{
return(false);
}
SpriteLayers.Clear();
GR.IO.MemoryReader memIn = DataIn.MemoryReader();
GR.Memory.ByteBuffer header = new GR.Memory.ByteBuffer();
if (memIn.ReadBlock(header, 9) != 9)
{
return(false);
}
if ((header.ByteAt(0) != 0x53) ||
(header.ByteAt(1) != 0x50) ||
(header.ByteAt(2) != 0x44))
{
// no SPD
return(false);
}
NumSprites = header.ByteAt(4) + 1;
int numAnims = header.ByteAt(5) + 1;
BackgroundColor = header.ByteAt(6);
MultiColor1 = header.ByteAt(7);
MultiColor2 = header.ByteAt(8);
Sprites = new List <SpriteData>();
GR.Memory.ByteBuffer tempData = new GR.Memory.ByteBuffer();
for (int i = 0; i < NumSprites; ++i)
{
Sprites.Add(new SpriteData());
PaletteManager.ApplyPalette(Sprites[i].Image);
tempData.Clear();
memIn.ReadBlock(tempData, 63);
tempData.CopyTo(Sprites[i].Data, 0, 63);
Sprites[i].Color = memIn.ReadUInt8();
Sprites[i].Multicolor = (((Sprites[i].Color) & 0x80) != 0);
Sprites[i].Color &= 0x0f;
}
if (numAnims > 0)
{
GR.Memory.ByteBuffer animFrom = new GR.Memory.ByteBuffer();
GR.Memory.ByteBuffer animTo = new GR.Memory.ByteBuffer();
GR.Memory.ByteBuffer animNumFrames = new GR.Memory.ByteBuffer();
GR.Memory.ByteBuffer animAttributes = new GR.Memory.ByteBuffer();
memIn.ReadBlock(animFrom, (uint)numAnims);
memIn.ReadBlock(animTo, (uint)numAnims);
memIn.ReadBlock(animNumFrames, (uint)numAnims);
memIn.ReadBlock(animAttributes, (uint)numAnims);
}
UsedSprites = (uint)NumSprites;
return(true);
}
public override bool Load(string Filename)
{
_LastError = "";
GR.Memory.ByteBuffer diskData = GR.IO.File.ReadAllBytes(Filename);
if (diskData == null)
{
_LastError = "Could not open/read file";
return(false);
}
/*
* 35 track, no errors 174848
* 35 track, 683 error bytes 175531
* 40 track, no errors 196608
* 40 track, 768 error bytes 197376
*/
if ((diskData.Length != 174848) &&
(diskData.Length != 175531) &&
(diskData.Length != 196608) &&
(diskData.Length != 197376))
{
_LastError = "disk image size is not supported";
return(false);
}
switch (diskData.Length)
{
case 174848:
case 175531:
CreateEmptyMedia();
break;
case 196608:
case 197376:
CreateEmptyMedia40Tracks();
break;
}
int dataPos = 0;
for (int i = 0; i < Tracks.Count; ++i)
{
for (int j = 0; j < Tracks[i].Sectors.Count; ++j)
{
diskData.CopyTo(Tracks[i].Sectors[j].Data, dataPos, 256);
dataPos += 256;
}
}
for (int i = 0; i < Tracks.Count; ++i)
{
for (int j = 0; j < Tracks[i].Sectors.Count; ++j)
{
Tracks[i].Sectors[j].Free = !IsSectorMarkedAsUsedInBAM(i + 1, j);
}
}
if ((diskData.Length == 175531) ||
(diskData.Length == 197376))
{
// error info appended
for (int i = 0; i < Tracks.Count; ++i)
{
for (int j = 0; j < Tracks[i].Sectors.Count; ++j)
{
Tracks[i].Sectors[j].SectorErrorCode = diskData.ByteAt(dataPos);
++dataPos;
}
}
}
return(true);
}
