Ejemplo n.º 1
0
        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;
                }
                }
            }
        }
Ejemplo n.º 2
0
        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);
            }
        }
Ejemplo n.º 3
0
        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);
            }
        }
Ejemplo n.º 4
0
        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);
        }
Ejemplo n.º 5
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);
                }
            }
        }
Ejemplo n.º 6
0
        void PerformRawToRaw(Stream instream, Stream outstream)
        {
            var mixer  = new RawWaveMixer(instream, mRawInputFormat);
            var writer = new aBinaryWriter(outstream, Endianness.Big);

            mixer.Write(mRawOutputFormat, writer);
        }
Ejemplo n.º 7
0
 public void Copy(aBinaryWriter writer)
 {
     if (writer == null)
     {
         throw new ArgumentNullException("writer");
     }
     writer.Write8s(mStream.GetBuffer(), (int)Size);
 }
Ejemplo n.º 8
0
 protected override void WritePcm16(aBinaryWriter writer)
 {
     for (var i = 0; i < mSampleCount; ++i)
     {
         GotoSample(i);
         writer.WriteS16(MixPcm16());
     }
 }
Ejemplo n.º 9
0
        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);
        }
Ejemplo n.º 10
0
 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();
 }
Ejemplo n.º 11
0
        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;
            }
            }
        }
Ejemplo n.º 12
0
        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);
        }
Ejemplo n.º 13
0
 public static void save(bloResource resource, aBinaryWriter writer)
 {
     if (resource != null)
     {
         resource.save(writer);
     }
     else
     {
         writer.Write8(0);
         writer.Write8(0);
     }
 }
Ejemplo n.º 14
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);
                }
            }
        }
Ejemplo n.º 15
0
        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;
            }
        }
Ejemplo n.º 16
0
        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);
        }
Ejemplo n.º 17
0
        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);
                }
            }
        }
Ejemplo n.º 18
0
        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);
        }
Ejemplo n.º 19
0
        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);
            }
        }
Ejemplo n.º 20
0
        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);
        }
Ejemplo n.º 21
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);
        }
Ejemplo n.º 22
0
        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);
        }
Ejemplo n.º 23
0
        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);
            }
        }
Ejemplo n.º 24
0
        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");
                    }
                }
        }
Ejemplo n.º 25
0
        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);
                }
            }
        }
Ejemplo n.º 26
0
        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);
        }
Ejemplo n.º 27
0
        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;
            }
        }
Ejemplo n.º 28
0
        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;
            }
        }
Ejemplo n.º 29
0
        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);
        }
Ejemplo n.º 30
0
 public BinaryWaveBankSerializer(aBinaryWriter writer)
 {
     mWriter = writer;
 }
Ejemplo n.º 31
0
 public BmsWriter(Stream stream)
 {
     mWriter = new aBinaryWriter(stream, Endianness.Big);
 }
Ejemplo n.º 32
0
 public void ToStream(aBinaryWriter writer)
 {
     writer.WriteS32(Start);
     writer.WriteS32(Length);
     writer.WriteString<aCSTR>(Name, 8);
 }
Ejemplo n.º 33
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();
        }
Ejemplo n.º 34
0
 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');
     }
 }
Ejemplo n.º 35
0
 public abstract void Write(aBinaryWriter writer, string value);
Ejemplo n.º 36
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);
 }
Ejemplo n.º 37
0
 public override void Write(aBinaryWriter writer, string value)
 {
     writer.WriteString(value);
     writer.WriteChar('\0');
 }
Ejemplo n.º 38
0
 public override void Write(aBinaryWriter writer, string value)
 {
     base.Write(writer, value);
     writer.WriteChar('\0');
 }
Ejemplo n.º 39
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);
 }