Beispiel #1
0
        static void WriteText(uint ofs)
        {
            byte command;

            sReader.Keep();
            sReader.Goto(sTextOffset + ofs);
            var maxofs = 0u;

            do
            {
                var pos = sReader.Position - sTextOffset;
                command = sReader.Read8();
                sWriter.Write("  {0:X8} {1}", pos, sCommandNames[command]);
                var nextofs = 0u;
                switch (command)
                {
                case 0x00: sWriter.Write(" {0}", sReader.ReadS32()); break;

                case 0x01: sWriter.Write(" {0}", sReader.ReadF32()); break;

                case 0x02: {
                    var data  = sReader.ReadS32();
                    var value = FetchDataValue(data);
                    sWriter.Write(" {0} # \"{1}\"", data, value);
                    break;
                }

                case 0x03: sWriter.Write(" ${0:X8}", sReader.Read32()); break;

                case 0x04: WriteVar(); break;

                case 0x06: WriteVar(); break;

                case 0x07: WriteVar(); break;

                case 0x0D: {
                    sReader.Read8();                             // TSpcInterp skips this byte
                    WriteVar();
                    break;
                }

                case 0x1C: {
                    var dest   = sReader.Read32();
                    var args   = sReader.ReadS32();
                    var symbol = FetchSymbol(i => i.Data == dest);
                    if (symbol != null)
                    {
                        sWriter.Write(" {0}, {1}", FetchSymbolName(symbol), args);
                    }
                    else
                    {
                        sWriter.Write(" ${0:X8}, {1}", dest, args);
                    }
                    break;
                }

                case 0x1D: sWriter.Write(" {0}, {1}", FetchSymbolName(FetchSymbol(sReader.ReadS32())), sReader.ReadS32()); break;

                case 0x1E: sWriter.Write(" {0}", sReader.ReadS32()); break;

                case 0x1F: sWriter.Write(" {0}", sReader.ReadS32()); break;

                case 0x22: nextofs = WriteJmp(ofs); break;

                case 0x23: nextofs = WriteJmp(ofs); break;
                }
                sWriter.WriteLine();
                if (nextofs > maxofs)
                {
                    maxofs = nextofs;
                }
            } while (!IsReturnCommand(command) || sReader.Position <= sTextOffset + maxofs);
            sWriter.WriteLine();
            sReader.Back();
        }
Beispiel #2
0
        static bool WriteAafHeader(aBinaryReader reader, aBinaryWriter writer, int id, int index, byte[] data)
        {
            long reader_base = reader.Position;
            long writer_base = writer.Position;
            int  old_offset, old_size;

            if (!ReadAafHeader(reader, id, index, out old_offset, out old_size))
            {
                return(false);
            }

            int difference = (data.Length - old_size);

            reader.Goto(reader_base);
            int section;

            while ((section = reader.ReadS32()) != 0)
            {
                bool has_vnum = (section == 2 || section == 3);
                writer.WriteS32(section);
                int offset, size;
                int i = 0;

                while ((offset = reader.ReadS32()) != 0)
                {
                    size = reader.ReadS32();

                    if (offset > old_offset)
                    {
                        offset += difference;
                    }

                    writer.Keep();
                    writer.Goto(writer_base + offset);

                    if (section == id && i == index)
                    {
                        writer.Write8s(data);
                        size = data.Length;
                    }
                    else
                    {
                        reader.Keep();
                        reader.Goto(reader_base + offset);
                        writer.Write8s(reader.Read8s(size));
                        reader.Back();
                    }

                    writer.Back();
                    writer.WriteS32(offset);
                    writer.WriteS32(size);

                    if (has_vnum)
                    {
                        writer.WriteS32(reader.ReadS32());
                    }

                    ++i;
                }

                writer.WriteS32(0);
            }

            writer.WriteS32(0);
            writer.Goto(writer.Length);
            writer.WritePadding(32, 0);
            return(true);
        }
