void ExtractWav(Wave wave, byte[] data, Stream stream)
{
var writer = new aBinaryWriter(stream, Endianness.Little);
var mixer = new RawWaveMixer(new MemoryStream(data), wave.Format);
var dataSize = (wave.SampleCount * 2);
var sampleRate = (int)wave.SampleRate;
var numLoops = wave.Loop ? 1 : 0;
writer.WriteString("RIFF");
writer.WriteS32(36 + dataSize + ((wave.Loop || wave.RootKey != 60) ? (36 + (numLoops * 24)) : 0));
writer.WriteString("WAVE");
writer.WriteString("fmt ");
writer.WriteS32(16);
writer.WriteS16(1); // format
writer.Write16(1); // channel count
writer.WriteS32(sampleRate);
writer.WriteS32(sampleRate * 2); // byte rate
writer.Write16(2); // block align
writer.Write16(16); // bit depth
if (wave.Loop || wave.RootKey != 60)
{
writer.WriteString("smpl");
writer.WriteS32(36 + (numLoops * 24));
writer.WriteS32(0); // manufacturer
writer.WriteS32(0); // product
writer.WriteS32(1000000000 / sampleRate); // sample period
writer.WriteS32(wave.RootKey); // unity note
writer.WriteS32(0); // pitch fraction
writer.WriteS32(0); // SMPTE format
writer.WriteS32(0); // SMPTE offset
writer.WriteS32(numLoops);
writer.WriteS32(0); // sampler data
if (wave.Loop)
{
writer.WriteS32(0); // cue point ID
writer.WriteS32(0); // type
writer.WriteS32(wave.LoopStart);
writer.WriteS32(wave.LoopEnd - 1);
writer.WriteS32(0); // fraction
writer.WriteS32(0); // play count
}
}
writer.WriteString("data");
writer.WriteS32(dataSize);
mixer.Write(WaveFormat.Pcm16, writer);
}
void WriteWaveGroup(WaveGroup waveGroup)
{
var offset = ((int)mWriter.Position + CalculateArchiveInfoSize(waveGroup.Count));
if (waveGroup.ArchiveFileName.Length > 111)
{
mareep.WriteWarning("WSYS: wave archive name '{0}' is too long.\n", waveGroup.ArchiveFileName);
}
mWriter.WriteString <aCSTR>(waveGroup.ArchiveFileName, 112);
mWriter.WriteS32(waveGroup.Count);
for (var i = 0; i < waveGroup.Count; ++i)
{
mWriter.WriteS32(offset + 48 * i + 4);
}
mWriter.WritePadding(32, 0);
foreach (var wave in waveGroup)
{
WriteWave(wave);
}
mWriter.WritePadding(32, 0);
var sceneOffset = (int)mWriter.Position;
mWriter.Write32(C_DF);
mWriter.WriteS32(waveGroup.Count);
for (var i = 0; i < waveGroup.Count; ++i)
{
mWriter.WriteS32(offset + 48 * i);
}
mWriter.WritePadding(32, 0);
// these two sections are unused
mWriter.Write32(C_EX);
mWriter.WritePadding(32, 0);
mWriter.Write32(C_ST);
mWriter.WritePadding(32, 0);
mWriter.Write32(SCNE);
mWriter.WriteS32(0); // unused
mWriter.WriteS32(0); // unused
mWriter.WriteS32(sceneOffset);
mWriter.WriteS32(sceneOffset + 32);
mWriter.WriteS32(sceneOffset + 64);
mWriter.WritePadding(32, 0);
}
void PerformRawToWav(Stream instream, Stream outstream)
{
var mixer = new RawWaveMixer(instream, mRawInputFormat);
var writer = new aBinaryWriter(outstream, Endianness.Little);
var dataSize = (mixer.SampleCount * 2);
writer.WriteString("RIFF");
writer.WriteS32(36 + dataSize);
writer.WriteString("WAVE");
writer.WriteString("fmt ");
writer.WriteS32(16);
writer.WriteS16(1); // format
writer.Write16(1); // channel count
writer.WriteS32(mRawSampleRate);
writer.WriteS32(mRawSampleRate * 2); // byte rate
writer.Write16(2); // block align
writer.Write16(16); // bit depth
writer.WriteString("data");
writer.WriteS32(dataSize);
mixer.Write(WaveFormat.Pcm16, writer);
}
void ExtractWav(Wave wave, byte[] data, Stream stream)
{
var writer = new aBinaryWriter(stream, Endianness.Little);
var mixer = new RawWaveMixer(new MemoryStream(data), wave.Format);
var dataSize = (wave.SampleCount * 2);
var sampleRate = (int)wave.SampleRate;
writer.WriteString("RIFF");
writer.WriteS32(36 + dataSize);
writer.WriteString("WAVE");
writer.WriteString("fmt ");
writer.WriteS32(16);
writer.WriteS16(1); // format
writer.Write16(1); // channel count
writer.WriteS32(sampleRate);
writer.WriteS32(sampleRate * 2); // byte rate
writer.Write16(2); // block align
writer.Write16(16); // bit depth
writer.WriteString("data");
writer.WriteS32(dataSize);
mixer.Write(WaveFormat.Pcm16, writer);
}
void PerformStreamToWav(Stream instream, Stream outstream)
{
var reader = new aBinaryReader(instream, Endianness.Big);
var writer = new aBinaryWriter(outstream, Endianness.Little);
var streamDataSize = reader.ReadS32();
var sampleCount = reader.ReadS32();
var sampleRate = reader.Read16();
var dataSize = (sampleCount * 4);
var format = (StreamFormat)reader.Read16();
writer.WriteString("RIFF");
writer.WriteS32(36 + dataSize);
writer.WriteString("WAVE");
writer.WriteString("fmt ");
writer.WriteS32(16);
writer.WriteS16(1); // format
writer.Write16(2); // channel count
writer.WriteS32(sampleRate);
writer.WriteS32(sampleRate * 4); // byte rate
writer.Write16(4); // block align
writer.Write16(16); // bit depth
writer.WriteString("data");
writer.WriteS32(dataSize);
reader.Goto(32);
switch (format)
{
case StreamFormat.Pcm: DecodeStreamPcm(reader, writer, sampleCount); break;
case StreamFormat.Adpcm: DecodeStreamAdpcm(reader, writer, sampleCount); break;
default: mareep.WriteError("AFC: Unknown format '{0}' in header.", (int)format); break;
}
}
void WriteWaveBank()
{
mWriter.PushAnchor();
mWriter.WriteString("RIFF");
mWriter.WriteS32(CalculateInfoSize() + 8 + CalculateSmplSize() + 20 + CalculatePdtaSize() + 8 + 4);
mWriter.WriteString("sfbk");
WriteInfo();
WriteSdta();
WritePdta();
mWriter.PopAnchor();
}
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();
}
public override void Write(aBinaryWriter writer, string value)
{
aError.Check<ArgumentException>(value.Length <= Byte.MaxValue, "String value is too long for a BSTR.", "value");
writer.Write8((byte)value.Length);
writer.WriteString(value);
}
public override void Write(aBinaryWriter writer, string value)
{
writer.WriteString(value);
writer.WriteChar('\0');
}
public override void Write(aBinaryWriter writer, string value)
{
aError.Check<ArgumentException>(value.Length <= UInt16.MaxValue, "String value is too long for a WSTR.", "value");
writer.Write16((ushort)value.Length);
writer.WriteString(value);
}
public override void Write(aBinaryWriter writer, string value)
{
if (value.Length > mMultiple) {
value = value.Substring(0, mMultiple);
}
writer.WriteString(value);
var count = mMultiple - value.Length;
while (count-- > 0) {
writer.WriteChar('\0');
}
}
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();
}
public void ToStream(aBinaryWriter writer)
{
writer.WriteS32(Start);
writer.WriteS32(Length);
writer.WriteString<aCSTR>(Name, 8);
}
public void ToStream(aBinaryWriter writer)
{
writer.WriteS32(Start);
writer.WriteS32(Length);
writer.WriteString <aCSTR>(Name, 8);
}
public void save(aBinaryWriter writer)
{
if (writer == null)
{
throw new ArgumentNullException("writer");
}
// calculate entry shit
var entryOffset = calculateEntryOffset(FieldCount);
var entrySize = calculateEntrySize(mFields);
// write header
writer.WriteS32(EntryCount);
writer.WriteS32(FieldCount);
writer.Write32(entryOffset);
writer.WriteS32(entrySize);
// write field LUT
foreach (var field in mFields)
{
writer.Write32(field.hash);
writer.Write32(field.bitmask);
writer.Write16(field.start);
writer.Write8(field.shift);
writer.Write8((byte)field.type);
}
// since the stream is write-only, we must write packed integer fields to an intermediate, R/W buffer
var buffer = new Dictionary <ushort, uint>(FieldCount);
for (var entry = 0; entry < EntryCount; ++entry)
{
buffer.Clear();
for (var field = 0; field < FieldCount; ++field)
{
writer.Goto(entryOffset + (entrySize * entry) + mFields[field].start);
switch (mFields[field].type)
{
case jmpValueType.INTEGER: {
if (mFields[field].bitmask == 0xFFFFFFFFu)
{
// field is unpacked; write directly to stream
writer.WriteS32(mEntries[entry, field]);
}
else
{
// field is packed; write to intermediate buffer
if (!buffer.ContainsKey(mFields[field].start))
{
buffer[mFields[field].start] = 0u; // if there's no key yet, create one
}
buffer[mFields[field].start] |= ((uint)mEntries[entry, field] << mFields[field].shift) & mFields[field].bitmask;
}
break;
}
case jmpValueType.FLOAT: {
writer.WriteF32(mEntries[entry, field]);
break;
}
case jmpValueType.STRING: {
writer.WriteString <aCSTR>(mEntries[entry, field], 0x20);
break;
}
}
}
// flush intermediate buffer
foreach (var point in buffer)
{
writer.Goto(entryOffset + (entrySize * entry) + point.Key);
writer.Write32(point.Value);
}
}
}
public void save(aBinaryWriter writer)
{
writer.Write8((byte)mResourceType);
writer.Write8((byte)mResourcePath.Length);
writer.WriteString(mResourcePath);
}
