Esempio n. 1
0
        public static Chart Read(Stream source)
        {
            BinaryReaderEx reader = new BinaryReaderEx(source);

            Chart result = new Chart();
            result.TickRate = new Fraction(1, 58);

            int[] lastSample = new int[16];
            int eventParameter = 0;
            int eventValue = 0;
            int eventType = 0;
            int eventOffset = 0;
            bool notecountMode = true;
            bool defaultBPMSet = false;

            while (true)
            {
                eventOffset = reader.ReadUInt16();
                eventType = reader.ReadByte();
                eventParameter = (eventType >> 4);
                eventType &= 0xF;
                eventValue = reader.ReadByte();

                // end of chart?
                if (eventOffset == 0x7FFF)
                    break;

                // ignore events in note count mode
                if (notecountMode)
                {
                    if (eventType != 0 || eventOffset > 0)
                        notecountMode = false;
                }

                // process events
                if (!notecountMode)
                {
                    Entry entry = new Entry();

                    entry.LinearOffset = new Fraction(eventOffset, 1);

                    switch (eventType)
                    {
                        case 0x0: // marker
                            switch (eventParameter)
                            {
                                case 0x0: entry.Type = EntryType.Marker; entry.Player = 1; entry.Column = 0; entry.Value = new Fraction(lastSample[0x0], 1); break; //key0
                                case 0x1: entry.Type = EntryType.Marker; entry.Player = 2; entry.Column = 0; entry.Value = new Fraction(lastSample[0x1], 1); break;
                                case 0x2: entry.Type = EntryType.Marker; entry.Player = 1; entry.Column = 1; entry.Value = new Fraction(lastSample[0x2], 1); break; //key1
                                case 0x3: entry.Type = EntryType.Marker; entry.Player = 2; entry.Column = 1; entry.Value = new Fraction(lastSample[0x3], 1); break;
                                case 0x4: entry.Type = EntryType.Marker; entry.Player = 1; entry.Column = 2; entry.Value = new Fraction(lastSample[0x4], 1); break; //key2
                                case 0x5: entry.Type = EntryType.Marker; entry.Player = 2; entry.Column = 2; entry.Value = new Fraction(lastSample[0x5], 1); break;
                                case 0x6: entry.Type = EntryType.Marker; entry.Player = 1; entry.Column = 3; entry.Value = new Fraction(lastSample[0x6], 1); break; //key3
                                case 0x7: entry.Type = EntryType.Marker; entry.Player = 2; entry.Column = 3; entry.Value = new Fraction(lastSample[0x7], 1); break;
                                case 0x8: entry.Type = EntryType.Marker; entry.Player = 1; entry.Column = 4; entry.Value = new Fraction(lastSample[0x8], 1); break; //key4
                                case 0x9: entry.Type = EntryType.Marker; entry.Player = 2; entry.Column = 4; entry.Value = new Fraction(lastSample[0x9], 1); break;
                                case 0xA: entry.Type = EntryType.Marker; entry.Player = 1; entry.Column = 7; entry.Value = new Fraction(lastSample[0xA], 1); break; //scratch
                                case 0xB: entry.Type = EntryType.Marker; entry.Player = 2; entry.Column = 7; entry.Value = new Fraction(lastSample[0xB], 1); break;
                                case 0xC: entry.Type = EntryType.Measure; entry.Player = 1; break;
                                case 0xD: entry.Type = EntryType.Measure; entry.Player = 2; break;
                                case 0xE: entry.Type = EntryType.Marker; entry.Player = 1; entry.Column = 8; entry.Value = new Fraction(lastSample[0xA], 1); break; //freescratch
                                case 0xF: entry.Type = EntryType.Marker; entry.Player = 2; entry.Column = 8; entry.Value = new Fraction(lastSample[0xB], 1); break;
                            }
                            break;
                        case 0x1: // sample
                            switch (eventParameter)
                            {
                                case 0x0: entry.Type = EntryType.Sample; entry.Player = 1; entry.Column = 0; lastSample[0x0] = eventValue; entry.Value = new Fraction(eventValue, 1); break;
                                case 0x1: entry.Type = EntryType.Sample; entry.Player = 2; entry.Column = 0; lastSample[0x1] = eventValue; entry.Value = new Fraction(eventValue, 1); break;
                                case 0x2: entry.Type = EntryType.Sample; entry.Player = 1; entry.Column = 1; lastSample[0x2] = eventValue; entry.Value = new Fraction(eventValue, 1); break;
                                case 0x3: entry.Type = EntryType.Sample; entry.Player = 2; entry.Column = 1; lastSample[0x3] = eventValue; entry.Value = new Fraction(eventValue, 1); break;
                                case 0x4: entry.Type = EntryType.Sample; entry.Player = 1; entry.Column = 2; lastSample[0x4] = eventValue; entry.Value = new Fraction(eventValue, 1); break;
                                case 0x5: entry.Type = EntryType.Sample; entry.Player = 2; entry.Column = 2; lastSample[0x5] = eventValue; entry.Value = new Fraction(eventValue, 1); break;
                                case 0x6: entry.Type = EntryType.Sample; entry.Player = 1; entry.Column = 3; lastSample[0x6] = eventValue; entry.Value = new Fraction(eventValue, 1); break;
                                case 0x7: entry.Type = EntryType.Sample; entry.Player = 2; entry.Column = 3; lastSample[0x7] = eventValue; entry.Value = new Fraction(eventValue, 1); break;
                                case 0x8: entry.Type = EntryType.Sample; entry.Player = 1; entry.Column = 4; lastSample[0x8] = eventValue; entry.Value = new Fraction(eventValue, 1); break;
                                case 0x9: entry.Type = EntryType.Sample; entry.Player = 2; entry.Column = 4; lastSample[0x9] = eventValue; entry.Value = new Fraction(eventValue, 1); break;
                                case 0xA: entry.Type = EntryType.Sample; entry.Player = 1; entry.Column = 7; lastSample[0xA] = eventValue; entry.Value = new Fraction(eventValue, 1); break;
                                case 0xB: entry.Type = EntryType.Sample; entry.Player = 2; entry.Column = 7; lastSample[0xB] = eventValue; entry.Value = new Fraction(eventValue, 1); break;
                                case 0xE: entry.Type = EntryType.Sample; entry.Player = 1; entry.Column = 8; lastSample[0xA] = eventValue; entry.Value = new Fraction(eventValue, 1); break;
                                case 0xF: entry.Type = EntryType.Sample; entry.Player = 2; entry.Column = 8; lastSample[0xB] = eventValue; entry.Value = new Fraction(eventValue, 1); break;
                            }
                            break;
                        case 0x2: // tempo
                            entry.Type = EntryType.Tempo;
                            entry.Value = new Fraction((eventParameter * 256) + eventValue, 1);
                            if (!defaultBPMSet)
                            {
                                defaultBPMSet = true;
                                result.DefaultBPM = entry.Value;
                            }
                            break;
                        case 0x4: // end of song
                            entry.Type = EntryType.EndOfSong;
                            break;
                        case 0x5: // bgm
                            entry.Type = EntryType.Marker;
                            entry.Player = 0;
                            entry.Value = new Fraction(eventValue, 1);
                            break;
                        case 0x6: // judgement
                            entry.Type = EntryType.Judgement;
                            entry.Value = new Fraction(eventValue, 1);
                            entry.Parameter = eventParameter;
                            break;
                    }

                    if (entry.Type != EntryType.Invalid)
                        result.Entries.Add(entry);
                }
            }

            if (result.Entries.Count > 0)
            {
                result.Entries.Sort();
                result.CalculateMetricOffsets();
            }
            else
            {
                result = null;
            }

            return result;
        }
