public override void LoadParams(string[] arguments)
{
base.LoadParams(arguments);
var cmdline = new aCommandLine(arguments);
aCommandLineParameter parameter;
parameter = mareep.GetLastCmdParam(cmdline, "-wave-dir");
if (parameter == null)
{
mWavePath = "waves/";
}
else if (parameter.Count == 0)
{
mareep.WriteError("WHAP: missing argument for -wave-dir parameter.");
}
else
{
mWavePath = parameter[0];
}
parameter = mareep.GetLastCmdParam(cmdline, "-bank-dir");
if (parameter == null)
{
mBankPath = "banks/";
}
else if (parameter.Count == 0)
{
mareep.WriteError("WHAP: missing argument for -bank-dir parameter.");
}
else
{
mBankPath = parameter[0];
}
parameter = mareep.GetLastCmdParam(cmdline, "-mix-mode");
if (parameter == null)
{
mMixerMode = WaveMixerMode.Mix;
}
else if (parameter.Count == 0)
{
mareep.WriteError("WHAP: missing argument for -mix-mode parameter.");
}
else if (!Enum.TryParse(parameter[0], true, out mMixerMode))
{
mareep.WriteError("WHAP: unknown mix mode '{0}'.", parameter[0]);
}
mExtractWav = (mareep.GetLastCmdParam(cmdline, "-extract-wav") != null);
}
public CorrupterOptions(aCommandLine cmd)
: this()
{
foreach (var param in cmd)
{
switch (param.Name.ToLowerInvariant())
{
case "-start": LoadStart(param); continue;
case "-end": LoadEnd(param); continue;
case "-inc": LoadInc(param); continue;
case "-mode": LoadMode(param); continue;
case "-skip": LoadSkip(param); continue;
case "-only": LoadOnly(param); continue;
case "-zdoom": LoadZDOOM(param); continue;
}
DOOMWADCorrupter.Warning("Skipping unknown option '{0}'...", param.Name);
}
}
public void LoadParams(string[] arguments)
{
var cmdline = new aCommandLine(arguments);
aCommandLineParameter parameter;
// input
parameter = mareep.GetLastCmdParam(cmdline, "-input");
if (parameter == null)
{
mareep.WriteError("WAVE: missing -input parameter.");
}
else if (parameter.Count == 0)
{
mareep.WriteError("WAVE: missing argument for -input parameter.");
}
mInput = parameter[0];
mInputFormat = GetFormat(Path.GetExtension(mInput));
if (mInputFormat == IOFormat.Raw)
{
if (parameter.Count < 2)
{
mareep.WriteError("WAVE: missing format for raw input.");
}
if (!Enum.TryParse(parameter[1], true, out mRawInputFormat))
{
mareep.WriteError("WAVE: bad format '{0}' for raw input.", parameter[1]);
}
}
// output
parameter = mareep.GetLastCmdParam(cmdline, "-output");
if (parameter == null)
{
mareep.WriteError("WAVE: missing -output parameter.");
}
else if (parameter.Count == 0)
{
mareep.WriteError("WAVE: missing argument for -output parameter.");
}
mOutput = parameter[0];
mOutputFormat = GetFormat(Path.GetExtension(mOutput));
if (mOutputFormat == IOFormat.Raw)
{
if (parameter.Count < 2)
{
mareep.WriteError("WAVE: missing format for raw output.");
}
if (!Enum.TryParse(parameter[1], true, out mRawOutputFormat))
{
mareep.WriteError("WAVE: bad format '{0}' for raw output.", parameter[1]);
}
}
else if (mOutputFormat == IOFormat.AfcStream)
{
if (parameter.Count < 2)
{
mStreamFormat = StreamFormat.Adpcm;
}
else if (!Enum.TryParse(parameter[1], true, out mStreamFormat))
{
mareep.WriteError("WAVE: bad stream format '{0}'.", parameter[1]);
}
}
// mode
if (mInputFormat == IOFormat.Raw && mOutputFormat == IOFormat.Raw)
{
mMode = Mode.RawToRaw;
}
else if (mInputFormat == IOFormat.Raw && mOutputFormat == IOFormat.MicrosoftWave)
{
mMode = Mode.RawToWav;
}
else if (mInputFormat == IOFormat.MicrosoftWave && mOutputFormat == IOFormat.Raw)
{
mMode = Mode.WavToRaw;
}
else if (mInputFormat == IOFormat.MicrosoftWave && mOutputFormat == IOFormat.AfcStream)
{
mMode = Mode.WavToStream;
}
else if (mInputFormat == IOFormat.AfcStream && mOutputFormat == IOFormat.MicrosoftWave)
{
mMode = Mode.StreamToWav;
}
else
{
mareep.WriteError("WAVE: unsupported combination of input and output formats.");
}
// mix mode
parameter = mareep.GetLastCmdParam(cmdline, "-mix-mode");
if (parameter != null)
{
if (parameter.Count < 1)
{
mareep.WriteError("WAVE: bad -mix-mode parameter.");
}
if (!Enum.TryParse(parameter[0], true, out mMixerMode))
{
mareep.WriteError("WAVE: bad mixer mode '{0}' in -mix-mode parameter.", parameter[0]);
}
}
// sample rate
parameter = mareep.GetLastCmdParam(cmdline, "-sample-rate");
if (parameter != null)
{
if (parameter.Count < 1)
{
mareep.WriteError("WAVE: missing argument for -sample-rate parameter.");
}
if (!Int32.TryParse(parameter[0], out mRawSampleRate) || mRawSampleRate < 0)
{
mareep.WriteError("WAVE: bad sample rate '{0}'.", parameter[0]);
}
}
else if (mInputFormat == IOFormat.Raw && mOutputFormat != IOFormat.Raw)
{
mareep.WriteError("WAVE: missing -sample-rate parameter for raw input.");
}
// frame rate
parameter = mareep.GetLastCmdParam(cmdline, "-frame-rate");
if (parameter != null)
{
if (parameter.Count < 1)
{
mareep.WriteError("WAVE: missing argument for -frame-rate parameter.");
}
if (!Int32.TryParse(parameter[0], out mStreamFrameRate) || mStreamFrameRate < 0)
{
mareep.WriteError("WAVE: bad frame rate '{0}'.", parameter[0]);
}
}
else
{
mStreamFrameRate = 30;
}
// loop
parameter = mareep.GetLastCmdParam(cmdline, "-loop");
if (parameter != null)
{
mStreamLoop = true;
if (parameter.Count < 1)
{
mareep.WriteError("WAVE: missing argument for -loop parameter.");
}
if (!Int32.TryParse(parameter[0], out mStreamLoopStart) || mStreamLoopStart < 0)
{
mareep.WriteError("WAVE: bad loop value '{0}'.", parameter[0]);
}
}
}
public void LoadParams(string[] arguments)
{
var cmdline = new aCommandLine(arguments);
aCommandLineParameter parameter;
parameter = mareep.GetLastCmdParam(cmdline, "-input");
if (parameter == null)
{
mareep.WriteError("JOLT: missing -input parameter.");
}
else if (parameter.Count == 0)
{
mareep.WriteError("JOLT: missing argument for -input parameter.");
}
mInput = parameter[0];
parameter = mareep.GetLastCmdParam(cmdline, "-output");
if (parameter == null)
{
mareep.WriteError("JOLT: missing -output parameter.");
}
else if (parameter.Count == 0)
{
mareep.WriteError("JOLT: missing argument for -output parameter.");
}
mOutput = parameter[0];
parameter = mareep.GetLastCmdParam(cmdline, "-loop");
if (parameter != null)
{
mLoop = 0;
mLoopTimeUnit = LoopTimeUnit.Pulses;
if (parameter.Count >= 1)
{
if (!Int64.TryParse(parameter[0], NumberStyles.None, null, out mLoop))
{
mareep.WriteError("JOLT: bad loop value '{0}'.", parameter[0]);
}
}
if (parameter.Count >= 2)
{
switch (parameter[1].ToLowerInvariant())
{
case "pulses":
case "ticks": {
mLoopTimeUnit = LoopTimeUnit.Pulses;
break;
}
case "beats":
case "quarters": {
mLoopTimeUnit = LoopTimeUnit.Beats;
break;
}
case "bars":
case "measures": {
mLoopTimeUnit = LoopTimeUnit.Measures;
break;
}
default: {
mareep.WriteError("JOLT: bad time unit '{0}'.", parameter[1]);
break;
}
}
}
}
}
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 LoadParams(string[] arguments)
{
var cmdline = new aCommandLine(arguments);
foreach (var parameter in cmdline)
{
switch (parameter.Name)
{
case "-extract-seq": mAction = DoExtractSeq; break;
case "-replace-seq": mAction = DoReplaceSeq; break;
case "-extract-ibnk": mAction = DoExtractIbnk; break;
case "-replace-ibnk": mAction = DoReplaceIbnk; break;
case "-extract-wsys": mAction = DoExtractWsys; break;
case "-replace-wsys": mAction = DoReplaceWsys; break;
case "-init-data-file": {
if (parameter.Count == 0)
{
mareep.WriteError("CHARGE: bad -init-data-file parameter");
}
mAafInPath = parameter[0];
if (parameter.Count > 1)
{
mAafOutPath = parameter[1];
}
else
{
mAafOutPath = Path.ChangeExtension(mAafInPath, ".new.aaf");
}
break;
}
case "-seq-data-file": {
if (parameter.Count == 0)
{
mareep.WriteError("CHARGE: bad -seq-data-file parameter");
}
mArcInPath = parameter[0];
if (parameter.Count > 1)
{
mArcOutPath = parameter[1];
}
else
{
mArcOutPath = Path.ChangeExtension(mArcInPath, ".new.arc");
}
break;
}
case "-target": mTarget = parameter[0]; break;
case "-input": mInput = parameter[0]; break;
case "-output": mOutput = parameter[0]; break;
}
}
}
