static void DecodeStreamAdpcm(aBinaryReader reader, aBinaryWriter writer, int sampleCount)
{
var left = new short[16];
int left_last = 0, left_penult = 0;
var right = new short[16];
int right_last = 0, right_penult = 0;
for (var i = 0; i < sampleCount; i += 16)
{
Waveform.Adpcm4toPcm16(reader.Read8s(9), left, ref left_last, ref left_penult);
Waveform.Adpcm4toPcm16(reader.Read8s(9), right, ref right_last, ref right_penult);
for (var j = 0; j < 16 && (i + j) < sampleCount; ++j)
{
writer.WriteS16(left[j]);
writer.WriteS16(right[j]);
}
if ((i % cMessageInterval) == 0 || (i + 16) >= sampleCount)
{
mareep.WriteMessage("\rSamples encoded: {0}/{1}", System.Math.Min((i + 16), sampleCount), sampleCount);
}
}
}
void WriteSdta()
{
mWriter.WriteString("LIST");
mWriter.WriteS32(CalculateSmplSize() + 12);
mWriter.WriteString("sdta");
mWriter.WriteString("smpl");
mWriter.WriteS32(CalculateSmplSize());
foreach (var waveGroup in mWaveBank)
{
var archiveFileName = Path.Combine(mInputDirectory, waveGroup.ArchiveFileName);
using (var instream = mareep.OpenFile(archiveFileName)) {
var reader = new aBinaryReader(instream, Endianness.Big);
mareep.WriteSeparator('-');
mareep.WriteMessage("{0} ({1} wave(s))\n", waveGroup.ArchiveFileName, waveGroup.Count);
foreach (var wave in waveGroup)
{
reader.Goto(wave.WaveStart);
var data = reader.Read8s(wave.WaveSize);
var mixer = new RawWaveMixer(new MemoryStream(data), wave.Format);
mixer.Write(WaveFormat.Pcm16, mWriter);
for (var i = 0; i < 92; i++)
{
mWriter.WriteS8(0);
}
}
}
}
}
protected override void loadBlo1(aBinaryReader reader)
{
base.loadBlo1(reader);
var finder = bloResourceFinder.getFinder();
int numparams = reader.Read8();
mFont = finder.find <bloResFont>(reader, "font");
mTopColor = new bloColor(reader.Read32());
mBottomColor = new bloColor(reader.Read32());
int binding = reader.Read8();
mHBinding = (bloTextboxHBinding)((binding >> 2) & 3);
mVBinding = (bloTextboxVBinding)((binding >> 0) & 3);
mFontSpacing = reader.ReadS16();
mFontLeading = reader.ReadS16();
mFontWidth = reader.Read16();
mFontHeight = reader.Read16();
int strlen = reader.Read16();
setString(reader.Read8s(strlen));
numparams -= 10;
if (numparams > 0)
{
if (reader.Read8() != 0)
{
setConnectParent(true);
}
--numparams;
}
if (numparams > 0)
{
mFromColor = new bloColor(reader.Read32());
--numparams;
}
else
{
mFromColor = new bloColor(bloColor.cZero);
}
if (numparams > 0)
{
mToColor = new bloColor(reader.Read32());
--numparams;
}
else
{
mToColor = new bloColor(bloColor.cOne);
}
reader.Skip(4);
}
protected override WaveBank DoTransform(WaveBank obj)
{
if (obj == null)
{
return(null);
}
if (!Directory.Exists(mWaveDirectory))
{
mareep.WriteMessage("Creating directory '{0}'...\n", mWaveDirectory);
Directory.CreateDirectory(mWaveDirectory);
}
mareep.WriteMessage("Transferring waves...\n");
var extension = (mExtractWav ? "wav" : "raw");
foreach (var waveGroup in obj)
{
var archiveFileName = Path.Combine(mBankDirectory, waveGroup.ArchiveFileName);
var archiveNoExtension = Path.GetFileNameWithoutExtension(waveGroup.ArchiveFileName);
using (var input = mareep.OpenFile(archiveFileName)) {
var reader = new aBinaryReader(input, Endianness.Big);
mareep.WriteSeparator('-');
mareep.WriteMessage("{0} ({1} wave(s))\n", waveGroup.ArchiveFileName, waveGroup.Count);
foreach (var wave in waveGroup)
{
wave.FileName = String.Format("{0}_{1:D5}.{2}.{3}", archiveNoExtension, wave.WaveId, wave.Format.ToLowerString(), extension);
string waveFileName = Path.Combine(mWaveDirectory, wave.FileName);
using (var output = mareep.CreateFile(waveFileName)) {
reader.Goto(wave.WaveStart);
var data = reader.Read8s(wave.WaveSize);
if (mExtractWav)
{
ExtractWav(wave, data, output);
}
else
{
ExtractRaw(wave, data, output);
}
}
mareep.WriteMessage(" #{0:X4} {1} {2} {3}Hz {4} samples\n", wave.WaveId, mareep.ConvertKey(wave.RootKey), wave.Format.ToLowerString(), (int)wave.SampleRate, wave.SampleCount);
}
}
}
return(obj);
}
protected override void loadCompact(aBinaryReader reader)
{
base.loadCompact(reader);
var finder = bloResourceFinder.getFinder();
mFont = finder.find <bloResFont>(reader, "font");
mTopColor = new bloColor(reader.Read32());
mBottomColor = new bloColor(reader.Read32());
int hbinding = reader.Read8();
mHBinding = (bloTextboxHBinding)(hbinding & 127);
mVBinding = (bloTextboxVBinding)reader.Read8();
if ((hbinding & 0x80) != 0)
{
mFontSpacing = reader.ReadS16();
mFontLeading = reader.ReadS16();
mFontWidth = reader.Read16();
mFontHeight = reader.Read16();
}
else if (mFont != null)
{
mFontSpacing = 0;
mFontLeading = mFont.getLeading();
mFontWidth = mFont.getWidth();
mFontHeight = mFont.getHeight();
}
else
{
mFontSpacing = 0;
mFontLeading = 0;
mFontWidth = 0;
mFontHeight = 0;
}
int strlen = reader.Read16();
setString(reader.Read8s(strlen));
mFromColor = new bloColor(bloColor.cZero);
mToColor = new bloColor(bloColor.cOne);
reader.Skip(4);
}
void DoExtractWsys()
{
if (mAafInPath == null)
{
mareep.WriteError("CHARGE: missing -init-data-file parameter");
}
if (mOutput == null)
{
mareep.WriteError("CHARGE: missing -output parameter");
}
if (mTarget == null)
{
mareep.WriteError("CHARGE: missing -target parameter");
}
int index;
if (!Int32.TryParse(mTarget, out index))
{
mareep.WriteError("CHARGE: bad target {0}", mTarget);
}
using (Stream stream = mareep.OpenFile(mAafInPath)) {
mareep.WriteMessage("Scanning AAF header...\n");
aBinaryReader reader = new aBinaryReader(stream, Endianness.Big);
int offset, size;
if (!ReadAafHeader(reader, 3, index, out offset, out size))
{
mareep.WriteError("CHARGE: failed to find wave bank data\n");
}
reader.Goto(offset);
if (reader.ReadS32() != 0x57535953) // 'WSYS'
{
mareep.WriteError("CHARGE: could not find 'WSYS' header");
}
mareep.WriteMessage("Found wave bank data {0} (0x{1:X6}, 0x{2:X6})\n", index, offset, size);
mareep.WriteMessage("Extracting wave bank data...\n");
reader.Goto(offset);
WriteFileData(mOutput, reader.Read8s(size));
}
}
public GlyphBlock(aBinaryReader reader)
{
firstCode = reader.Read16(); // 0008
lastCode = reader.Read16(); // 000A
cellWidth = reader.Read16(); // 000C
cellHeight = reader.Read16(); // 000E
sheetSize = reader.ReadS32(); // 0010
sheetFormat = (gxTextureFormat)reader.Read16(); // 0014
sheetRow = reader.Read16(); // 0016
sheetColumn = reader.Read16(); // 0018
sheetWidth = reader.Read16(); // 001A
sheetHeight = reader.Read16(); // 001C
reader.Step(2); // 001E
// we have to manually calculate how many sheets there are
int sheetCount = (((lastCode - firstCode) / (sheetRow * sheetColumn)) + 1);
sheets = aCollection.Initialize(sheetCount, () => reader.Read8s(sheetSize));
}
static void Main(string[] arguments)
{
Message("doomwadcorrupter v{0} arookas", new Version(0, 1, 12));
Separator();
if (arguments == null || arguments.Length < 2)
{
Message("Usage: doomwadcorrupter <input.wad> <output.wad> [options]");
Message();
Message("Options:");
Message(" -start <value>");
Message(" -end <value>");
Message(" -inc <value>");
Message(" -mode <type> [<value>]");
Message(" -skip <filter> [<filter> [...]]");
Message(" -only <filter> [<filter> [...]]");
Message(" -zdoom");
Message();
Message("For more detailed instructions, refer to the official repo page.");
Pause();
Exit(false);
}
var inputWAD = arguments[0];
var outputWAD = arguments[1];
cmd = new aCommandLine(arguments.Skip(2).ToArray());
options = new CorrupterOptions(cmd);
DisplayOptions(inputWAD, outputWAD);
int lumpCount;
var lumpsCorrupted = 0;
var lumpsSkipped = 0;
var bytesCorrupted = 0;
rnd = new Random((uint)options.CorruptSeed);
var timeTaken = Stopwatch.StartNew();
using (var instream = OpenWAD(inputWAD)) {
var reader = new aBinaryReader(instream, Endianness.Little, Encoding.ASCII);
// header
var wadType = reader.ReadString(4);
if (wadType != "IWAD" && wadType != "PWAD")
{
Error("Input file is not a DOOM WAD.");
}
lumpCount = reader.ReadS32();
var directoryOffset = reader.ReadS32();
// directory
reader.Goto(directoryOffset);
var lumps = aCollection.Initialize(lumpCount, () => new Lump(reader));
using (var outstream = CreateWAD(outputWAD)) {
var writer = new aBinaryWriter(outstream, Endianness.Little, Encoding.ASCII);
// header
writer.WriteString(wadType);
writer.WriteS32(lumpCount);
writer.WriteS32(directoryOffset);
// data
var corruptBuff = new byte[options.Increment];
var startBuff = new byte[options.Start];
var ns = LumpNamespace.Global;
foreach (var lump in lumps)
{
reader.Goto(lump.Start);
writer.Goto(lump.Start);
CheckNamespaceMarker(lump, ref ns);
if (options.Filter.IsCorruptable(lump.Name, ns) && !(options.ZDOOM && IsZDOOMLump(lump.Name)))
{
++lumpsCorrupted;
var i = options.Start;
var end = options.End ?? lump.Length;
if (i > 0)
{
var count = (int)System.Math.Min(lump.Length, i);
reader.Read(startBuff, count);
writer.Write8s(startBuff, count);
}
while (i < lump.Length && i < end)
{
Status("Corrupting '{0}'... (0x{1:X8} / 0x{2:X8})", lump.Name, i, lump.Length);
var count = (int)System.Math.Min(lump.Length - i, options.Increment);
reader.Read(corruptBuff, count);
CorruptByte(ref corruptBuff[0], options.CorruptMode, options.CorruptValue);
writer.Write8s(corruptBuff, count);
++bytesCorrupted;
i += count;
}
}
else
{
++lumpsSkipped;
writer.Write8s(reader.Read8s(lump.Length));
}
}
// directory
writer.Goto(directoryOffset);
foreach (var lump in lumps)
{
Status("Writing lump directory for '{0}'...", lump.Name);
lump.ToStream(writer);
}
}
}
timeTaken.Stop();
Status("Finished corrupting.");
Message();
Separator();
Message(" Files : {0}", lumpCount);
Message(" Files corrupted : {0}", lumpsCorrupted);
Message(" Files skipped : {0}", lumpsSkipped);
Message("Bytes mercilessly sacrificed : {0}", bytesCorrupted);
Message(" Time taken : {0}", timeTaken.Elapsed.ToString("g"));
Message(" Finished at : {0}", DateTime.Now.ToString("HH:mm:ss tt"));
Pause();
}
static void Main(string[] arguments)
{
Message("doomwadcorrupter v{0} arookas", new Version(0, 1, 12));
Separator();
if (arguments == null || arguments.Length < 2) {
Message("Usage: doomwadcorrupter <input.wad> <output.wad> [options]");
Message();
Message("Options:");
Message(" -start <value>");
Message(" -end <value>");
Message(" -inc <value>");
Message(" -mode <type> [<value>]");
Message(" -skip <filter> [<filter> [...]]");
Message(" -only <filter> [<filter> [...]]");
Message(" -zdoom");
Message();
Message("For more detailed instructions, refer to the official repo page.");
Pause();
Exit(false);
}
var inputWAD = arguments[0];
var outputWAD = arguments[1];
cmd = new aCommandLine(arguments.Skip(2).ToArray());
options = new CorrupterOptions(cmd);
DisplayOptions(inputWAD, outputWAD);
int lumpCount;
var lumpsCorrupted = 0;
var lumpsSkipped = 0;
var bytesCorrupted = 0;
rnd = new Random((uint)options.CorruptSeed);
var timeTaken = Stopwatch.StartNew();
using (var instream = OpenWAD(inputWAD)) {
var reader = new aBinaryReader(instream, Endianness.Little, Encoding.ASCII);
// header
var wadType = reader.ReadString(4);
if (wadType != "IWAD" && wadType != "PWAD") {
Error("Input file is not a DOOM WAD.");
}
lumpCount = reader.ReadS32();
var directoryOffset = reader.ReadS32();
// directory
reader.Goto(directoryOffset);
var lumps = aCollection.Initialize(lumpCount, () => new Lump(reader));
using (var outstream = CreateWAD(outputWAD)) {
var writer = new aBinaryWriter(outstream, Endianness.Little, Encoding.ASCII);
// header
writer.WriteString(wadType);
writer.WriteS32(lumpCount);
writer.WriteS32(directoryOffset);
// data
var corruptBuff = new byte[options.Increment];
var startBuff = new byte[options.Start];
var ns = LumpNamespace.Global;
foreach (var lump in lumps) {
reader.Goto(lump.Start);
writer.Goto(lump.Start);
CheckNamespaceMarker(lump, ref ns);
if (options.Filter.IsCorruptable(lump.Name, ns) && !(options.ZDOOM && IsZDOOMLump(lump.Name))) {
++lumpsCorrupted;
var i = options.Start;
var end = options.End ?? lump.Length;
if (i > 0) {
var count = (int)System.Math.Min(lump.Length, i);
reader.Read(startBuff, count);
writer.Write8s(startBuff, count);
}
while (i < lump.Length && i < end) {
Status("Corrupting '{0}'... (0x{1:X8} / 0x{2:X8})", lump.Name, i, lump.Length);
var count = (int)System.Math.Min(lump.Length - i, options.Increment);
reader.Read(corruptBuff, count);
CorruptByte(ref corruptBuff[0], options.CorruptMode, options.CorruptValue);
writer.Write8s(corruptBuff, count);
++bytesCorrupted;
i += count;
}
}
else {
++lumpsSkipped;
writer.Write8s(reader.Read8s(lump.Length));
}
}
// directory
writer.Goto(directoryOffset);
foreach (var lump in lumps) {
Status("Writing lump directory for '{0}'...", lump.Name);
lump.ToStream(writer);
}
}
}
timeTaken.Stop();
Status("Finished corrupting.");
Message();
Separator();
Message(" Files : {0}", lumpCount);
Message(" Files corrupted : {0}", lumpsCorrupted);
Message(" Files skipped : {0}", lumpsSkipped);
Message("Bytes mercilessly sacrificed : {0}", bytesCorrupted);
Message(" Time taken : {0}", timeTaken.Elapsed.ToString("g"));
Message(" Finished at : {0}", DateTime.Now.ToString("HH:mm:ss tt"));
Pause();
}
protected override void CalculateHistoryAdpcm2(int sample, out int last, out int penult)
{
last = 0;
penult = 0;
var frame = (sample / 16);
if (frame == 0)
{
return;
}
switch (mFormat)
{
case WaveFormat.Pcm8: {
var adpcm2 = new byte[5];
var pcm16 = new short[16];
int _last = 0, _penult = 0;
mReader.Goto(0);
for (var i = 0; i < frame; ++i)
{
for (var j = 0; j < 16; ++j)
{
pcm16[j] = 0;
if ((i * 16 + j) < mSampleCount)
{
Waveform.Pcm8toPcm16(mReader.ReadS8(), out pcm16[j]);
}
}
Waveform.Pcm16toAdpcm2(pcm16, adpcm2, ref _last, ref _penult);
Waveform.Adpcm2toPcm16(adpcm2, pcm16, ref last, ref penult);
}
break;
}
case WaveFormat.Pcm16: {
var adpcm2 = new byte[5];
var pcm16 = new short[16];
int _last = 0, _penult = 0;
mReader.Goto(0);
for (var i = 0; i < frame; ++i)
{
for (var j = 0; j < 16; ++j)
{
pcm16[j] = 0;
if ((i * 16 + j) < mSampleCount)
{
pcm16[j] = mReader.ReadS16();
}
}
Waveform.Pcm16toAdpcm2(pcm16, adpcm2, ref _last, ref _penult);
Waveform.Adpcm2toPcm16(adpcm2, pcm16, ref last, ref penult);
}
break;
}
case WaveFormat.Adpcm2: {
var pcm16 = new short[16];
mReader.Goto(0);
for (var i = 0; i < frame; ++i)
{
Waveform.Adpcm2toPcm16(mReader.Read8s(5), pcm16, ref last, ref penult);
}
break;
}
case WaveFormat.Adpcm4: {
var adpcm2 = new byte[5];
var pcm16 = new short[16];
int last1 = 0, penult1 = 0;
int last2 = 0, penult2 = 0;
mReader.Goto(0);
for (var i = 0; i < frame; ++i)
{
Waveform.Adpcm4toPcm16(mReader.Read8s(9), pcm16, ref last1, ref penult1);
Waveform.Pcm16toAdpcm2(pcm16, adpcm2, ref last2, ref penult2);
Waveform.Adpcm2toPcm16(adpcm2, pcm16, ref last, ref penult);
}
break;
}
}
}
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);
}
void DoReplaceSeq()
{
if (mAafInPath == null)
{
mareep.WriteError("CHARGE: missing -init-data-file parameter");
}
if (mArcInPath == null)
{
mareep.WriteError("CHARGE: missing -seq-data-file parameter");
}
byte[] arc_data = ReadFileData(mArcInPath);
if (mInput == null)
{
mareep.WriteError("CHARGE: missing -input parameter");
}
byte[] seq_data = ReadFileData(mInput);
if (mTarget == null)
{
mareep.WriteError("CHARGE: missing -target parameter");
}
byte[] barc_data = null;
using (Stream input = mareep.OpenFile(mAafInPath)) {
mareep.WriteMessage("Scanning AAF header...\n");
aBinaryReader reader = new aBinaryReader(input, Endianness.Big);
int offset, size;
if (!ReadAafHeader(reader, 4, 0, out offset, out size))
{
mareep.WriteError("CHARGE: failed to find sequence info block");
}
reader.Goto(offset);
if (reader.ReadS32() != 0x42415243) // 'BARC'
{
mareep.WriteError("CHARGE: could not find 'BARC' header");
}
reader.Goto(offset + 12);
int count = reader.ReadS32();
barc_data = new byte[32 + 32 * count];
reader.Goto(offset + 32);
int index, old_offset, old_size;
mareep.WriteMessage("Found sequence info data (0x{0:X6}, 0x{1:X6}), {2} sequence(s)\n", offset, size, count);
mareep.WriteMessage("Scanning sequence list...\n");
if (!ReadBarcHeader(reader, mTarget, count, out index, out old_offset, out old_size))
{
mareep.WriteError("CHARGE: could not find sequence {0}", mTarget);
}
mareep.WriteMessage("Found sequence {0} (0x{1:X6}, 0x{2:X6})\n", index, offset, size);
int new_offset, new_size = ((seq_data.Length + 31) & ~31);
int difference = (new_size - old_size);
reader.Goto(offset + 16);
using (Stream arc_stream = mareep.CreateFile(mArcOutPath))
using (MemoryStream barc_stream = new MemoryStream(barc_data, true)) {
mareep.WriteMessage("Writing new sequence data...\n");
aBinaryWriter arc_writer = new aBinaryWriter(arc_stream);
aBinaryWriter barc_writer = new aBinaryWriter(barc_stream, Endianness.Big);
barc_writer.WriteS32(0x42415243); // 'BARC'
barc_writer.WriteS32(0x2D2D2D2D); // '----'
barc_writer.WriteS32(0);
barc_writer.WriteS32(count);
barc_writer.Write8s(reader.Read8s(16));
for (int i = 0; i < count; ++i)
{
barc_writer.Write8s(reader.Read8s(14));
barc_writer.WriteS16(reader.ReadS16());
barc_writer.WriteS32(reader.ReadS32());
barc_writer.WriteS32(reader.ReadS32());
offset = reader.ReadS32();
size = reader.ReadS32();
new_offset = offset;
if (offset > old_offset)
{
new_offset += difference;
}
arc_writer.Goto(new_offset);
if (i == index)
{
arc_writer.Write8s(seq_data);
arc_writer.WritePadding(32, 0);
size = new_size;
}
else
{
arc_writer.Write8s(arc_data, offset, size);
}
barc_writer.WriteS32(new_offset);
barc_writer.WriteS32(size);
}
}
reader.Goto(0);
using (Stream output = mareep.CreateFile(mAafOutPath)) {
mareep.WriteMessage("Writing new AAF file...\n");
aBinaryWriter writer = new aBinaryWriter(output, Endianness.Big);
if (!WriteAafHeader(reader, writer, 4, 0, barc_data))
{
mareep.WriteError("CHARGE: failed to write aaf file");
}
}
}
}
void DoExtractSeq()
{
if (mAafInPath == null)
{
mareep.WriteError("CHARGE: missing -init-data-file parameter");
}
if (mArcInPath == null)
{
mareep.WriteError("CHARGE: missing -seq-data-file parameter");
}
if (mOutput == null)
{
mareep.WriteError("CHARGE: missing -output parameter");
}
if (mTarget == null)
{
mareep.WriteError("CHARGE: missing -target parameter");
}
int offset, size;
using (Stream stream = mareep.OpenFile(mAafInPath)) {
mareep.WriteMessage("Scanning AAF header...\n");
aBinaryReader reader = new aBinaryReader(stream, Endianness.Big);
if (!ReadAafHeader(reader, 4, 0, out offset, out size))
{
mareep.WriteError("CHARGE: failed to find sequence info data");
}
reader.Goto(offset);
if (reader.ReadS32() != 0x42415243) // 'BARC'
{
mareep.WriteError("CHARGE: could not find 'BARC' header");
}
reader.Goto(offset + 12);
int count = reader.ReadS32();
reader.Goto(offset + 32);
int index;
mareep.WriteMessage("Found sequence info data (0x{0:X6}, 0x{1:X6}), {2} sequence(s)\n", offset, size, count);
mareep.WriteMessage("Scanning sequence list...\n");
if (!ReadBarcHeader(reader, mTarget, count, out index, out offset, out size))
{
mareep.WriteError("CHARGE: could not find sequence {0}", mTarget);
}
mareep.WriteMessage("Found sequence {0} (0x{1:X6}, 0x{2:X6})\n", index, offset, size);
}
mareep.WriteMessage("Extracting sequence data...\n");
using (Stream stream = mareep.OpenFile(mArcInPath)) {
aBinaryReader reader = new aBinaryReader(stream);
reader.Goto(offset);
WriteFileData(mOutput, reader.Read8s(size));
}
}
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);
}