Beispiel #3
0
        protected override WaveBank DoTransform(WaveBank obj)
        {
            if (obj != null)
            {
                return(obj);
            }

            mReader.Keep();
            mReader.PushAnchor();

            if (mReader.Read32() != WSYS)
            {
                mareep.WriteError("WSYS: could not find header.");
            }

            var size = mReader.ReadS32();

            mReader.Step(8);             // unused
            var winfOffset = mReader.ReadS32();
            var wbctOffset = mReader.ReadS32();

            mareep.WriteMessage("WSYS: header found, size {0:F1} KB\n", ((double)size / 1024.0d));

            var waveBank = new WaveBank();

            waveBank.Name = mName;

            mReader.Goto(winfOffset);

            if (mReader.Read32() != WINF)
            {
                mareep.WriteError("WSYS: could not find WINF at 0x{0:X6}.", winfOffset);
            }

            var waveGroupCount = mReader.ReadS32();

            if (waveGroupCount < 0)
            {
                mareep.WriteError("WSYS: bad wave-group count '{0}' in WINF.", waveGroupCount);
            }

            mareep.WriteMessage("WSYS: WINF found, {0} wave group(s).\n", waveGroupCount);

            var waveGroupOffsets = mReader.ReadS32s(waveGroupCount);

            mReader.Goto(wbctOffset);

            if (mReader.Read32() != WBCT)
            {
                mareep.WriteError("WSYS: could not find WBCT at 0x{0:X6}.", wbctOffset);
            }

            mReader.Step(4);             // unused

            var sceneCount = mReader.ReadS32();

            if (sceneCount != waveGroupCount)
            {
                mareep.WriteError("WSYS: WINF count ({0}) does not match WBCT count ({1}).", waveGroupCount, sceneCount);
            }

            var sceneOffsets = mReader.ReadS32s(sceneCount);

            for (var i = 0; i < waveGroupCount; ++i)
            {
                mReader.Goto(waveGroupOffsets[i]);

                var archiveName   = mReader.ReadString <aCSTR>(112);
                var waveInfoCount = mReader.ReadS32();

                if (waveInfoCount < 0)
                {
                    mareep.WriteError("WSYS: bad wave count '{0}' in wave group #{1}.", waveInfoCount, i);
                }

                var waveInfoOffsets = mReader.ReadS32s(waveInfoCount);

                mReader.Goto(sceneOffsets[i]);

                if (mReader.Read32() != SCNE)
                {
                    mareep.WriteError("WSYS: could not find SCNE at 0x{0:X6}.", sceneOffsets[i]);
                }

                mReader.Step(8);                 // unused
                var cdfOffset = mReader.ReadS32();
                mReader.Goto(cdfOffset);

                if (mReader.Read32() != C_DF)
                {
                    mareep.WriteError("WSYS: could not find C-DF at 0x{0:X6}.", cdfOffset);
                }

                var waveidCount = mReader.ReadS32();

                if (waveidCount != waveInfoCount)
                {
                    mareep.WriteError("WSYS: C-DF count ({0}) does not match wave-info count ({1}).", waveidCount, waveInfoCount);
                }

                var waveidOffsets = mReader.ReadS32s(waveidCount);

                var waveGroup = new WaveGroup();
                waveGroup.ArchiveFileName = archiveName;

                for (var j = 0; j < waveInfoCount; ++j)
                {
                    var wave = new Wave();

                    mReader.Goto(waveidOffsets[j]);

                    var waveid = (mReader.ReadS32() & 0xFFFF);
                    wave.WaveId = waveid;

                    mReader.Goto(waveInfoOffsets[j]);
                    mReader.Step(1);                     // unknown

                    var format = (WaveFormat)mReader.Read8();

                    if (!format.IsDefined())
                    {
                        mareep.WriteError("WSYS: group #{0}: wave #{1}: bad format '{2}'.", i, j, (byte)format);
                    }
                    else
                    {
                        wave.Format = format;
                    }

                    var key = mReader.Read8();

                    if (key < 0 || key > 127)
                    {
                        mareep.WriteError("WSYS: group #{0}: wave #{1}: bad root key '{2}'.", i, j, key);
                    }
                    else
                    {
                        wave.RootKey = key;
                    }

                    mReader.Step(1);                     // alignment

                    var sampleRate = mReader.ReadF32();

                    if (sampleRate < 0.0f)
                    {
                        mareep.WriteError("WSYS: group #{0}: wave #{1}: bad sample rate '{2:F1}'.", i, j, sampleRate);
                    }
                    else
                    {
                        wave.SampleRate = sampleRate;
                    }

                    var waveStart = mReader.ReadS32();

                    if (waveStart < 0)
                    {
                        mareep.WriteError("WSYS: group #{0}: wave #{1}: bad wave start '{2}'.", i, j, waveStart);
                    }
                    else
                    {
                        wave.WaveStart = waveStart;
                    }

                    var waveSize = mReader.ReadS32();

                    if (waveSize < 0)
                    {
                        mareep.WriteError("WSYS: group #{0}: wave #{1}: bad wave size '{1}'.", i, j, waveSize);
                    }
                    else
                    {
                        wave.WaveSize = waveSize;
                    }

                    wave.Loop = (mReader.Read32() != 0);

                    var loopStart = mReader.ReadS32();

                    if (loopStart < 0)
                    {
                        mareep.WriteError("WSYS: group #{0}: wave #{1}: bad loop start '{2}'.", i, j, loopStart);
                    }
                    else
                    {
                        wave.LoopStart = loopStart;
                    }

                    var loopEnd = mReader.ReadS32();

                    if (loopEnd < 0)
                    {
                        mareep.WriteError("WSYS: group #{0}: wave #{1}: bad loop end '{2}'.", i, j, loopEnd);
                    }
                    else
                    {
                        wave.LoopEnd = loopEnd;
                    }

                    var sampleCount = mReader.ReadS32();
                    wave.SampleCount = mareep.CalculateSampleCount(format, waveSize);

                    if (loopStart > loopEnd)
                    {
                        mareep.WriteWarning("WSYS: group #{0}: wave #{1}: loop start '{2}' is greater than loop end '{3}'.\n", i, j, loopStart, loopEnd);
                    }

                    if (loopStart > wave.SampleCount)
                    {
                        mareep.WriteWarning("WSYS: group #{0}: wave #{1}: loop start '{2}' is greater than sample count '{3}'.\n", i, j, loopStart, wave.SampleCount);
                    }

                    if (loopEnd > wave.SampleCount)
                    {
                        mareep.WriteWarning("WSYS: group #{0}: wave #{1}: loop end '{2}' is greater than sample count '{3}'.\n", i, j, loopEnd, wave.SampleCount);
                    }

                    wave.HistoryLast   = mReader.ReadS16();
                    wave.HistoryPenult = mReader.ReadS16();

                    // rest of the fields are unknown or runtime

                    waveGroup.Add(wave);
                }

                waveBank.Add(waveGroup);
            }

            mReader.PopAnchor();
            mReader.Back();

            return(waveBank);
        }