Esempio n. 2
0
File: PE.cs Progetto: s0rg/pe.net
		/// <summary>
		/// Create new PE Object from strean
		/// </summary>
		/// <param name="stream"></param>
		public PE(Stream stream, bool load_full = false)
		{
			pe = new BinaryReaderEx(stream);
			
			try {
				pe.ReadStruct<IMAGE_DOS_HEADER>(out this.dosHeader);

				if (dosHeader.e_magic != 0x5A4D) // MZ
					throw new Exception("Invalid DOS header");

				pe.Seek(dosHeader.e_lfanew);

				UInt32 nt_sign = pe.ReadUInt32();

				if (nt_sign != 0x4550) // PE
					throw new Exception("Invalid PE signature");

				pe.ReadStruct<IMAGE_FILE_HEADER>(out fileHeader);

				ushort magic = pe.ReadUInt16();
				pe.Seek(-2, SeekOrigin.Current);
				
				switch (magic) {
					case (ushort)PeType.PE32:
						this.peType = PeType.PE32;
						pe.ReadStruct<IMAGE_OPTIONAL_HEADER32>(out this.optionalHeader32);
						break;

					case (ushort)PeType.PE64:
						this.peType = PeType.PE64;
						pe.ReadStruct<IMAGE_OPTIONAL_HEADER64>(out this.optionalHeader64);
						break;

					case (ushort)PeType.ROM:
						this.peType = PeType.ROM;
						break;

					default:
						throw new Exception("Invalid IMAGE_FILE_HEADER.Magic value");
				}
				
				if (this.peType != PeType.ROM) {
					this.imageSectionHeaders = pe.ReadStructArray<IMAGE_SECTION_HEADER>(fileHeader.NumberOfSections);
					
					this.loadSections();
					
					if (load_full)
						this.LoadFull();
				}
			
			} catch (Exception e) {
				pe = null;
				throw e;
			}
		}
