예제 #1
0
        public static Cry LoadCry(int index, int cryTable)
        {
            var cryToLoad = new Cry();

            // If ledrom Is Nothing Then
            // Return False
            // End If

            // load cry table entry
            // ledrom.Seek(cryTable + index * 12)

            // Dim someValue = ledrom.ReadInt32()
            // Dim cryOffset = ledrom.ReadPointer()
            // Dim cryShape = ledrom.ReadInt32()

            string LocalReadHex()
            {
                var argStart2 = cryTable + index * 12; var argLength = 4; var ret = HexFunctions.ReadHex(ref MainObject.LoadedRom, ref argStart2, ref argLength); return(ret);
            }

            string LocalReverseHex()
            {
                var argHexData = "hs114971a3962f4785bb1199029f740d9a()"; var ret = HexFunctions.ReverseHex(ref argHexData); return(ret);
            }

            var someValue = int.Parse(LocalReverseHex(), System.Globalization.NumberStyles.HexNumber);

            string LocalReadHex1()
            {
                var argStart2 = cryTable + index * 12 + 4; var argLength = 4; var ret = HexFunctions.ReadHex(ref MainObject.LoadedRom, ref argStart2, ref argLength); return(ret);
            }

            string LocalReverseHex1()
            {
                var argHexData = "hs42097b91af9a4cb7bf85297615b2b82c()"; var ret = HexFunctions.ReverseHex(ref argHexData); return(ret);
            }

            var cryOffset = int.Parse(LocalReverseHex1(), System.Globalization.NumberStyles.HexNumber) - 0x8000000;

            string LocalReadHex2()
            {
                var argStart2 = cryTable + index * 12 + 8; var argLength = 4; var ret = HexFunctions.ReadHex(ref MainObject.LoadedRom, ref argStart2, ref argLength); return(ret);
            }

            string LocalReverseHex2()
            {
                var argHexData = "hs636c588e252f49388e9b7cfd50d62ae5()"; var ret = HexFunctions.ReverseHex(ref argHexData); return(ret);
            }

            var cryShape = int.Parse(LocalReverseHex2(), System.Globalization.NumberStyles.HexNumber);


            // If cryOffset = 0 Then
            // Return False
            // End If

            // load cry data
            // ledrom.Seek(cryOffset)

            cryToLoad.Offset = cryOffset;
            cryToLoad.Index  = index;


            // CryToLoad.Compressed = ledrom.ReadUInt16() = &H1
            // CryToLoad.Looped = ledrom.ReadUInt16() = &H4000
            // CryToLoad.SampleRate = ledrom.ReadInt32() >> 10
            // CryToLoad.LoopStart = ledrom.ReadInt32()
            // CryToLoad.Size = ledrom.ReadInt32() + 1

            string LocalReadHex3()
            {
                var argStart2 = cryOffset + 0; var argLength = 2; var ret = HexFunctions.ReadHex(ref MainObject.LoadedRom, ref argStart2, ref argLength); return(ret);
            }

            string LocalReverseHex3()
            {
                var argHexData = "hs228b8612293b47259bd1ddc81cc475da()"; var ret = HexFunctions.ReverseHex(ref argHexData); return(ret);
            }

            cryToLoad.Compressed = short.Parse(LocalReverseHex3(), System.Globalization.NumberStyles.HexNumber) == 0x1;
            string LocalReadHex4()
            {
                var argStart2 = cryOffset + 2; var argLength = 2; var ret = HexFunctions.ReadHex(ref MainObject.LoadedRom, ref argStart2, ref argLength); return(ret);
            }

            string LocalReverseHex4()
            {
                var argHexData = "hs1356c430d68a4b5c97b50286fa9e623c()"; var ret = HexFunctions.ReverseHex(ref argHexData); return(ret);
            }

            cryToLoad.Looped = short.Parse(LocalReverseHex4(), System.Globalization.NumberStyles.HexNumber) == 0x4000;
            string LocalReadHex5()
            {
                var argStart2 = cryOffset + 4; var argLength = 4; var ret = HexFunctions.ReadHex(ref MainObject.LoadedRom, ref argStart2, ref argLength); return(ret);
            }

            string LocalReverseHex5()
            {
                var argHexData = "hsdf6fddefae014a00ae3654bb21c3d239()"; var ret = HexFunctions.ReverseHex(ref argHexData); return(ret);
            }

            cryToLoad.SampleRate = int.Parse(LocalReverseHex5(), System.Globalization.NumberStyles.HexNumber) >> 10;
            string LocalReadHex6()
            {
                var argStart2 = cryOffset + 8; var argLength = 4; var ret = HexFunctions.ReadHex(ref MainObject.LoadedRom, ref argStart2, ref argLength); return(ret);
            }

            string LocalReverseHex6()
            {
                var argHexData = "hs8b94dd1b930547378b53e2d5ed2df7c4()"; var ret = HexFunctions.ReverseHex(ref argHexData); return(ret);
            }

            cryToLoad.LoopStart = int.Parse(LocalReverseHex6(), System.Globalization.NumberStyles.HexNumber);
            string LocalReadHex7()
            {
                var argStart2 = cryOffset + 12; var argLength = 4; var ret = HexFunctions.ReadHex(ref MainObject.LoadedRom, ref argStart2, ref argLength); return(ret);
            }

            string LocalReverseHex7()
            {
                var argHexData = "hs29971bab56db428e81f7e305c6e4d9da()"; var ret = HexFunctions.ReverseHex(ref argHexData); return(ret);
            }

            cryToLoad.Size = int.Parse(LocalReverseHex7(), System.Globalization.NumberStyles.HexNumber) + 1;
            if (!cryToLoad.Compressed)
            {
                // uncompressed, 1 sample per 1 byte of size
                cryToLoad.Data = new sbyte[cryToLoad.Size];
                for (int g = 0, loopTo = cryToLoad.Size - 1; g <= loopTo; g++)
                {
                    string LocalReadHex8()
                    {
                        var argStart2 = cryOffset + 16 + g; var argLength = 1; var ret = HexFunctions.ReadHex(ref MainObject.LoadedRom, ref argStart2, ref argLength); return(ret);
                    }

                    cryToLoad.Data[g] = (sbyte)ByteFunctions.ByteToSignedInteger(Conversions.ToByte("&H" + LocalReadHex8()));
                }
            }
            else
            {
                // compressed, a bit of a hassle
                var lookup = new sbyte[] { 0, 1, 4, 9, 16, 25, 36, 49, -64, -49, -36, -25, -16, -9, -4, -1 };

                var   start     = cryOffset + 16;
                var   offtrack  = cryOffset + 16;
                var   alignment = 0;
                var   size      = 0;
                sbyte pcmLevel  = 0;
                var   data      = new List <sbyte>();
                while (true)
                {
                    if (alignment == 0)
                    {
                        var argLength = 1;
                        pcmLevel  = (sbyte)ByteFunctions.ByteToSignedInteger(Conversions.ToByte("&H" + HexFunctions.ReadHex(ref MainObject.LoadedRom, ref offtrack, ref argLength)));
                        offtrack += 1;
                        data.Add(pcmLevel);
                        alignment = 0x20;
                    }

                    var argLength1 = 1;
                    var input      = Conversions.ToByte("&H" + HexFunctions.ReadHex(ref MainObject.LoadedRom, ref offtrack, ref argLength1));
                    offtrack += 1;
                    if (alignment < 0x20)
                    {
                        // first nybble
                        pcmLevel += lookup[input >> 4];
                        data.Add(pcmLevel);
                    }

                    // second nybble
                    pcmLevel += lookup[input & 0xF];
                    data.Add(pcmLevel);

                    // exit when currentSize >= cry.Size
                    size += 2;
                    if (size >= cryToLoad.Size)
                    {
                        break;
                    }

                    alignment -= 1;
                }

                cryToLoad.Data = data.ToArray();
                // bytes needed to recompress
                cryToLoad.Size = offtrack - start;
            }

            return(cryToLoad);
        }