Beispiel #4
0
        static bool WriteAafHeader(aBinaryReader reader, aBinaryWriter writer, int id, int index, byte[] data)
        {
            long reader_base = reader.Position;
            long writer_base = writer.Position;
            int  old_offset, old_size;

            if (!ReadAafHeader(reader, id, index, out old_offset, out old_size))
            {
                return(false);
            }

            int difference = (data.Length - old_size);

            mareep.WriteMessage("Entry size difference: {0} byte(s)\n", difference);
            int danger_level = 0;

            reader.Goto(reader_base);
            int section;

            while ((section = reader.ReadS32()) != 0)
            {
                if (danger_level++ > 1000)
                {
                    mareep.WriteError("CHARGE: malformed AAF file (endless loop detected)");
                }

                bool has_vnum = (section == 2 || section == 3);
                writer.WriteS32(section);
                int offset, size;
                int i = 0;

                while ((offset = reader.ReadS32()) != 0)
                {
                    if (danger_level++ > 1000)
                    {
                        mareep.WriteError("CHARGE: malformed AAF file (endless loop detected)");
                    }

                    size = reader.ReadS32();
                    int new_offset = offset;

                    if (new_offset > old_offset)
                    {
                        new_offset += difference;
                    }

                    writer.Keep();
                    writer.Goto(writer_base + new_offset);

                    if (section == id && i == index)
                    {
                        writer.Write8s(data);
                        size = data.Length;
                    }
                    else
                    {
                        reader.Keep();
                        reader.Goto(reader_base + offset);
                        writer.Write8s(reader.Read8s(size));
                        reader.Back();
                    }

                    writer.Back();
                    writer.WriteS32(new_offset);
                    writer.WriteS32(size);

                    if (has_vnum)
                    {
                        writer.WriteS32(reader.ReadS32());
                    }

                    ++i;
                }

                writer.WriteS32(0);
            }

            writer.WriteS32(0);
            writer.Goto(writer.Length);
            writer.WritePadding(32, 0);
            return(true);
        }