Esempio n. 3
0
            /*
            public static bool operator ==(Properties a, Properties b)
            {
                return (a.Channel == b.Channel &&
                    a.Flags == b.Flags &&
                    a.Frequency == b.Frequency &&
                    a.Offset == b.Offset &&
                    a.Panning == b.Panning &&
                    a.ReverbVolume == b.ReverbVolume &&
                    a.SampleType == b.SampleType &&
                    a.Volume == b.Volume
                    );
            }

            public static bool operator !=(Properties a, Properties b)
            {
                return (a.Channel != b.Channel ||
                    a.Flags != b.Flags ||
                    a.Frequency != b.Frequency ||
                    a.Offset != b.Offset ||
                    a.Panning != b.Panning ||
                    a.ReverbVolume != b.ReverbVolume ||
                    a.SampleType != b.SampleType ||
                    a.Volume != b.Volume
                    );
            }
            */
            public static Properties Read(Stream source)
            {
                BinaryReaderEx reader = new BinaryReaderEx(source);
                Properties result = new Properties();

                result.Channel = reader.ReadByte();
                result.Frequency = reader.ReadUInt16();
                result.ReverbVolume = reader.ReadByte();
                result.Volume = reader.ReadByte();
                result.Panning = reader.ReadByte();
                result.Offset = reader.ReadUInt24();
                result.SampleType = reader.ReadByte();
                result.Flags = reader.ReadByte();

                return result;
            }
Esempio n. 4
0
        private void ReadRows(BinaryReaderEx r, DataTable table)
        {
            object[] values = new object[columns.Count];
            for (uint i = 0; i < this.RecordCount; i++)
            {
                uint RowLength = r.ReadUInt16();
                for (int j = 0; j < columns.Count; j++)
                {
                    switch (this.columns[j].Type)
                    {
                        case 1:
                            values[j] = r.ReadByte();
                            break;

                        case 2:
                            values[j] = r.ReadUInt16();
                            break;

                        case 3:
                            values[j] = r.ReadUInt32();
                            break;

                        case 5:
                            values[j] = r.ReadSingle();
                            break;

                        case 9:
                            values[j] = r.ReadString(this.ColumnLengths[j]);
                            break;

                        case 11:
                            values[j] = r.ReadUInt32();
                            break;

                        case 12:
                            values[j] = r.ReadByte();
                            break;

                        case 13:
                            values[j] = r.ReadInt16();
                            break;

                        case 0x10:
                            values[j] = r.ReadByte();
                            break;

                        case 0x12:
                            values[j] = r.ReadUInt32();
                            break;

                        case 20:
                            values[j] = r.ReadSByte();
                            break;

                        case 0x15:
                            values[j] = r.ReadInt16();
                            break;

                        case 0x16:
                            values[j] = r.ReadInt32();
                            break;

                        case 0x18:
                            values[j] = r.ReadString(this.ColumnLengths[j]);
                            break;

                        case 0x1a: //unk lenght
                            values[j] = r.ReadString();
                            break;

                        case 0x1b:
                            values[j] = r.ReadUInt32();
                            break;
                    }
                }
                table.Rows.Add(values);
            }
        }