public static byte[] Compress(ByteArrayStream target)
{
if (target.Address != 0)
{
throw new ArgumentException($"{nameof(target)} address must be 0");
}
if (target.Size % 2 != 0)
{
throw new ArgumentException($"size is wrong ({target.Size.ToString("x2")}), {nameof(target)} needs to be in 2 byte chunks (words)");
}
var output = new List <byte>(target.Size / 2);
while (!target.AtEnd)
{
var low = target.Byte();
var high = target.Byte();
if ((low & 0x07) != low)
{
throw new Exception($"{nameof(low)} byte should be lower three bits only. value: ${low.ToString("x2")} address: ${(target.Address - 2).ToString("x2")}");
}
if ((high & 0x07) != low)
{
throw new Exception($"{nameof(high)} byte should be lower three bits only. value: ${high.ToString("x2")} address: ${(target.Address - 1).ToString("x2")}");
}
var data = (byte)(low + (high << 4));
output.Add(data);
}
return(output.ToArray());
}
public static byte[] Compress(ByteArrayStream target)
{
if (target.Address != 0)
{
throw new ArgumentException($"{nameof(target)} address must be 0");
}
if (target.Size % 0x20 != 0)
{
throw new ArgumentException($"size is wrong ({target.Size.ToString("x2")}), {nameof(target)} needs to be in full $20 byte chunks");
}
var output = new List <byte>(target.Size * 3 / 4);
while (!target.AtEnd)
{
output.Add(target.Byte());
if ((target.Address % 0x20) >= 0x10)
{
var zero = target.Byte();
if (zero != 0)
{
throw new Exception($"byte should be zero. value: ${zero.ToString("x2")} address: ${(target.Address - 1).ToString("x4")}");
}
}
}
return(output.ToArray());
}
public void FileDownloadItem()
{
var fileId = GenerateFileId();
var readStream = new ByteArrayStream(128 * 1024);
var client = new Client(KTestHost, KTestPort);
client.Connect();
client.BeginTransaction(fileId);
client.Upload(FileType.Asset, readStream);
client.EndTransaction();
Thread.Sleep(50); // give the server a little time to finish the transaction
var targetFile = Path.GetTempFileName();
var downloadItem = new FileDownloadItem(fileId, FileType.Asset, targetFile);
var mre = new ManualResetEvent(false);
Exception err = null;
client.DownloadFinished += (sender, args) =>
{
try
{
Assert.AreEqual(DownloadResult.Success, args.Result);
Assert.AreEqual(args.DownloadItem.Id, fileId);
Assert.IsTrue(File.Exists(targetFile));
var fileBytes = File.ReadAllBytes(targetFile);
Assert.IsTrue(Util.ByteArraysAreEqual(readStream.BackingBuffer, fileBytes));
}
catch (Exception e)
{
err = e;
}
finally
{
if (File.Exists(targetFile))
{
File.Delete(targetFile);
}
mre.Set();
}
};
client.QueueDownload(downloadItem);
Assert.IsTrue(mre.WaitOne(2000));
if (err != null)
{
throw err;
}
}
public MetaTileDefinition(ByteArrayStream source)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
TopLeft = new BGMapEntry(source.Word());
TopRight = new BGMapEntry(source.Word());
BottomLeft = new BGMapEntry(source.Word());
BottomRight = new BGMapEntry(source.Word());
}
public static string AttemptTranslate(ByteArrayStream stream, int depthLeft = 2)
{
var code = stream.Byte();
if (code >= 0x80)
{
return(BasicTable.Lookup(code));
}
if (code < 0x30)
{
if (code == 0x01)
{
return($"{{windowbreak}}");
}
if (code == 0x05)
{
return($"{{05:{stream.Byte().ToString("x2")}}}");
}
if (code == 0x1b)
{
return($"{{swapspeaker:{stream.Byte().ToString("x2")}}}");
}
if (code == 0x1d)
{
return($"{{character:{CharacterNames.GetString(stream.Byte())}}}");
}
if (code == 0x1e)
{
return($"{{item:{ItemNames.GetString(stream.Byte())}}}");
}
if (code == 0x1f)
{
return($"{{location:{LocationNames.GetString(stream.Byte())}}}");
}
//if (code == 0x2f) {
// return $"{{if:{stream.Byte().ToString("x2")} {stream.Byte().ToString("x2")} {stream.Byte().ToString("x2")}}}";
//}
return($"{{{code.ToString("x2")}}}");
}
if (depthLeft == 0)
{
return($"{{{code.ToString("x2")}}}");
}
//var text = string.Join("", LookupBytes(code).Select(x => AttemptTranslate(x, depthLeft - 1)));
var text = AttemptTranslateLine(LookupBytes(code), depthLeft - 1);
return(text);
}
public static byte[] Decompress(ByteArrayStream source, int compressedSize)
{
var output = new List <byte>(compressedSize * 2);
for (int i = 0; i < compressedSize; i++)
{
var data = source.Byte();
output.Add((byte)(data & 0x07));
output.Add((byte)((data >> 4) & 0x07));
}
return(output.ToArray());
}
public bool Open(string filename, out PlayerData playerData)
{
playerData = null;
if (String.IsNullOrEmpty(filename))
{
return(false);
}
using (var stream = new ByteArrayStream(File.ReadAllBytes(filename)))
{
return(OpenFromByteArrayStream(stream, out playerData));
}
}
public static string AttemptTranslateLine(ByteArrayStream stream)
{
var line = new List <string>();
while (stream.ByteAt(0) != BasicTable.EndOfString)
{
line.Add(AttemptTranslate(stream));
}
var text = string.Join("", line);
stream.Byte();
return(text);
}
public void UploadDownloadOne()
{
var fileId = GenerateFileId();
var readStream = new ByteArrayStream(16 * 1024);
var client = new Client(KTestHost, KTestPort);
client.Connect();
client.BeginTransaction(fileId);
client.Upload(FileType.Asset, readStream);
client.EndTransaction();
Thread.Sleep(50); // give the server a little time to finish the transaction
var downloadItem = new TestDownloadItem(fileId, FileType.Asset);
client.QueueDownload(downloadItem);
Exception err = null;
var mre = new ManualResetEvent(false);
client.DownloadFinished += (sender, args) =>
{
try
{
Assert.AreEqual(0, args.DownloadQueueLength);
Assert.AreEqual(DownloadResult.Success, args.Result);
Assert.AreEqual(fileId, args.DownloadItem.Id);
}
catch (Exception e)
{
err = e;
}
finally
{
mre.Set();
}
};
Assert.IsTrue(mre.WaitOne(2000));
if (err != null)
{
throw err;
}
Assert.IsTrue(Util.ByteArraysAreEqual(readStream.BackingBuffer, downloadItem.Bytes));
}
public void TransactionIsolation()
{
var fileId = GenerateFileId();
var readStream = new ByteArrayStream(16 * 1024);
var client = new Client(KTestHost, KTestPort);
client.Connect();
Assert.Throws <TransactionIsolationException>(() => client.Upload(FileType.Asset, readStream));
Assert.Throws <TransactionIsolationException>(() => client.EndTransaction());
// Back-to-back begin transactions are allowed
client.BeginTransaction(fileId);
Assert.DoesNotThrow(() => client.BeginTransaction(fileId));
}
public static byte[] Decompress(ByteArrayStream source, int outputSize)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
var output = new ByteArrayStream(outputSize);
var work = new ByteRingBuffer(RingSize, StartWriteAddress);
Queue <bool> commands = source.Byte().ToBooleanQueue();
while (output.HasSpace)
{
if (commands.Count == 0)
{
commands = source.Byte().ToBooleanQueue();
}
if (commands.Dequeue())
{
var b = source.Byte();
work.Byte(b);
output.Byte(b);
}
else
{
var d1 = source.Byte();
var d2 = source.Byte();
var address = d1 + ((d2 << 2) & 0x0300);
var counter = (d2 & 0x3f) + 3;
var copySource = work.Branch(address);
while (output.HasSpace && (counter != 0))
{
var copy = copySource.Byte();
counter--;
work.Byte(copy);
output.Byte(copy);
}
}
}
return(output.Buffer);
}
public static ObjectSchemaTemplateInfo FromBinary(Byte[] Bytes)
{
XElement x;
using (ByteArrayStream s = new ByteArrayStream(Bytes))
{
using (var sr = Txt.CreateTextReader(s.AsNewReading(), TextEncoding.Default, true))
{
x = TreeFile.ReadFile(sr);
}
}
XmlSerializer xs = new XmlSerializer();
var t = xs.Read <ObjectSchemaTemplate>(x);
var ti = new ObjectSchemaTemplateInfo(t);
return(ti);
}
static List <string> FindInRom(byte[] searchTerm, int dataOffset, int dataLength)
{
var spots =
new ByteArrayStream(Rom.ROM)
.FindAll(searchTerm)
.Select(x => new {
Address = x.Address + Rom.AddressOffset,
DataAddress = x.Address + Rom.AddressOffset + dataOffset,
Data = x.GetBytes(dataLength, x.Address + dataOffset)
});
var lines =
spots
.Select(x =>
$"{x.Address.ToString("x6", CultureInfo.InvariantCulture)} -- {x.DataAddress.ToString("x6", CultureInfo.InvariantCulture)} -- {string.Join(" ", x.Data.Select(y => y.ToString("x2", CultureInfo.InvariantCulture)))}"
);
return(lines.ToList());
}
public static string AttemptTranslateLine(byte[] input, int depthLeft = 3)
{
var line = new List <string>();
var stream = new ByteArrayStream(input);
while (!stream.AtEnd)
{
line.Add(AttemptTranslate(stream, depthLeft));
}
var text = string.Join("", line);
if (!stream.AtEnd)
{
stream.Byte();
}
return(text);
}
public static byte[] Decompress(ByteArrayStream source, int compressedSize)
{
if (compressedSize % 0x18 != 0)
{
throw new ArgumentException($"{nameof(compressedSize)} is wrong ({compressedSize.ToString("x2")}), {nameof(source)} needs to be in full $18 byte chunks");
}
var output = new List <byte>(compressedSize * 4 / 3);
for (int i = 0; i < compressedSize; i++)
{
output.Add(source.Byte());
// skip a byte in destination
if ((i % 0x18) >= 0x10)
{
output.Add(0);
}
}
return(output.ToArray());
}
private static ScriptGraphNode CreateNode(ScriptNodeData data)
{
ScriptGraphNode node;
ByteArrayStream stream = new ByteArrayStream(data.serialData);
switch (data.type)
{
case NodeType.Root:
{
node = new RootNode();
}
break;
case NodeType.Message:
{
node = new MessageNode();
var temp = node as MessageNode;
temp.text = stream.ReadString();
}
break;
case NodeType.Branch:
{
node = new BranchNode();
var temp = node as BranchNode;
temp.flag = stream.ReadBool();
}
break;
case NodeType.None:
default:
node = null;
break;
}
SetCommonData(node, data);
return(node);
}
public void ResetDownloadFinishedEventHandler()
{
var fileId = GenerateFileId();
var readStream = new ByteArrayStream(16 * 1024);
var client = new Client(KTestHost, KTestPort);
client.Connect();
client.BeginTransaction(fileId);
client.Upload(FileType.Asset, readStream);
client.EndTransaction();
Thread.Sleep(50);
var downloadItem = new TestDownloadItem(fileId, FileType.Asset);
// Add two listeners that will assert if called
client.DownloadFinished += (sender, args) => { Debug.Assert(false); };
client.DownloadFinished += (sender, args) => { Debug.Assert(false); };
// Clear the listeners so they will not be called
client.ResetDownloadFinishedEventHandler();
client.QueueDownload(downloadItem);
var mre = new ManualResetEvent(false);
ThreadPool.QueueUserWorkItem(state =>
{
while (client.DownloadQueueLength > 0)
{
Thread.Sleep(0);
}
mre.Set();
});
Assert.IsTrue(mre.WaitOne(2000));
}
public static (byte[] comp, byte[] decomp) DecompressFull(ByteArrayStream source, int outputSize)
{
var startAddress = source.Address;
var dataSourceOffset = source.Word();
var dataSource = source.Branch(source.Address + dataSourceOffset);
var output = new ByteArrayStream(outputSize);
byte command;
while ((command = source.Byte()) != 0x00)
{
if ((command & 0x0f) != 0)
{
var length = command & 0x0f;
dataSource.CopyTo(output, length);
}
if ((command & 0xf0) != 0)
{
var length = ((command & 0xf0) >> 4) + 2;
var address = output.Address - source.Byte() - 1;
if (address < 0)
{
throw new IndexOutOfRangeException($"{nameof(address)} cannot be less than 0");
}
output.Branch(address).CopyTo(output, length);
}
}
var comp = source.GetBytes(dataSource.Address - startAddress, startAddress);
var decomp = output.GetBytes(output.Address, 0);
return(comp, decomp);
}
public static ScriptNodeData Serialize(ScriptGraphNode node)
{
ScriptNodeData data = new ScriptNodeData();
data.id = node.id;
data.type = node.Type;
data.outIds = node.outIds.ToArray();
data.rect = node.GetPosition();
ByteArrayStream stream = new ByteArrayStream();
switch (node.Type)
{
case NodeType.Root:
break;
case NodeType.Message:
Serialize(node as MessageNode, ref stream);
break;
case NodeType.Branch:
Serialize(node as BranchNode, ref stream);
break;
case NodeType.None:
default:
{
Debug.LogError("Invalid Node Type :" + node.Type.ToString());
}
break;
}
data.serialData = stream.GetBuffer();
return(data);
}
public static void Go()
{
var rom = FFMQ.Game.Rom;
//0B81A5 $AD $91 $0E LDA $0E91 [010E91] = $0D A:400D X:182E Y:0080 S:1FC8 D:0000 DB:01 P:nvMxdizc V:30 H:166
var start = 0x0d; // byte
start *= 2;
Console.WriteLine($"{nameof(start)} == {start.ToString("x2")}");
//0B81AF $BF $3B $AF $07 LDA $07AF3B,X[07AF55] = $0234 A: 001A X:001A Y:0080 S: 1FC8 D:0000 DB: 01 P: nvmxdizc V:30 H: 192
var lookup_07af3b = rom.GetStream(0x07af3b);
var offset = lookup_07af3b.WordAt(start);
Console.WriteLine($"{nameof(offset)} == {offset.ToString("x4")}");
//0B81BC $BF $13 $B0 $07 LDA $07B013,X[07B247] = $07 A: 0234 X: 0234 Y: 0000 S: 1FC8 D:0000 DB: 01 P: nvMxdiZc V:30 H: 229
//0B81C0 $99 $10 $19 STA $1910,Y[011910] = $00 A: 0207 X: 0234 Y: 0000 S: 1FC8 D:0000 DB: 01 P: nvMxdizc V:30 H: 239
//0B81C3 $E8 INX A: 0207 X: 0234 Y: 0000 S: 1FC8 D:0000 DB: 01 P: nvMxdizc V:30 H: 249
//0B81C4 $C8 INY A: 0207 X: 0235 Y: 0000 S: 1FC8 D:0000 DB: 01 P: nvMxdizc V:30 H: 252
//0B81C5 $C0 $07 $00 CPY #$0007 A:0207 X:0235 Y:0001 S:1FC8 D:0000 DB:01 P:nvMxdizc V:30 H:256
var optionsLookup = rom.GetStream(0x07b013);
// $1910 - $1916
// $1910 is index into tilemap data
// $1911 is index into bg tile graphics data
// $1912 is index into color palettes
var options = optionsLookup.GetBytesAt(7, offset);
Console.WriteLine($"{nameof(options)} == {options.ToHexString()}");
//; multiply(lower six bits of $1910) * 3
//0b850e sep #$20
//0b8510 lda $1910
//0b8513 and #$3f
//0b8515 sta $4202
//0b8518 lda #$03
//0b851a sta $4203
//; get multiply result
//0b8526 ldx $4216
var mapDataOffsetIndex = (options[0] & 0x3f) * 3;
Console.WriteLine($"{nameof(mapDataOffsetIndex)} == {mapDataOffsetIndex.ToString("x4")}");
var mapDataOffsetLookup = rom.GetStream(0x0b8735);
//; store source data lookup address, long, at $0900 => value at $0b8735,x
//0b8529 rep #$20
//0b852b lda $0b8735,x
//0b852f sta $0900
//0b8532 sep #$20
//0b8534 lda $0b8737,x
//0b8538 sta $0902
var mapDataOffset = mapDataOffsetLookup.LongAt(mapDataOffsetIndex);
Console.WriteLine($"{nameof(mapDataOffset)} == {mapDataOffset.ToString("x4")}");
// $1000 seems to be the largest map, but using $2000 for now
var(tilemapcomp, tilemapdecomp) = SimpleTailWindowCompression.DecompressFull(rom.GetStream(mapDataOffset), 0x2000);
Utilities.WriteBytesToFile(tilemapcomp, @"c:\working\ffmq\~go! -- comp.txt");
Utilities.WriteBytesToFile(tilemapdecomp, @"c:\working\ffmq\~go! -- decomp.txt");
// $19b7
var bgGraphicsOffsetsIndex = options[1] * 0x0a;
var lookup_0b8cd9 = rom.GetStream(0x0b8cd9);
// $1918 - $1921
// $1918 is ???
// $1919 is color data index to
// $191a to $1921 are bg tile graphics offsets
var x1918 = lookup_0b8cd9.GetBytesAt(0x0a, bgGraphicsOffsetsIndex);
// TODO: clean up data access, this is awkward
// bgTileIndexes is $191a to $1921
var bgTileIndexes = new ByteArrayStream(x1918, 2);
var bgTileData = rom.GetStream(0x058c80);
var bgTilePaletteIndexData = rom.GetStream(0x05f280);
var bgTileSets = new List <BgTileSetEntry>();
while (!bgTileIndexes.AtEnd)
{
var bgTileIndex = bgTileIndexes.Byte();
// $300 is $20 tiles of $18 bytes
var tileDataAddressOffset = 0x300 * bgTileIndex;
var tileData = ExpandSecondHalfWithZeros.Decompress(bgTileData.GetBytes(0x300, tileDataAddressOffset));
// $10 is $20 tiles, each a nibble
var paletteAddress = 0x10 * bgTileIndex;
var palette = ExpandNibblesMasked.Decompress(bgTilePaletteIndexData.GetBytes(0x10, paletteAddress));
bgTileSets.Add(new BgTileSetEntry {
TileDataAddress = bgTileData.Address + tileDataAddressOffset,
PaletteIndexAddress = bgTilePaletteIndexData.Address + paletteAddress,
TileData = tileData,
PaletteIndex = palette
});
}
Console.ReadKey();
}
public static byte[] Decompress(ByteArrayStream source, int outputSize)
{
var(comp, decomp) = DecompressFull(source, outputSize);
return(decomp);
}
private void saveJF3D(OpenGLModel model, IOStream os)
{
baos = new ByteArrayStream();
tmp = new byte[8];
int size;
writeuint32(MAGIC);
writeuint32(VERSION);
writeuint32(ID_MODEL);
size = 0;
int tcnt = model.textures.Size();
for (int a = 0; a < tcnt; a++)
{
size += model.textures.Get(a).Length + 1;
}
writeuint32(size);
writeuint32(tcnt);
for (int a = 0; a < tcnt; a++)
{
writeString(model.textures.Get(a));
}
for (int o = 0; o < model.ol.Size(); o++)
{
OpenGLObject obj = model.ol.Get(o);
writeuint32(ID_OBJECT);
int vcnt = obj.GetVertexCount() * 3;
int pcnt = obj.GetPolyCount();
size = obj.GetName().Length + 1 + 4 + (4 * 3) + (4 + (vcnt * 4)) + (4 + (pcnt * 4));
writeuint32(size);
writeString(obj.GetName());
writeuint32(obj.GetType());
writefloat(obj.GetOrigin().x);
writefloat(obj.GetOrigin().y);
writefloat(obj.GetOrigin().z);
writeuint32(vcnt / 3);
float[] xyz = obj.GetVertexBuffer();
for (int a = 0; a < vcnt; a++)
{
writefloat(xyz[a]);
}
switch (obj.GetType())
{
case GL_TRIANGLES:
writeuint32(pcnt / 3);
break;
case GL_QUADS:
writeuint32(pcnt / 4);
break;
}
int[] pts = obj.GetPolyBuffer();
for (int a = 0; a < pcnt; a++)
{
writeuint32(pts[a]);
}
int maps = obj.GetUVMaps().Size();
if (maps == 0)
{
Console.WriteLine("GL_JF3D:Warning:No UVMaps found for object:" + obj.GetName());
}
for (int m = 0; m < maps; m++)
{
OpenGLUVMap map = obj.GetUVMaps().Get(m);
writeuint32(ID_UVMAP);
int uvcnt = map.GetUVCount() * 2;
size = map.GetName().Length + 1 + 4 + (4 + (uvcnt * 4));
writeuint32(size);
writeString(map.GetName());
writeuint32(map.GetTextureIndex());
writeuint32(uvcnt / 2);
float[] uv = map.GetBuffer();
for (int a = 0; a < uvcnt; a++)
{
writefloat(uv[a]);
}
}
}
os.Write(baos.GetData().ToArray());
}
public bool Save(string filename, PlayerData playerData)
{
ByteArrayStream stream = new ByteArrayStream();
stream.WriteString("PTFF", 4);
byte version = playerData.Version;
stream.WriteByte(version);
stream.WriteByte(0); // ??
stream.WriteUShort(playerData.TickPerMinute);
stream.WriteFloat(playerData.Tempo);
UInt16 trackCount = playerData.Tracks.Count;
stream.WriteUShort(trackCount);
stream.writeUInt(playerData.HeaderEndTick);
stream.WriteFloat(playerData.TrackDuration);
ushort insCount = (ushort)(playerData.Instruments.Count - 1);
stream.WriteUShort(insCount);
for (int i = 0, l = playerData.Instruments.Count; i < l; i++)
{
InstrumentData ins = playerData.Instruments[i];
if (ins != null && ins.InsNum != 0)
{
if (version == 1)
{
stream.WriteUShort(ins.InsNum);
stream.WriteUShort(0);
}
else
{
stream.WriteByte((byte)ins.InsNum);
stream.WriteByte(0);
}
stream.WriteString(ins.Name, 0x40);
}
}
int eventSize = version == 1 ? 0x10 : 0x0B;
foreach (TrackData track in playerData.Tracks)
{
stream.writeUInt(EZTR);
int eventsCount = track.Events.Count();
int endTick = 0;
if (eventsCount > 0)
{
endTick = track.Events.Max(evnt => evnt.Tick);
}
uint blockSize = (uint)(eventsCount * eventSize);
stream.WriteString("", 0x02); // unknown
stream.WriteString(track.TrackName, 0x40);
stream.writeInt(endTick);
stream.writeUInt(blockSize);
if (version == 1)
{
stream.WriteUShort(0); // Unknown
}
foreach (EventData evnt in track.Events)
{
stream.writeInt(evnt.Tick);
stream.WriteByte((byte)evnt.EventType);
switch (evnt.EventType)
{
case EventType.Volume:
{
if (version == 1)
{
stream.WriteByte(0);
stream.WriteByte(0);
stream.WriteByte(0);
}
stream.WriteByte(evnt.Volume);
stream.WriteByte(0);
stream.WriteByte(0);
stream.WriteByte(0);
stream.WriteByte(0);
stream.WriteByte(0);
if (version == 1)
{
stream.WriteByte(0);
stream.WriteByte(0);
}
}
break;
case EventType.Note:
{
if (version == 1)
{
stream.WriteByte(0);
stream.WriteByte(0);
stream.WriteByte(0);
}
ushort insno = 0;
if (evnt.Instrument != null)
{
insno = evnt.Instrument.InsNum;
}
if (version == 1)
{
stream.WriteUShort(insno);
}
else
{
stream.WriteByte((byte)insno);
}
stream.WriteByte(evnt.Vel);
stream.WriteByte(evnt.Pan);
stream.WriteByte(evnt.Attribute);
stream.WriteUShort(evnt.Duration);
if (version == 1)
{
stream.WriteByte(0);
}
}
break;
case EventType.Tempo:
if (version == 1)
{
stream.WriteByte(0);
stream.WriteByte(0);
stream.WriteByte(0);
}
stream.Write(BitConverter.GetBytes(evnt.Tempo));
stream.WriteByte(0);
stream.WriteByte(0);
if (version == 1)
{
stream.WriteByte(0);
stream.WriteByte(0);
}
break;
case EventType.Beat:
if (version == 1)
{
stream.WriteByte(0);
stream.WriteByte(0);
stream.WriteByte(0);
}
stream.WriteUShort(evnt.Beat);
stream.WriteByte(0);
stream.WriteByte(0);
stream.WriteByte(0);
stream.WriteByte(0);
if (version == 1)
{
stream.WriteByte(0);
stream.WriteByte(0);
}
break;
default:
{
}
break;
}
}
}
byte[] ptffData = stream.GetData();
int sizeIn = ptffData.Count();
if (m_settingsDialog.EncryptFile /*playerData.Encrypted*/)
{
ptffData = EncryptDataOnline(ptffData);
if (ptffData == null || sizeIn != ptffData.Count())
{
return(false);
}
}
File.WriteAllBytes(filename, ptffData);
return(true);
}
public static Dictionary <String, TableVal> LoadPartialData(Schema s, String[] DataDirs, Firefly.Mapping.Binary.BinarySerializer bs)
{
var Entities = s.Types.Where(t => t.OnEntity).Select(t => t.Entity).ToList();
var DuplicatedCollectionNames = Entities.GroupBy(e => e.CollectionName).Where(g => g.Count() > 1).Select(g => g.Key).ToList();
if (DuplicatedCollectionNames.Count > 0)
{
throw new InvalidOperationException("DuplicatedCollectionNames: {0}".Formats(String.Join(" ", DuplicatedCollectionNames)));
}
var CollectionNameToEntity = Entities.ToDictionary(e => e.CollectionName, StringComparer.OrdinalIgnoreCase);
var EntityNameToEntity = Entities.ToDictionary(e => e.Name, StringComparer.OrdinalIgnoreCase);
var SchemaHash = s.Hash();
var Files = new Dictionary <String, Byte[]>();
foreach (var DataDirOrMemoryDatabaseFile in DataDirs)
{
foreach (var f in Directory.GetFiles(DataDirOrMemoryDatabaseFile, "*.tree", SearchOption.AllDirectories).OrderBy(ff => ff, StringComparer.OrdinalIgnoreCase))
{
Files.Add(f, File.ReadAllBytes(f));
}
}
var Forests = Files.AsParallel().Select(p =>
{
using (var bas = new ByteArrayStream(p.Value))
{
using (var sr = Txt.CreateTextReader(bas.AsNewReading(), Firefly.TextEncoding.TextEncoding.Default))
{
return(TreeFile.ReadDirect(sr, p.Key, new TreeFormatParseSetting(), new TreeFormatEvaluateSetting()).Value.Nodes);
}
}
}).ToList();
var Tables = new Dictionary <String, List <Node> >();
foreach (var Forest in Forests)
{
foreach (var n in Forest)
{
if (!n.OnStem)
{
continue;
}
var Name = n.Stem.Name;
if (CollectionNameToEntity.ContainsKey(Name))
{
Name = CollectionNameToEntity[Name].Name;
}
if (!Tables.ContainsKey(Name))
{
Tables.Add(Name, new List <Node>());
}
var t = Tables[Name];
t.AddRange(n.Stem.Children);
}
}
var rvts = new RelationValueTreeSerializer(s);
var TableValues = new Dictionary <String, TableVal>(StringComparer.OrdinalIgnoreCase);
foreach (var p in Tables)
{
var EntityName = p.Key;
var e = EntityNameToEntity[EntityName];
var tv = rvts.ReadTable(p.Value, e);
TableValues.Add(EntityName, tv);
}
return(TableValues);
}
public static byte[] Compress(ByteArrayStream target)
{
var commands = new List <byte>();
var data = new List <byte>();
var copyData = 0;
while (!target.AtEnd)
{
var term = target.GetBytes(0x11);
var copyOutput = 0;
var copyOffset = -1;
while (term.Length >= 3)
{
var(found, address) = target.FindLastInWindow(term, target.Address - 256, target.Address + term.Length - 1);
if (found)
{
copyOutput = term.Length - 2;
copyOffset = target.Address - address - 1;
break;
}
term = target.GetBytes(term.Length - 1);
}
if (copyOutput == 0)
{
if (copyData == 0xf)
{
commands.Add((byte)copyData);
copyData = 1;
}
else
{
copyData++;
}
data.Add(target.Byte());
}
else
{
commands.Add((byte)((copyOutput << 4) + copyData));
commands.Add((byte)copyOffset);
copyData = 0;
target.Address += term.Length;
}
}
// Add last copy data command
if (copyData != 0)
{
commands.Add((byte)copyData);
}
// Add terminating command
commands.Add(0);
var output = new ByteArrayStream(commands.Count + data.Count + 2);
var dataOffset = commands.Count;
if (dataOffset > 0xffff)
{
throw new Exception($"{nameof(dataOffset)} cannot be larger than 0xffff. {nameof(commands)} is too large");
}
output.Word((ushort)dataOffset);
output.Write(commands);
output.Write(data);
return(output.Buffer);
}
private static void Serialize(BranchNode node, ref ByteArrayStream stream)
{
stream.WriteBool(node.flag);
}
/// <summary>
/// Deserialize a message from the stream.
/// </summary>
/// <param name="networkClient">The network client to deserialize the message from.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>The message that was deserialized.</returns>
public async Task <IMessage> DeserializeAsync(INetworkClient networkClient, CancellationToken cancellationToken = default(CancellationToken))
{
var stream = new ByteArrayStream(await networkClient.ReadDotBlockAsync(cancellationToken).ConfigureAwait(false));
return(new TextMessage(stream));
}
private bool OpenFromByteArrayStream(ByteArrayStream stream, out PlayerData playerData)
{
playerData = null;
if (stream == null)
{
return(false);
}
playerData = new PlayerData();
var instruments = playerData.Instruments;
var tracks = playerData.Tracks;
var sign = stream.ReadUInt(); // zero??
var num = stream.ReadUInt();
var pos = stream.ReadUInt();
stream.Seek(num);
var insCnt = stream.ReadUShort();
var trackCnt = (byte)stream.ReadUShort();
var tickPerMinute = stream.ReadUShort();
var tempo = stream.ReadFloat();
var tick1 = stream.ReadUInt();
playerData.HeaderEndTick = tick1;
var playTime = stream.ReadFloat();
var endTick = stream.ReadUInt();
stream.ReadUInt();
playerData.Encrypted = true;
playerData.Version = 1;
playerData.TrackDuration = playTime;
playerData.TickPerMinute = tickPerMinute;
playerData.Tempo = tempo;
playerData.HeaderEndTick = endTick;
stream.Seek(8);
instruments.Add(new InstrumentData()
{
InsNum = 0,
Name = "none"
});
for (int i = 0; i < insCnt; i++)
{
ushort insNo = stream.ReadUShort();
stream.Skip(1);
string oggName = stream.ReadString(0x40);
if (m_settingsDialog.RenameInst)
{
oggName = oggName.Replace(".wav", ".ogg");
}
instruments.Add(new InstrumentData()
{
InsNum = insNo,
Name = oggName,
});
}
for (byte trackIdx = 0; (int)trackIdx < (int)trackCnt; ++trackIdx)
{
stream.Skip(2);
var trackName = stream.ReadString(0x40);
stream.Skip(4);
var track = new TrackData(trackIdx)
{
TrackName = trackName,
};
tracks.AddTrack(track);
var eventsCount = (ushort)stream.ReadUInt();
for (ushort index = 0; (int)index < (int)eventsCount; ++index)
{
uint tick = stream.ReadUInt();
byte eventCode = stream.ReadByte();
switch (eventCode)
{
case 1:
{ // Note
var insNo = stream.ReadUShort();
var vel = stream.ReadByte();
var pan = stream.ReadByte();
var attribute = stream.ReadByte();
var duration = stream.ReadUShort();
stream.Skip(1);
InstrumentData inst =
playerData.Instruments.SingleOrDefault(ins => ins.InsNum == insNo);
EventData newEvent = new EventData()
{
TrackId = trackIdx,
Tick = (int)tick,
Attribute = attribute,
Duration = duration,
EventType = EventType.Note,
Instrument = inst,
Vel = vel,
Pan = pan
};
track.AddEvent(newEvent);
}
break;
case 2:
{
var volume = stream.ReadByte();
stream.Skip(7);
var newEvent = new EventData()
{
TrackId = trackIdx,
Tick = (int)tick,
EventType = EventType.Volume,
Volume = volume
};
track.AddEvent(newEvent);
}
break;
case 3:
{
var tempo2 = stream.ReadFloat();
stream.Skip(4);
var newEvent = new EventData()
{
TrackId = trackIdx,
Tick = (int)tick,
EventType = EventType.Tempo,
Tempo = tempo2
};
track.AddEvent(newEvent);
}
break;
case 4:
stream.Skip(8);
break;
default:
throw new Exception("Failed to read op");
}
}
}
return(true);
}
public VideoFramesFileWriter([NotNull] string fileName, bool compress, long baseTime = 0, int bufferSize = 2048) : base(fileName, bufferSize, baseTime)
{
_compress = compress;
_byteArrayStream = compress ? new ByteArrayStream(1 << 20) : null;
}
private static void Serialize(MessageNode node, ref ByteArrayStream stream)
{
stream.WriteString(node.text);
}
