static void convertJmp(jmp jmp, string path, IoFormat format) { using (var file = File.Create(path)) { switch (format) { case IoFormat.JMP: { var writer = new aBinaryWriter(file, Endianness.Big, Encoding.GetEncoding(932)); jmp.save(writer); break; } case IoFormat.XML: { var settings = new XmlWriterSettings() { OmitXmlDeclaration = true, Encoding = Encoding.UTF8, NewLineChars = "\n", IndentChars = "\t", Indent = true, }; var writer = XmlWriter.Create(file, settings); jmp.save(writer); writer.Close(); break; } } } }
internal override void saveCompact(aBinaryWriter writer) { base.saveCompact(writer); if (mTextureCount > 0) { bloResource.save(mTextures[0], writer); } else { bloResource.save(null, writer); } bloResource.save(mPalette, writer); writer.Write8((byte)mBinding); byte bits = 0; bits |= (byte)mWrapS; bits <<= 1; bits |= (byte)(mRotate90 ? 1 : 0); bits <<= 2; bits |= (byte)mMirror; writer.Write8(bits); writer.WritePadding(4, 0); for (int i = 0; i < 4; ++i) { writer.Write32(mColors[i].rgba); } }
static void saveCompact(bloPane pane, aBinaryWriter writer) { var typeID = cPaneID; if (pane is bloTextbox) { typeID = cTextboxID; } else if (pane is bloWindow) { typeID = cWindowID; } else if (pane is bloPicture) { typeID = cPictureID; } writer.Write16(typeID); pane.saveCompact(writer); if (pane.getChildPane() > 0) { writer.Write16(cBeginID); foreach (var childpane in pane) { saveCompact(childpane, writer); } writer.Write16(cEndID); } }
void PerformWavToStream(Stream instream, Stream outstream) { var mixer = new MicrosoftWaveMixer(instream); var writer = new aBinaryWriter(outstream, Endianness.Big); var dataSize = 0; switch (mStreamFormat) { case StreamFormat.Pcm: dataSize = (mixer.SampleCount * 4); break; case StreamFormat.Adpcm: dataSize = (mareep.RoundUp16B(mixer.SampleCount) / 16 * 18); break; } writer.WriteS32(dataSize); writer.WriteS32(mixer.SampleCount); writer.Write16((ushort)mixer.SampleRate); writer.Write16((ushort)mStreamFormat); writer.Write16(0); // unused writer.Write16((ushort)mStreamFrameRate); writer.WriteS32(mStreamLoop ? 1 : 0); // loop flag writer.WriteS32(mStreamLoop ? mStreamLoopStart : 0); // loop start writer.WritePadding(32, 0); switch (mStreamFormat) { case StreamFormat.Pcm: EncodeStreamPcm(mixer, writer); break; case StreamFormat.Adpcm: EncodeStreamAdpcm(mixer, writer); break; } writer.WritePadding(32, 0); }
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 PerformRawToRaw(Stream instream, Stream outstream) { var mixer = new RawWaveMixer(instream, mRawInputFormat); var writer = new aBinaryWriter(outstream, Endianness.Big); mixer.Write(mRawOutputFormat, writer); }
public void Copy(aBinaryWriter writer) { if (writer == null) { throw new ArgumentNullException("writer"); } writer.Write8s(mStream.GetBuffer(), (int)Size); }
protected override void WritePcm16(aBinaryWriter writer) { for (var i = 0; i < mSampleCount; ++i) { GotoSample(i); writer.WriteS16(MixPcm16()); } }
void PerformWavToRaw(Stream instream, Stream outstream) { var mixer = new MicrosoftWaveMixer(instream); var writer = new aBinaryWriter(outstream, Endianness.Big); mixer.MixerMode = mMixerMode; mixer.Write(mRawOutputFormat, writer); }
public sunSpcBinary(Stream output) { mWriter = new aBinaryWriter(output, Endianness.Big, Encoding.GetEncoding(932)); mText = new sunSpcBinarySection(); mData = new sunSpcBinarySection(); mDataString = new sunSpcBinarySection(); mSymbol = new sunSpcBinarySection(); mSymbolString = new sunSpcBinarySection(); mWriter.PushAnchor(); }
protected override void WritePcm8(aBinaryWriter writer) { mReader.Goto(0); switch (mFormat) { case WaveFormat.Pcm8: { writer.WriteS8s(mReader.ReadS8s(mSampleCount)); break; } case WaveFormat.Pcm16: { for (var i = 0; i < mSampleCount; ++i) { sbyte pcm8; Waveform.Pcm16toPcm8(mReader.ReadS16(), out pcm8); writer.WriteS8(pcm8); } break; } case WaveFormat.Adpcm2: { var pcm8 = new sbyte[16]; var pcm16 = new short[16]; int last = 0, penult = 0; for (var i = 0; i < mSampleCount; i += 16) { Waveform.Adpcm2toPcm16(mReader.Read8s(5), pcm16, ref last, ref penult); for (var j = 0; j < 16; ++j) { Waveform.Pcm16toPcm8(pcm16[j], out pcm8[j]); } writer.WriteS8s(pcm8, System.Math.Min(16, (mSampleCount - i))); } break; } case WaveFormat.Adpcm4: { var pcm8 = new sbyte[16]; var pcm16 = new short[16]; int last = 0, penult = 0; for (var i = 0; i < mSampleCount; i += 16) { Waveform.Adpcm4toPcm16(mReader.Read8s(9), pcm16, ref last, ref penult); for (var j = 0; j < 16; ++j) { Waveform.Pcm16toPcm8(pcm16[j], out pcm8[j]); } writer.WriteS8s(pcm8, System.Math.Min(16, (mSampleCount - i))); } break; } } }
public void saveCompact(Stream stream) { aBinaryWriter writer = new aBinaryWriter(stream, Endianness.Big, Encoding.GetEncoding(1252)); foreach (var childpane in this) { saveCompact(childpane, writer); } writer.Write16(cExitID); }
public static void save(bloResource resource, aBinaryWriter writer) { if (resource != null) { resource.save(writer); } else { writer.Write8(0); writer.Write8(0); } }
static void DecodeStreamPcm(aBinaryReader reader, aBinaryWriter writer, int sampleCount) { for (var i = 0; i < sampleCount; ++i) { writer.WriteS16(reader.ReadS16()); writer.WriteS16(reader.ReadS16()); if ((i % cMessageInterval) == 0 || i >= sampleCount) { mareep.WriteMessage("\rSamples decoded: {0}/{1}", System.Math.Min((i + 1), sampleCount), sampleCount); } } }
static void saveBlo1(bloPane pane, aBinaryWriter writer, ref uint blockcount) { var typeID = cPAN1; if (pane is bloTextbox) { typeID = cTBX1; } else if (pane is bloWindow) { typeID = cWIN1; } else if (pane is bloPicture) { typeID = cPIC1; } var blockstart = writer.Position; writer.Write32(typeID); writer.Write32(0u); // dummy size pane.saveBlo1(writer); writer.WritePadding(4, 0); var blockend = writer.Position; writer.Goto(blockstart + 4); writer.Write32((uint)(blockend - blockstart)); writer.Goto(blockend); ++blockcount; if (pane.getChildPane() > 0) { writer.Write32(cBGN1); writer.Write32(0x8u); ++blockcount; foreach (var childpane in pane) { saveBlo1(childpane, writer, ref blockcount); } writer.Write32(cEND1); writer.Write32(0x8u); ++blockcount; } }
internal virtual void saveCompact(aBinaryWriter writer) { if (writer == null) { throw new ArgumentNullException("writer"); } writer.Write8((byte)(mVisible ? 1 : 0)); writer.Write8(0); // padding writer.Write32(mName); writer.WriteS16((short)mRect.left); writer.WriteS16((short)mRect.top); writer.WriteS16((short)mRect.width); writer.WriteS16((short)mRect.height); }
static void EncodeStreamPcm(MicrosoftWaveMixer mixer, aBinaryWriter writer) { short left, right; for (var i = 0; i < mixer.SampleCount; ++i) { mixer.ReadPcm16(i, out left, out right); writer.WriteS16(left); writer.WriteS16(right); if ((i % cMessageInterval) == 0 || i >= mixer.SampleCount) { mareep.WriteMessage("\rSamples encoded: {0}/{1}", System.Math.Min((i + 1), mixer.SampleCount), mixer.SampleCount); } } }
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); }
public static void Write24(this aBinaryWriter writer, int value) { var byte1 = (byte)((value >> 16) & 0xFF); var byte2 = (byte)((value >> 8) & 0xFF); var byte3 = (byte)(value & 0xFF); if (writer.Endianness == Endianness.Big) { writer.Write8(byte1); writer.Write8(byte2); writer.Write8(byte3); } else { writer.Write8(byte3); writer.Write8(byte2); writer.Write8(byte1); } }
internal override void saveCompact(aBinaryWriter writer) { base.saveCompact(writer); bloResource.save(mFont, writer); writer.Write32(mTopColor.rgba); writer.Write32(mBottomColor.rgba); byte binding = 0; if (mFont != null) { binding |= 1; binding <<= 2; } binding |= (byte)mHBinding; binding <<= 2; binding |= (byte)mVBinding; writer.Write8(binding); if (mFont != null) { writer.WriteS16((short)mFontSpacing); writer.WriteS16((short)mFontLeading); writer.Write16((ushort)mFontWidth); writer.Write16((ushort)mFontHeight); } if (mFont != null) { var strbuffer = mFont.decodeToBytes(mText); writer.Write16((ushort)strbuffer.Length); writer.Write8s(strbuffer); } else { writer.Write16(0); } writer.WritePadding(4, 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); }
protected override void WriteAdpcm4(aBinaryWriter writer) { var adpcm4 = new byte[9]; var pcm16 = new short[16]; int last = 0, penult = 0; for (var i = 0; i < mSampleCount; i += 16) { for (var j = 0; j < 16; ++j) { pcm16[j] = 0; if (i + j < mSampleCount) { ReadPcm16((i + j), out pcm16[j]); } } Waveform.Pcm16toAdpcm4(pcm16, adpcm4, ref last, ref penult); writer.Write8s(adpcm4); } }
void DoReplaceWsys() { if (mAafInPath == null) { mareep.WriteError("CHARGE: missing -init-data-file parameter"); } if (mInput == null) { mareep.WriteError("CHARGE: missing -input parameter"); } mareep.WriteMessage("Loading input file data...\n"); byte[] data = ReadFileData(mInput); 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 input = mareep.OpenFile(mAafInPath)) using (Stream output = mareep.CreateFile(mAafOutPath)) { mareep.WriteMessage("Writing new AAF file...\n"); aBinaryReader reader = new aBinaryReader(input, Endianness.Big); aBinaryWriter writer = new aBinaryWriter(output, Endianness.Big); if (!WriteAafHeader(reader, writer, 3, index, data)) { mareep.WriteError("CHARGE: failed to write aaf file"); } } }
static void EncodeStreamAdpcm(MicrosoftWaveMixer mixer, aBinaryWriter writer) { var left_adpcm4 = new byte[9]; int left_last = 0, left_penult = 0; var right_adpcm4 = new byte[9]; int right_last = 0, right_penult = 0; var left = new short[16]; var right = new short[16]; for (var i = 0; i < mixer.SampleCount; i += 16) { for (var j = 0; j < 16; ++j) { if ((i + j) < mixer.SampleCount) { mixer.ReadPcm16((i + j), out left[j], out right[j]); } else { left[j] = 0; right[j] = 0; } } Waveform.Pcm16toAdpcm4(left, left_adpcm4, ref left_last, ref left_penult); Waveform.Pcm16toAdpcm4(right, right_adpcm4, ref right_last, ref right_penult); writer.Write8s(left_adpcm4); writer.Write8s(right_adpcm4); if ((i % cMessageInterval) == 0 || (i + 16) >= mixer.SampleCount) { mareep.WriteMessage("\rSamples encoded: {0}/{1}", System.Math.Min((i + 16), mixer.SampleCount), mixer.SampleCount); } } }
public void saveBlo1(Stream stream) { aBinaryWriter writer = new aBinaryWriter(stream, Endianness.Big, Encoding.GetEncoding(1252)); var blockstart = writer.Position; var blockcount = 0u; writer.Write32(cSCRN); writer.Write32(cBLO1); writer.Write32(0u); // dummy size writer.Write32(0u); // dummy block count writer.WritePadding(32, 0); writer.Write32(cINF1); writer.Write32(0x10u); writer.WriteS16((short)mRect.width); writer.WriteS16((short)mRect.height); writer.Write32(mTintColor.rgba); ++blockcount; foreach (var childpane in this) { saveBlo1(childpane, writer, ref blockcount); } writer.Write32(cEXT1); writer.Write32(0x8u); ++blockcount; writer.WritePadding(32, 0); var blockend = writer.Position; writer.Goto(blockstart + 8); writer.Write32((uint)(blockend - blockstart)); writer.Write32(blockcount); writer.Goto(blockend); }
public void Write(WaveFormat format, aBinaryWriter writer) { if (!format.IsDefined()) { throw new ArgumentOutOfRangeException("format"); } if (writer == null) { throw new ArgumentNullException("writer"); } switch (format) { case WaveFormat.Pcm8: WritePcm8(writer); break; case WaveFormat.Pcm16: WritePcm16(writer); break; case WaveFormat.Adpcm2: WriteAdpcm2(writer); break; case WaveFormat.Adpcm4: WriteAdpcm4(writer); break; } }
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; } }
protected override WaveBank DoTransform(WaveBank obj) { if (obj == null) { return(null); } var badwaves = 0; if (!Directory.Exists(mBankDirectory)) { mareep.WriteMessage("Creating directory '{0}'...\n", mBankDirectory); Directory.CreateDirectory(mBankDirectory); } mareep.WriteMessage("Transferring waves...\n"); foreach (var waveGroup in obj) { var archiveFileName = Path.Combine(mBankDirectory, waveGroup.ArchiveFileName); mareep.WriteSeparator('-'); mareep.WriteMessage("{0}\n", waveGroup.ArchiveFileName); using (var outstream = mareep.CreateFile(archiveFileName)) { var writer = new aBinaryWriter(outstream, Endianness.Big); foreach (var wave in waveGroup) { var waveFileName = Path.Combine(mWaveDirectory, wave.FileName); var extension = Path.GetExtension(waveFileName).ToLowerInvariant(); if (!File.Exists(waveFileName)) { mareep.WriteWarning("XFER: cannot find file '{0}'\n", wave.FileName); ++badwaves; continue; } using (var instream = mareep.OpenFile(waveFileName)) { wave.WaveStart = (int)writer.Position; WaveMixer mixer = null; switch (extension) { case ".wav": mixer = new MicrosoftWaveMixer(instream); break; case ".raw": mixer = new RawWaveMixer(instream, wave.Format); break; } if (mixer == null) { mareep.WriteWarning("XFER: could not create wave mixer (unsupported file extension '{0}')\n", extension); ++badwaves; continue; } mixer.MixerMode = mMixerMode; mixer.CopyWaveInfo(wave); if (wave.Loop && wave.LoopStart > 0) { int last, penult; mixer.CalculateHistory(wave.LoopStart, wave.Format, out last, out penult); wave.HistoryLast = last; wave.HistoryPenult = penult; } mixer.Write(wave.Format, writer); wave.WaveSize = ((int)writer.Position - wave.WaveStart); writer.WritePadding(32, 0); mareep.WriteMessage(" #{0:X4} '{1,-35}' (0x{2:X6} 0x{3:X6})\n", wave.WaveId, Path.GetFileName(wave.FileName), wave.WaveStart, wave.WaveSize); } } } } if (badwaves > 0) { mareep.WriteError("Failed to transfer {0} wave(s).", badwaves); } return(obj); }
public BinaryWaveBankSerializer(aBinaryWriter writer) { mWriter = writer; }
public BmsWriter(Stream stream) { mWriter = new aBinaryWriter(stream, Endianness.Big); }
public void ToStream(aBinaryWriter writer) { writer.WriteS32(Start); writer.WriteS32(Length); writer.WriteString<aCSTR>(Name, 8); }
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) { if (value.Length > mMultiple) { value = value.Substring(0, mMultiple); } writer.WriteString(value); var count = mMultiple - value.Length; while (count-- > 0) { writer.WriteChar('\0'); } }
public abstract void Write(aBinaryWriter writer, string value);
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) { writer.WriteString(value); writer.WriteChar('\0'); }
public override void Write(aBinaryWriter writer, string value) { base.Write(writer, value); writer.WriteChar('\0'); }
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); }