static void WriteText(uint ofs)
{
byte command;
sReader.Keep();
sReader.Goto(sTextOffset + ofs);
var maxofs = 0u;
do
{
var pos = sReader.Position - sTextOffset;
command = sReader.Read8();
sWriter.Write(" {0:X8} {1}", pos, sCommandNames[command]);
var nextofs = 0u;
switch (command)
{
case 0x00: sWriter.Write(" {0}", sReader.ReadS32()); break;
case 0x01: sWriter.Write(" {0}", sReader.ReadF32()); break;
case 0x02: {
var data = sReader.ReadS32();
var value = FetchDataValue(data);
sWriter.Write(" {0} # \"{1}\"", data, value);
break;
}
case 0x03: sWriter.Write(" ${0:X8}", sReader.Read32()); break;
case 0x04: WriteVar(); break;
case 0x06: WriteVar(); break;
case 0x07: WriteVar(); break;
case 0x0D: {
sReader.Read8(); // TSpcInterp skips this byte
WriteVar();
break;
}
case 0x1C: {
var dest = sReader.Read32();
var args = sReader.ReadS32();
var symbol = FetchSymbol(i => i.Data == dest);
if (symbol != null)
{
sWriter.Write(" {0}, {1}", FetchSymbolName(symbol), args);
}
else
{
sWriter.Write(" ${0:X8}, {1}", dest, args);
}
break;
}
case 0x1D: sWriter.Write(" {0}, {1}", FetchSymbolName(FetchSymbol(sReader.ReadS32())), sReader.ReadS32()); break;
case 0x1E: sWriter.Write(" {0}", sReader.ReadS32()); break;
case 0x1F: sWriter.Write(" {0}", sReader.ReadS32()); break;
case 0x22: nextofs = WriteJmp(ofs); break;
case 0x23: nextofs = WriteJmp(ofs); break;
}
sWriter.WriteLine();
if (nextofs > maxofs)
{
maxofs = nextofs;
}
} while (!IsReturnCommand(command) || sReader.Position <= sTextOffset + maxofs);
sWriter.WriteLine();
sReader.Back();
}
static bool WriteAafHeader(aBinaryReader reader, aBinaryWriter writer, int id, int index, byte[] data)
{
long reader_base = reader.Position;
long writer_base = writer.Position;
int old_offset, old_size;
if (!ReadAafHeader(reader, id, index, out old_offset, out old_size))
{
return(false);
}
int difference = (data.Length - old_size);
reader.Goto(reader_base);
int section;
while ((section = reader.ReadS32()) != 0)
{
bool has_vnum = (section == 2 || section == 3);
writer.WriteS32(section);
int offset, size;
int i = 0;
while ((offset = reader.ReadS32()) != 0)
{
size = reader.ReadS32();
if (offset > old_offset)
{
offset += difference;
}
writer.Keep();
writer.Goto(writer_base + offset);
if (section == id && i == index)
{
writer.Write8s(data);
size = data.Length;
}
else
{
reader.Keep();
reader.Goto(reader_base + offset);
writer.Write8s(reader.Read8s(size));
reader.Back();
}
writer.Back();
writer.WriteS32(offset);
writer.WriteS32(size);
if (has_vnum)
{
writer.WriteS32(reader.ReadS32());
}
++i;
}
writer.WriteS32(0);
}
writer.WriteS32(0);
writer.Goto(writer.Length);
writer.WritePadding(32, 0);
return(true);
}
protected override WaveBank DoTransform(WaveBank obj)
{
if (obj != null)
{
return(obj);
}
mReader.Keep();
mReader.PushAnchor();
if (mReader.Read32() != WSYS)
{
mareep.WriteError("WSYS: could not find header.");
}
var size = mReader.ReadS32();
mReader.Step(8); // unused
var winfOffset = mReader.ReadS32();
var wbctOffset = mReader.ReadS32();
mareep.WriteMessage("WSYS: header found, size {0:F1} KB\n", ((double)size / 1024.0d));
var waveBank = new WaveBank();
waveBank.Name = mName;
mReader.Goto(winfOffset);
if (mReader.Read32() != WINF)
{
mareep.WriteError("WSYS: could not find WINF at 0x{0:X6}.", winfOffset);
}
var waveGroupCount = mReader.ReadS32();
if (waveGroupCount < 0)
{
mareep.WriteError("WSYS: bad wave-group count '{0}' in WINF.", waveGroupCount);
}
mareep.WriteMessage("WSYS: WINF found, {0} wave group(s).\n", waveGroupCount);
var waveGroupOffsets = mReader.ReadS32s(waveGroupCount);
mReader.Goto(wbctOffset);
if (mReader.Read32() != WBCT)
{
mareep.WriteError("WSYS: could not find WBCT at 0x{0:X6}.", wbctOffset);
}
mReader.Step(4); // unused
var sceneCount = mReader.ReadS32();
if (sceneCount != waveGroupCount)
{
mareep.WriteError("WSYS: WINF count ({0}) does not match WBCT count ({1}).", waveGroupCount, sceneCount);
}
var sceneOffsets = mReader.ReadS32s(sceneCount);
for (var i = 0; i < waveGroupCount; ++i)
{
mReader.Goto(waveGroupOffsets[i]);
var archiveName = mReader.ReadString <aCSTR>(112);
var waveInfoCount = mReader.ReadS32();
if (waveInfoCount < 0)
{
mareep.WriteError("WSYS: bad wave count '{0}' in wave group #{1}.", waveInfoCount, i);
}
var waveInfoOffsets = mReader.ReadS32s(waveInfoCount);
mReader.Goto(sceneOffsets[i]);
if (mReader.Read32() != SCNE)
{
mareep.WriteError("WSYS: could not find SCNE at 0x{0:X6}.", sceneOffsets[i]);
}
mReader.Step(8); // unused
var cdfOffset = mReader.ReadS32();
mReader.Goto(cdfOffset);
if (mReader.Read32() != C_DF)
{
mareep.WriteError("WSYS: could not find C-DF at 0x{0:X6}.", cdfOffset);
}
var waveidCount = mReader.ReadS32();
if (waveidCount != waveInfoCount)
{
mareep.WriteError("WSYS: C-DF count ({0}) does not match wave-info count ({1}).", waveidCount, waveInfoCount);
}
var waveidOffsets = mReader.ReadS32s(waveidCount);
var waveGroup = new WaveGroup();
waveGroup.ArchiveFileName = archiveName;
for (var j = 0; j < waveInfoCount; ++j)
{
var wave = new Wave();
mReader.Goto(waveidOffsets[j]);
var waveid = (mReader.ReadS32() & 0xFFFF);
wave.WaveId = waveid;
mReader.Goto(waveInfoOffsets[j]);
mReader.Step(1); // unknown
var format = (WaveFormat)mReader.Read8();
if (!format.IsDefined())
{
mareep.WriteError("WSYS: group #{0}: wave #{1}: bad format '{2}'.", i, j, (byte)format);
}
else
{
wave.Format = format;
}
var key = mReader.Read8();
if (key < 0 || key > 127)
{
mareep.WriteError("WSYS: group #{0}: wave #{1}: bad root key '{2}'.", i, j, key);
}
else
{
wave.RootKey = key;
}
mReader.Step(1); // alignment
var sampleRate = mReader.ReadF32();
if (sampleRate < 0.0f)
{
mareep.WriteError("WSYS: group #{0}: wave #{1}: bad sample rate '{2:F1}'.", i, j, sampleRate);
}
else
{
wave.SampleRate = sampleRate;
}
var waveStart = mReader.ReadS32();
if (waveStart < 0)
{
mareep.WriteError("WSYS: group #{0}: wave #{1}: bad wave start '{2}'.", i, j, waveStart);
}
else
{
wave.WaveStart = waveStart;
}
var waveSize = mReader.ReadS32();
if (waveSize < 0)
{
mareep.WriteError("WSYS: group #{0}: wave #{1}: bad wave size '{1}'.", i, j, waveSize);
}
else
{
wave.WaveSize = waveSize;
}
wave.Loop = (mReader.Read32() != 0);
var loopStart = mReader.ReadS32();
if (loopStart < 0)
{
mareep.WriteError("WSYS: group #{0}: wave #{1}: bad loop start '{2}'.", i, j, loopStart);
}
else
{
wave.LoopStart = loopStart;
}
var loopEnd = mReader.ReadS32();
if (loopEnd < 0)
{
mareep.WriteError("WSYS: group #{0}: wave #{1}: bad loop end '{2}'.", i, j, loopEnd);
}
else
{
wave.LoopEnd = loopEnd;
}
var sampleCount = mReader.ReadS32();
wave.SampleCount = mareep.CalculateSampleCount(format, waveSize);
if (loopStart > loopEnd)
{
mareep.WriteWarning("WSYS: group #{0}: wave #{1}: loop start '{2}' is greater than loop end '{3}'.\n", i, j, loopStart, loopEnd);
}
if (loopStart > wave.SampleCount)
{
mareep.WriteWarning("WSYS: group #{0}: wave #{1}: loop start '{2}' is greater than sample count '{3}'.\n", i, j, loopStart, wave.SampleCount);
}
if (loopEnd > wave.SampleCount)
{
mareep.WriteWarning("WSYS: group #{0}: wave #{1}: loop end '{2}' is greater than sample count '{3}'.\n", i, j, loopEnd, wave.SampleCount);
}
wave.HistoryLast = mReader.ReadS16();
wave.HistoryPenult = mReader.ReadS16();
// rest of the fields are unknown or runtime
waveGroup.Add(wave);
}
waveBank.Add(waveGroup);
}
mReader.PopAnchor();
mReader.Back();
return(waveBank);
}
static bool WriteAafHeader(aBinaryReader reader, aBinaryWriter writer, int id, int index, byte[] data)
{
long reader_base = reader.Position;
long writer_base = writer.Position;
int old_offset, old_size;
if (!ReadAafHeader(reader, id, index, out old_offset, out old_size))
{
return(false);
}
int difference = (data.Length - old_size);
mareep.WriteMessage("Entry size difference: {0} byte(s)\n", difference);
int danger_level = 0;
reader.Goto(reader_base);
int section;
while ((section = reader.ReadS32()) != 0)
{
if (danger_level++ > 1000)
{
mareep.WriteError("CHARGE: malformed AAF file (endless loop detected)");
}
bool has_vnum = (section == 2 || section == 3);
writer.WriteS32(section);
int offset, size;
int i = 0;
while ((offset = reader.ReadS32()) != 0)
{
if (danger_level++ > 1000)
{
mareep.WriteError("CHARGE: malformed AAF file (endless loop detected)");
}
size = reader.ReadS32();
int new_offset = offset;
if (new_offset > old_offset)
{
new_offset += difference;
}
writer.Keep();
writer.Goto(writer_base + new_offset);
if (section == id && i == index)
{
writer.Write8s(data);
size = data.Length;
}
else
{
reader.Keep();
reader.Goto(reader_base + offset);
writer.Write8s(reader.Read8s(size));
reader.Back();
}
writer.Back();
writer.WriteS32(new_offset);
writer.WriteS32(size);
if (has_vnum)
{
writer.WriteS32(reader.ReadS32());
}
++i;
}
writer.WriteS32(0);
}
writer.WriteS32(0);
writer.Goto(writer.Length);
writer.WritePadding(32, 0);
return(true);
}