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'); } }
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); }