| private ToUInt16 ( byte value, int startIndex ) : ushort | ||
| value | byte | |
| startIndex | int | |
| Результат | ushort | |
public static MidiData parse(FileStream input_file_stream)
{
var input_binary_reader = new BinaryReader(input_file_stream);
HeaderChunk header_chunk;
ushort number_of_tracks;
{
var header_chunk_ID = stringEncoder.GetString(input_binary_reader.ReadBytes(4));
var header_chunk_size = BitConverter.ToInt32(input_binary_reader.ReadBytes(4).Reverse().ToArray <byte>(), 0);
var header_chunk_data = input_binary_reader.ReadBytes(header_chunk_size);
var format_type = BitConverter.ToUInt16(header_chunk_data.Take(2).Reverse().ToArray <byte>(), 0);
number_of_tracks = BitConverter.ToUInt16(header_chunk_data.Skip(2).Take(2).Reverse().ToArray <byte>(), 0);
var time_division = BitConverter.ToUInt16(header_chunk_data.Skip(4).Take(2).Reverse().ToArray <byte>(), 0);
header_chunk = new HeaderChunk(format_type, time_division);
}
var tracks =
Enumerable.Range(0, number_of_tracks)
.Select(track_number =>
{
var track_chunk_ID = stringEncoder.GetString(input_binary_reader.ReadBytes(4));
var track_chunk_size = BitConverter.ToInt32(input_binary_reader.ReadBytes(4).Reverse().ToArray <byte>(), 0);
var track_chunk_data = input_binary_reader.ReadBytes(track_chunk_size);
return(Tuple.Create(track_chunk_size, track_chunk_data));
}).ToList()
.Select(raw_track => new TrackChunk(parse_events(raw_track.Item2, raw_track.Item1)));
return(new MidiData(header_chunk, tracks));
}
private void _ReadEmblemFullInfo()
{
//loop here in case it runs this too early and reads 0 max emblems because it's not initialized in the game yet
int tries = 0, maxEmblems = 0, maxExtra = 0;
do
{
//read the number of emblems loaded into the game
byte[] maxEmblemsBuffer = new byte[4];
byte[] maxExtraBuffer = new byte[4];
ReadProcessMemory(gameProc.Handle, MAX_EMBLEMS_ADDRESS, maxEmblemsBuffer, 4, IntPtr.Zero);
ReadProcessMemory(gameProc.Handle, MAX_EXTRA_EMBLEMS_ADDRESS, maxExtraBuffer, 4, IntPtr.Zero);
maxEmblems = BC.ToInt32(maxEmblemsBuffer, 0);
maxExtra = BC.ToInt32(maxExtraBuffer, 0);
if (maxEmblems + maxExtra != 0)
{
break;
}
Thread.Sleep(2000);
tries++;
}while (tries < 5);
Emblems = new Emblem[maxEmblems];
ExtraEmblems = new ExtraEmblem[maxExtra];
byte[] currentEmblem = new byte[128]; //size of 1 emblem object in memory
int address = EMBLEMS_ADDRESS;
for (int i = 0; i < Emblems.Length; i++)
{
ReadProcessMemory(gameProc.Handle, address, currentEmblem, currentEmblem.Length, IntPtr.Zero);
//WriteProcessMemory(gameProc.Handle, address + 4, new byte[1] { 1 }, 1, IntPtr.Zero); //for the fun stuff
Emblems[i] = new Emblem()
{
type = currentEmblem[0],
tag = BC.ToInt16(currentEmblem, 2),
level = BC.ToInt16(currentEmblem, 4),
sprite = Convert.ToChar(currentEmblem[6]),
color = BC.ToUInt16(currentEmblem, 8),
var = BC.ToInt32(currentEmblem, 12),
hint = Encoding.ASCII.GetString(currentEmblem, 16, 110),
collected = currentEmblem[126]
};
address += 128;
}
currentEmblem = new byte[68]; //size of 1 extra emblem object in memory
address = EXTRA_EMBLEMS_ADDRESS;
for (int i = 0; i < ExtraEmblems.Length; i++)
{
ReadProcessMemory(gameProc.Handle, address, currentEmblem, currentEmblem.Length, IntPtr.Zero);
ExtraEmblems[i] = new ExtraEmblem()
{
name = Encoding.ASCII.GetString(currentEmblem, 0, 20),
description = Encoding.ASCII.GetString(currentEmblem, 20, 40),
conditionset = currentEmblem[60],
showconditionset = currentEmblem[61],
sprite = Convert.ToChar(currentEmblem[62]),
color = BC.ToUInt16(currentEmblem, 64),
collected = currentEmblem[66],
};
address += 68;
}
if (!(previousEmblems.SequenceEqual(Emblems) && previousExtraEmblems.SequenceEqual(ExtraEmblems)))
{
EmblemsChangedEvent(this, EmblemsChangedEventArgs.FullInfo);
}
previousEmblems = (Emblem[])Emblems.Clone();
previousExtraEmblems = (ExtraEmblem[])ExtraEmblems.Clone();
}
internal StrongNameSignature StrongHash(Stream stream, StrongNameOptions options)
{
var info = new StrongNameSignature();
HashAlgorithm hash = HashAlgorithm.Create(TokenAlgorithm);
var cs = new CryptoStream(Stream.Null, hash, CryptoStreamMode.Write);
// MS-DOS Header - always 128 bytes
// ref: Section 24.2.1, Partition II Metadata
var mz = new byte[128];
stream.Read(mz, 0, 128);
if (BitConverterLE.ToUInt16(mz, 0) != 0x5a4d)
{
return(null);
}
UInt32 peHeader = BitConverterLE.ToUInt32(mz, 60);
cs.Write(mz, 0, 128);
if (peHeader != 128)
{
var mzextra = new byte[peHeader - 128];
stream.Read(mzextra, 0, mzextra.Length);
cs.Write(mzextra, 0, mzextra.Length);
}
// PE File Header - always 248 bytes
// ref: Section 24.2.2, Partition II Metadata
var pe = new byte[248];
stream.Read(pe, 0, 248);
if (BitConverterLE.ToUInt32(pe, 0) != 0x4550)
{
return(null);
}
if (BitConverterLE.ToUInt16(pe, 4) != 0x14c)
{
return(null);
}
// MUST zeroize both CheckSum and Security Directory
var v = new byte[8];
Buffer.BlockCopy(v, 0, pe, 88, 4);
Buffer.BlockCopy(v, 0, pe, 152, 8);
cs.Write(pe, 0, 248);
UInt16 numSection = BitConverterLE.ToUInt16(pe, 6);
int sectionLength = (numSection * 40);
var sectionHeaders = new byte[sectionLength];
stream.Read(sectionHeaders, 0, sectionLength);
cs.Write(sectionHeaders, 0, sectionLength);
UInt32 cliHeaderRVA = BitConverterLE.ToUInt32(pe, 232);
UInt32 cliHeaderPos = RVAtoPosition(cliHeaderRVA, numSection, sectionHeaders);
var cliHeaderSiz = (int)BitConverterLE.ToUInt32(pe, 236);
// CLI Header
// ref: Section 24.3.3, Partition II Metadata
var cli = new byte[cliHeaderSiz];
stream.Position = cliHeaderPos;
stream.Read(cli, 0, cliHeaderSiz);
UInt32 strongNameSignatureRVA = BitConverterLE.ToUInt32(cli, 32);
info.SignaturePosition = RVAtoPosition(strongNameSignatureRVA, numSection, sectionHeaders);
info.SignatureLength = BitConverterLE.ToUInt32(cli, 36);
UInt32 metadataRVA = BitConverterLE.ToUInt32(cli, 8);
info.MetadataPosition = RVAtoPosition(metadataRVA, numSection, sectionHeaders);
info.MetadataLength = BitConverterLE.ToUInt32(cli, 12);
if (options == StrongNameOptions.Metadata)
{
cs.Close();
hash.Initialize();
var metadata = new byte[info.MetadataLength];
stream.Position = info.MetadataPosition;
stream.Read(metadata, 0, metadata.Length);
info.Hash = hash.ComputeHash(metadata);
return(info);
}
// now we hash every section EXCEPT the signature block
for (int i = 0; i < numSection; i++)
{
UInt32 start = BitConverterLE.ToUInt32(sectionHeaders, i * 40 + 20);
var length = (int)BitConverterLE.ToUInt32(sectionHeaders, i * 40 + 16);
var section = new byte[length];
stream.Position = start;
stream.Read(section, 0, length);
if ((start <= info.SignaturePosition) && (info.SignaturePosition < start + length))
{
// hash before the signature
var before = (int)(info.SignaturePosition - start);
if (before > 0)
{
cs.Write(section, 0, before);
}
// copy signature
info.Signature = new byte[info.SignatureLength];
Buffer.BlockCopy(section, before, info.Signature, 0, (int)info.SignatureLength);
Array.Reverse(info.Signature);
// hash after the signature
var s = (int)(before + info.SignatureLength);
int after = (length - s);
if (after > 0)
{
cs.Write(section, s, after);
}
}
else
{
cs.Write(section, 0, length);
}
}
cs.Close();
info.Hash = hash.Hash;
return(info);
}
private static MIDIEvent_Length_Tuple next_event(ByteEnumerable track_data, int start_index, byte last_midi_channel)
{
var i = start_index - 1;
MidiEvent midi_event = null;
{
var delta_time = 0;
{
var length_temp = new ByteList();
do
{
i += 1;
length_temp.Add(track_data.ElementAt(i));
} while (track_data.ElementAt(i) > 0x7F);
delta_time = VariableLengthUtil.decode_to_int(length_temp);
}
i += 1;
var event_type_value = track_data.ElementAt(i);
// MIDI Channel Events
if ((event_type_value & 0xF0) < 0xF0)
{
var midi_channel_event_type = (byte)(event_type_value & 0xF0);
var midi_channel = (byte)(event_type_value & 0x0F);
i += 1;
var parameter_1 = track_data.ElementAt(i);
var parameter_2 = (byte)0x00;
// One or two parameter type
switch (midi_channel_event_type)
{
// One parameter types
case 0xC0:
midi_event = new ProgramChangeEvent(delta_time, midi_channel, parameter_1);
last_midi_channel = midi_channel;
break;
case 0xD0:
midi_event = new ChannelAftertouchEvent(delta_time, midi_channel, parameter_1);
last_midi_channel = midi_channel;
break;
// Two parameter types
case 0x80:
i += 1;
parameter_2 = track_data.ElementAt(i);
midi_event = new NoteOffEvent(delta_time, midi_channel, parameter_1, parameter_2);
last_midi_channel = midi_channel;
break;
case 0x90:
i += 1;
parameter_2 = track_data.ElementAt(i);
midi_event = new NoteOnEvent(delta_time, midi_channel, parameter_1, parameter_2);
last_midi_channel = midi_channel;
break;
case 0xA0:
i += 1;
parameter_2 = track_data.ElementAt(i);
midi_event = new NoteAftertouchEvent(delta_time, midi_channel, parameter_1, parameter_2);
last_midi_channel = midi_channel;
break;
case 0xB0:
i += 1;
parameter_2 = track_data.ElementAt(i);
midi_event = new ControllerEvent(delta_time, midi_channel, parameter_1, parameter_2);
last_midi_channel = midi_channel;
break;
case 0xE0:
i += 1;
parameter_2 = track_data.ElementAt(i);
midi_event = new PitchBendEvent(delta_time, midi_channel, parameter_1, parameter_2);
last_midi_channel = midi_channel;
break;
// Might be a Control Change Messages LSB
default:
midi_event = new ControllerEvent(delta_time, last_midi_channel, event_type_value, parameter_1);
break;
}
i += 1;
}
// Meta Events
else if (event_type_value == 0xFF)
{
i += 1;
var meta_event_type = track_data.ElementAt(i);
i += 1;
var meta_event_length = track_data.ElementAt(i);
i += 1;
var meta_event_data = Enumerable.Range(i, meta_event_length).Select(b => track_data.ElementAt(b)).ToArray();
switch (meta_event_type)
{
case 0x00:
midi_event = new SequenceNumberEvent(BitConverter.ToUInt16(meta_event_data.Reverse().ToArray <byte>(), 0));
break;
case 0x01:
midi_event = new TextEvent(delta_time, stringEncoder.GetString(meta_event_data));
break;
case 0x02:
midi_event = new CopyrightNoticeEvent(stringEncoder.GetString(meta_event_data));
break;
case 0x03:
midi_event = new SequenceOrTrackNameEvent(stringEncoder.GetString(meta_event_data));
break;
case 0x04:
midi_event = new InstrumentNameEvent(delta_time, stringEncoder.GetString(meta_event_data));
break;
case 0x05:
midi_event = new LyricsEvent(delta_time, stringEncoder.GetString(meta_event_data));
break;
case 0x06:
midi_event = new MarkerEvent(delta_time, stringEncoder.GetString(meta_event_data));
break;
case 0x07:
midi_event = new CuePointEvent(delta_time, stringEncoder.GetString(meta_event_data));
break;
case 0x20:
midi_event = new MIDIChannelPrefixEvent(delta_time, meta_event_data[0]);
break;
case 0x2F:
midi_event = new EndOfTrackEvent(delta_time);
break;
case 0x51:
var tempo =
(meta_event_data[2] & 0x0F) +
((meta_event_data[2] & 0xF0) * 16) +
((meta_event_data[1] & 0x0F) * 256) +
((meta_event_data[1] & 0xF0) * 4096) +
((meta_event_data[0] & 0x0F) * 65536) +
((meta_event_data[0] & 0xF0) * 1048576);
midi_event = new SetTempoEvent(delta_time, tempo);
break;
case 0x54:
midi_event = new SMPTEOffsetEvent(delta_time, meta_event_data[0], meta_event_data[1], meta_event_data[2], meta_event_data[3], meta_event_data[4]);
break;
case 0x58:
midi_event = new TimeSignatureEvent(delta_time, meta_event_data[0], meta_event_data[1], meta_event_data[2], meta_event_data[3]);
break;
case 0x59:
midi_event = new KeySignatureEvent(delta_time, meta_event_data[0], meta_event_data[1]);
break;
case 0x7F:
midi_event = new SequencerSpecificEvent(delta_time, meta_event_data);
break;
}
i += meta_event_length;
}
// System Exclusive Events
else if (event_type_value == 0xF0 || event_type_value == 0xF7)
{
var event_length = 0;
{
var length_temp = new ByteList();
do
{
i += 1;
length_temp.Add(track_data.ElementAt(i));
} while (track_data.ElementAt(i) > 0x7F);
event_length = VariableLengthUtil.decode_to_int(length_temp);
}
i += 1;
var event_data = Enumerable.Range(i, event_length).Select(b => track_data.ElementAt(b));
midi_event = new SysexEvent(delta_time, event_type_value, event_data);
i += event_length;
}
}
switch (midi_event != null)
{
case true:
return(new MIDIEvent_Length_Tuple(new SomeMidiEvent(midi_event), i - start_index, last_midi_channel));
}
return(new MIDIEvent_Length_Tuple(new NoMidiEvent(), i - start_index, last_midi_channel));
}
public static ushort ToUInt16(ReadOnlySpan <byte> value) => Converter.ToUInt16(value);
/// <summary>
/// 返回指定的字节数组中以指定位置的字节转换来的值
/// </summary>
/// <param name="buffer">来源字节数组</param>
/// <param name="offset">数据偏移</param>
/// <returns>值</returns>
public static ushort ToUInt16(this byte[] buffer, int offset)
{
return(BitConverter.ToUInt16(buffer, offset));
}
