private void GUI_FormClosing(object sender, FormClosingEventArgs e)
{
logger.Info("Shutdown");
Settings.Default.Save();
if (waveReader != null)
{
waveReader.Dispose();
}
if (waveOut != null)
{
waveOut.Dispose();
}
}
// SOUND
// Play Sound
public void playSound(HKSound sound)
{
if (waveOut != null)
{
debugLog("[Sound] Disposed");
waveOut.Dispose();
}
waveOut = new WaveOut();
waveOut.DeviceNumber = selectedDevice;
checkSoundState.Stop();
debugLog("[Action] Sound " + sound.filename);
// VorbisWaveReader is not in AudioFileReader but is a ISampleProvider
if (sound.extension == ".ogg")
{
if (currentOGG != null)
{
currentOGG.Dispose();
}
currentOGG = new VorbisWaveReader(sound.completeFilename);
waveOut.Init(currentOGG);
waveOut.Play();
waveOut.Volume = sound.volume;
checkSoundState.Start();
currentSound = sound;
debugLog("[Sound] Volume : " + sound.volume);
debugLog("[Sound] OGG Start");
}
else if (".mp3.mp4.wav".Contains(sound.extension))
{
if (audioFile != null)
{
audioFile.Dispose();
}
audioFile = new AudioFileReader(sound.completeFilename);
waveOut.Init(audioFile);
waveOut.Play();
waveOut.Volume = sound.volume;
checkSoundState.Start();
currentSound = sound;
debugLog("[Sound] Volume : " + sound.volume);
debugLog("[Sound] MP3/MP4/WAV Start");
}
else
{
debugLog("[Sound] Not MP3, MP4 nor WAV");
}
}
private void OnPlaybackStopped(object sender, StoppedEventArgs args)
{
outputDevice.Dispose();
outputDevice = null;
audioFile.Dispose();
audioFile = null;
}
public static void PlayOGGAudioFiles(int BusType, int BusNumber, int audioIndex)
{
VorbisWaveReader vorbisStream = new VorbisWaveReader(BGMfiles[audioIndex]);
try
{
vorbisStream.Dispose();
waveOut.Dispose();
vorbisStream = new VorbisWaveReader(BGMfiles[audioIndex]);
switch (BusType)
{
//BGM
case 0:
waveOut.Init(vorbisStream);
waveOut.Play();
break;
//SFX
case 1:
waveOut.Init(vorbisStream);
waveOut.Play();
break;
}
}
catch (Exception)
{
throw;
}
}
public void Dispose()
{
AudioManager.audioSources.Remove(name);
output.Dispose();
waveChannel.Dispose();
reader.Dispose();
}
private void OnPlaybackStopped(object sender, EventArgs e)
{
_waveOut.PlaybackStopped -= OnPlaybackStopped;
_waveOut = null;
_vorbisReader.Dispose();
_vorbisReader = null;
}
public static async void PlaySound(string sound, bool loop)
{
Logger.WriteLine($"attempting to play sound: {sound}");
try
{
// gc isn't happy rn
// create wave out event and initialize it with the vorbis wave reader
using (WaveOutEvent waveOut = new WaveOutEvent())
{
// create vorbis wave reader
using (VorbisWaveReader v = new VorbisWaveReader($"{Static.audioPath}\\{sound}.ogg"))
{
// also create a loop stream and initialize the wave out event with the loop stream instead of loop is true
using (LoopStream loopStream = new LoopStream(v))
{
if (loop)
{
waveOut.Init(loopStream);
}
else
{
waveOut.Init(v);
}
// flush and dispose the streams after playback stops
void Dispose(object sender, StoppedEventArgs e)
{
v.Flush();
v.Dispose();
waveOut.Dispose();
loopStream.Flush();
loopStream.Dispose();
}
waveOut.PlaybackStopped += Dispose;
// play
waveOut.Play();
// add the wave out event to the active audio list so it can be stopped manually
activeAudio.Add(waveOut);
// wait the duration of the sound
await Task.Delay(v.TotalTime);
}
}
}
}
catch (Exception ex)
{
ExceptionMessage.New(ex, true);
}
}
public void StopSong()
{
if (audioFile != null)
{
audioFile.Dispose();
audioFile = null;
}
if (oggReader != null)
{
oggReader.Dispose();
oggReader = null;
}
audioOutput.Stop();
}
private void CleanUp()
{
if (outputDevice != null)
{
outputDevice.Stop();
outputDevice.Dispose();
outputDevice = null;
}
if (vorbis != null)
{
vorbis.Dispose();
vorbis = null;
}
}
public int Read(float[] buffer, int offset, int count)
{
if (isDisposed)
{
return(0);
}
int read = reader.Read(buffer, offset, count);
if (read == 0)
{
reader.Dispose();
isDisposed = true;
}
return(read);
}
public int Read(float[] buffer, int offset, int count)
{
if (_reader == null)
{
return(0);
}
var read = _reader.Read(buffer, offset, count);
if (read == 0)
{
_reader.Dispose();
_reader = null;
}
return(read);
}
public void CleanUp()
{
if (vorbisWaveReader != null)
{
vorbisWaveReader.Dispose();
vorbisWaveReader = null;
}
if (wavePlayer != null)
{
wavePlayer.Dispose();
wavePlayer = null;
}
if (stream != null)
{
stream.Dispose();
stream = null;
}
}
public void PlayVorbis(int index, params string[] names)
{
if (soundInstances < 4 && index < names.Length)
{
string filename = Path.Combine(Environment.CurrentDirectory, string.Concat(names[index], ".ogg"));
if (!File.Exists(filename))
{
return;
}
var vorbisStream = new VorbisWaveReader(filename);
var waveOut = new WaveOutEvent();
Thread currentSound = new Thread(delegate()
{
soundHandle.Reset();
waveOut.Init(vorbisStream);
waveOut.Play();
SpinWait.SpinUntil(() => waveOut.PlaybackState == PlaybackState.Stopped);
waveOut.Dispose();
vorbisStream.Dispose();
if (index + 1 < names.Length)
{
PlayVorbis(index + 1, names);
}
else
{
soundHandle.Set();
}
soundInstances--;
});
currentSound.IsBackground = true;
currentSound.Start();
soundInstances++;
}
}
private IWaveProvider GetOggWaveProvider()
{
Logger.Info($"Reading Ogg @ {opts.File}");
var oggReader = new VorbisWaveReader(opts.File);
int bytes = (int)oggReader.Length;
byte[] buffer = new byte[bytes];
Logger.Info($"Read Ogg - Sample Rate {oggReader.WaveFormat.SampleRate}");
if (oggReader.WaveFormat.SampleRate < INPUT_SAMPLE_RATE)
{
Logger.Error($"Ogg Sample rate must be at least 16000 but is {oggReader.WaveFormat.SampleRate} - Quitting. Use Audacity or another tool to resample as 16000 or Higher");
Environment.Exit(1);
}
int read = oggReader.Read(buffer, 0, (int)bytes);
BufferedWaveProvider bufferedWaveProvider = new BufferedWaveProvider(oggReader.WaveFormat)
{
BufferLength = read * 2,
ReadFully = false,
DiscardOnBufferOverflow = true
};
bufferedWaveProvider.AddSamples(buffer, 0, read);
VolumeSampleProvider volumeSample =
new VolumeSampleProvider(bufferedWaveProvider.ToSampleProvider())
{
Volume = opts.Volume
};
oggReader.Close();
oggReader.Dispose();
Logger.Info($"Convert to Mono 16bit PCM");
//after this we've got 16 bit PCM Mono - just need to sort sample rate
return(volumeSample.ToMono().ToWaveProvider16());
}
public void Stop(bool clearCurrentSongString = true)
{
if (waveOut != null)
{
waveOut.Stop();
waveOut.Dispose();
}
if (channel != null)
{
channel.Dispose();
}
if (waveReader != null)
{
waveReader.Dispose();
}
if (clearCurrentSongString)
{
currentSong = "";
}
}
public AudioConvertError Convert(int?loopStart, int?loopEnd, VorbisWaveReader oggFile, out byte[] convertedData)
{
var meta = new VorbisReader(oggFile);
var volume = 1.0f;
var numChannels = meta.Channels;
var sampleRate = meta.SampleRate;
loopStart = loopStart ?? 0;
loopEnd = loopEnd ?? (int)oggFile.Length;
MemoryStream scd = CreateSCDHeader((int)oggFile.Length, volume, numChannels, sampleRate, (int)loopStart, (int)loopEnd);
scd.Seek(0, SeekOrigin.End);
oggFile.CopyTo(scd);
scd.Seek(0, SeekOrigin.Begin);
convertedData = scd.ToArray();
scd.Dispose();
oggFile.Dispose();
return(AudioConvertError.None);
}
public void ReadData(string path)
{
ProgressWindow progress = new ProgressWindow();
progress.Show();
if (wavOutput != null)
{
wavOutput.Dispose();
}
if (wavFile != null)
{
wavFile.Dispose();
}
if (vorbisFile != null)
{
vorbisFile.Dispose();
}
textureDisplay.Image = null;
spriteDisplay.Image = null;
loadedAudio = new byte[] { };
isOgg = false;
audioList.Nodes.Clear();
texList.Items.Clear();
spriteList.Items.Clear();
audioList.BeginUpdate();
texList.BeginUpdate();
spriteList.BeginUpdate();
TXTR.Clear();
AudioGroupList.Clear();
SPRTList.Clear();
STRGList.Clear();
stringList.Items.Clear();
this.Enabled = false;
this.Cursor = Cursors.WaitCursor;
BinaryReader reader = null;
string file = "";
if (!path.EndsWith(".exe"))
{
if (File.Exists(path + "\\data.win"))
{
file = path + "\\data.win";
}
else if (File.Exists(path + "\\game.win"))
{
file = path + "\\game.win";
}
}
else
{
progress.SetText("Searching for data.win...");
reader = new BinaryReader(new FileStream(path, FileMode.Open));
bool found = false;
while (reader.BaseStream.Position < reader.BaseStream.Length - 4)
{
long pos = reader.BaseStream.Position;
byte[] FORMmagic = reader.ReadBytes(4);
if (FORMmagic.SequenceEqual(new byte[] { 0x46, 0x4F, 0x52, 0x4D }))
{
uint fileLength = reader.ReadUInt32() + 8;
byte[] GEN8magic = reader.ReadBytes(4);
if (GEN8magic.SequenceEqual(new byte[] { 0x47, 0x45, 0x4E, 0x38 }))
{
reader.BaseStream.Seek(pos, SeekOrigin.Begin);
if (Directory.Exists(@"C:\gmetemp"))
{
Directory.Delete(@"C:\gmetemp", true);
}
Directory.CreateDirectory(@"C:\gmetemp");
File.WriteAllBytes(@"C:\gmetemp\tmp.win", reader.ReadBytes((int)fileLength));
file = @"C:\gmetemp\tmp.win";
found = true;
break;
}
}
}
if (!found)
{
progress.Close();
MessageBox.Show("Unable to find data.win");
return;
}
}
reader = new BinaryReader(new FileStream(file, FileMode.Open));
int texOffset = 0x8;
reader.BaseStream.Seek(0x3C, SeekOrigin.Begin);
uint version = reader.ReadUInt32();
reader.BaseStream.Seek(0x38, SeekOrigin.Begin);
uint projnameoffset = reader.ReadUInt32();
reader.BaseStream.Seek(projnameoffset - 4, SeekOrigin.Begin);
string projname = Encoding.UTF8.GetString(reader.ReadBytes(reader.ReadInt32()));
if (version == 1)
{
texOffset = 0x4;
}
this.Text = "GM2Explorer - Reading game " + projname;
progress.SetText("Finding next section...");
//Begin asset search
reader.BaseStream.Seek(0, SeekOrigin.Begin);
//Start at FORM
reader.BaseStream.Seek(8, SeekOrigin.Current);
//GEN8
reader.BaseStream.Seek(4, SeekOrigin.Current);
uint sectLen = reader.ReadUInt32();
reader.BaseStream.Seek(sectLen, SeekOrigin.Current);
//OPTN
if (Encoding.UTF8.GetString(reader.ReadBytes(4)) == "OPTN")
{
sectLen = reader.ReadUInt32();
reader.BaseStream.Seek(sectLen, SeekOrigin.Current);
}
else
{
reader.BaseStream.Seek(-0x4, SeekOrigin.Current);
}
//LANG
if (Encoding.UTF8.GetString(reader.ReadBytes(4)) == "LANG")
{
sectLen = reader.ReadUInt32();
reader.BaseStream.Seek(sectLen, SeekOrigin.Current);
}
else
{
reader.BaseStream.Seek(-0x4, SeekOrigin.Current);
}
//EXTN
if (Encoding.UTF8.GetString(reader.ReadBytes(4)) == "EXTN")
{
sectLen = reader.ReadUInt32();
reader.BaseStream.Seek(sectLen, SeekOrigin.Current);
}
else
{
reader.BaseStream.Seek(-0x4, SeekOrigin.Current);
}
//SOND
reader.BaseStream.Seek(4, SeekOrigin.Current);
sectLen = reader.ReadUInt32();
uint sondOffs = (uint)reader.BaseStream.Position;
reader.BaseStream.Seek(sectLen, SeekOrigin.Current);
//AGRP
progress.SetText("Reading AGRP Section...");
reader.BaseStream.Seek(4, SeekOrigin.Current);
sectLen = reader.ReadUInt32();
uint currentOffset = (uint)reader.BaseStream.Position;
uint entryCount = reader.ReadUInt32();
uint entryListStart = (uint)reader.BaseStream.Position;
List <uint> entryOffsets = new List <uint>();
progress.SetProgressValue(0);
progress.SetProgressMax((int)entryCount);
for (int i = 0; i < entryCount; i++)
{
entryOffsets.Add(reader.ReadUInt32());
}
for (int i = 0; i < entryCount; i++)
{
progress.SetProgressValue(i);
progress.SetText($"Reading AGRP Section... {i}/{entryCount} - {(int)(((float)i/(float)entryCount)*100)}");
AudioGroup _audo = new AudioGroup();
_audo.fileNames = new List <string>();
_audo.files = new List <byte[]>();
reader.BaseStream.Seek(entryOffsets[i], SeekOrigin.Begin);
uint nameOffset = reader.ReadUInt32();
reader.BaseStream.Seek(nameOffset - 4, SeekOrigin.Begin);
string groupName = Encoding.UTF8.GetString(reader.ReadBytes(reader.ReadInt32()));
_audo.name = groupName;
AudioGroupList.Add(_audo);
}
if (entryCount == 0)
{
AudioGroup _audo = new AudioGroup();
_audo.fileNames = new List <string>();
_audo.files = new List <byte[]>();
_audo.name = "audiogroup_default";
AudioGroupList.Add(_audo);
}
//Jump back to SOND and fill out the data
reader.BaseStream.Seek(sondOffs, SeekOrigin.Begin);
progress.SetText("Reading SOND Section...");
entryCount = reader.ReadUInt32();
entryListStart = (uint)reader.BaseStream.Position;
entryOffsets = new List <uint>();
progress.SetProgressValue(0);
progress.SetProgressMax((int)entryCount);
for (int i = 0; i < entryCount; i++)
{
entryOffsets.Add(reader.ReadUInt32());
}
for (int i = 0; i < entryCount; i++)
{
progress.SetProgressValue(i);
progress.SetText($"Reading SOND Section... {i}/{entryCount} - {(int)(((float)i / (float)entryCount) * 100)}");
reader.BaseStream.Seek(entryOffsets[i], SeekOrigin.Begin);
uint nameOffset = reader.ReadUInt32();
long pos = reader.BaseStream.Position;
reader.BaseStream.Seek(nameOffset - 4, SeekOrigin.Begin);
string audioName = Encoding.UTF8.GetString(reader.ReadBytes(reader.ReadInt32()));
reader.BaseStream.Seek(pos + 0x18, SeekOrigin.Begin);
int groupIndex = reader.ReadInt32();
int audioIndex = reader.ReadInt32();
if (audioIndex != -1)
{
AudioGroup _audo = AudioGroupList[groupIndex];
if (_audo.fileNames.Count < audioIndex + 1)
{
_audo.fileNames.AddRange(new string[(audioIndex + 1) - _audo.fileNames.Count]);
}
_audo.fileNames[audioIndex] = audioName;
AudioGroupList[groupIndex] = _audo;
}
}
reader.BaseStream.Seek(currentOffset, SeekOrigin.Begin);
reader.BaseStream.Seek(sectLen, SeekOrigin.Current);
//SPRT
progress.SetText("Reading SPRT Section...");
reader.BaseStream.Seek(4, SeekOrigin.Current);
sectLen = reader.ReadUInt32();
currentOffset = (uint)reader.BaseStream.Position;
uint spriteCount = reader.ReadUInt32();
progress.SetProgressValue(0);
progress.SetProgressMax((int)spriteCount);
List <uint> spriteOffsets = new List <uint>();
for (int i = 0; i < spriteCount; i++)
{
spriteOffsets.Add(reader.ReadUInt32());
}
for (int i = 0; i < spriteCount; i++)
{
progress.SetProgressValue(i);
progress.SetText($"Reading SPRT section... {i}/{spriteCount} - {(int)(((float)i / (float)spriteCount) * 100)}");
SPRT sprt = new SPRT();
sprt.x = new List <ushort>();
sprt.y = new List <ushort>();
sprt.width = new List <ushort>();
sprt.height = new List <ushort>();
sprt.sheet = new List <ushort>();
reader.BaseStream.Seek(spriteOffsets[i], SeekOrigin.Begin);
uint nameOffset = reader.ReadUInt32();
reader.BaseStream.Seek(0x34, SeekOrigin.Current);
if (version == 2)
{
reader.BaseStream.Seek(0x14, SeekOrigin.Current);
}
uint texCount = reader.ReadUInt32();
List <uint> texOffsets = new List <uint>();
List <Bitmap> sprites = new List <Bitmap>();
for (int t = 0; t < texCount; t++)
{
texOffsets.Add(reader.ReadUInt32());
}
for (int t = 0; t < texCount; t++)
{
reader.BaseStream.Seek(texOffsets[t], SeekOrigin.Begin);
sprt.x.Add(reader.ReadUInt16());
sprt.y.Add(reader.ReadUInt16());
sprt.width.Add(reader.ReadUInt16());
sprt.height.Add(reader.ReadUInt16());
reader.BaseStream.Seek(0xC, SeekOrigin.Current);
sprt.sheet.Add(reader.ReadUInt16());
}
reader.BaseStream.Seek(nameOffset - 4, SeekOrigin.Begin);
string name = Encoding.UTF8.GetString(reader.ReadBytes(reader.ReadInt32()));
sprt.name = name;
SPRTList.Add(sprt);
}
reader.BaseStream.Seek(currentOffset, SeekOrigin.Begin);
reader.BaseStream.Seek(sectLen, SeekOrigin.Current);
progress.SetText("Finding next Section...");
//BGND
if (Encoding.UTF8.GetString(reader.ReadBytes(4)) == "BGND")
{
sectLen = reader.ReadUInt32();
reader.BaseStream.Seek(sectLen, SeekOrigin.Current);
}
else
{
reader.BaseStream.Seek(-0x4, SeekOrigin.Current);
}
//PATH
if (Encoding.UTF8.GetString(reader.ReadBytes(4)) == "PATH")
{
sectLen = reader.ReadUInt32();
reader.BaseStream.Seek(sectLen, SeekOrigin.Current);
}
else
{
reader.BaseStream.Seek(-0x4, SeekOrigin.Current);
}
//SCPT
if (Encoding.UTF8.GetString(reader.ReadBytes(4)) == "SCPT")
{
sectLen = reader.ReadUInt32();
reader.BaseStream.Seek(sectLen, SeekOrigin.Current);
}
else
{
reader.BaseStream.Seek(-0x4, SeekOrigin.Current);
}
//GLOB
if (Encoding.UTF8.GetString(reader.ReadBytes(4)) == "GLOB")
{
sectLen = reader.ReadUInt32();
reader.BaseStream.Seek(sectLen, SeekOrigin.Current);
}
else
{
reader.BaseStream.Seek(-0x4, SeekOrigin.Current);
}
//SHDR
if (Encoding.UTF8.GetString(reader.ReadBytes(4)) == "SHDR")
{
sectLen = reader.ReadUInt32();
reader.BaseStream.Seek(sectLen, SeekOrigin.Current);
}
else
{
reader.BaseStream.Seek(-0x4, SeekOrigin.Current);
}
//FONT
if (Encoding.UTF8.GetString(reader.ReadBytes(4)) == "FONT")
{
sectLen = reader.ReadUInt32();
reader.BaseStream.Seek(sectLen, SeekOrigin.Current);
}
else
{
reader.BaseStream.Seek(-0x4, SeekOrigin.Current);
}
//TMLN
if (Encoding.UTF8.GetString(reader.ReadBytes(4)) == "TMLN")
{
sectLen = reader.ReadUInt32();
reader.BaseStream.Seek(sectLen, SeekOrigin.Current);
}
else
{
reader.BaseStream.Seek(-0x4, SeekOrigin.Current);
}
//OBJT
if (Encoding.UTF8.GetString(reader.ReadBytes(4)) == "OBJT")
{
sectLen = reader.ReadUInt32();
reader.BaseStream.Seek(sectLen, SeekOrigin.Current);
}
else
{
reader.BaseStream.Seek(-0x4, SeekOrigin.Current);
}
//ROOM
if (Encoding.UTF8.GetString(reader.ReadBytes(4)) == "ROOM")
{
sectLen = reader.ReadUInt32();
reader.BaseStream.Seek(sectLen, SeekOrigin.Current);
}
else
{
reader.BaseStream.Seek(-0x4, SeekOrigin.Current);
}
//DAFL
if (Encoding.UTF8.GetString(reader.ReadBytes(4)) == "DAFL")
{
sectLen = reader.ReadUInt32();
reader.BaseStream.Seek(sectLen, SeekOrigin.Current);
}
else
{
reader.BaseStream.Seek(-0x4, SeekOrigin.Current);
}
//EMBI
if (Encoding.UTF8.GetString(reader.ReadBytes(4)) == "EMBI")
{
sectLen = reader.ReadUInt32();
reader.BaseStream.Seek(sectLen, SeekOrigin.Current);
}
else
{
reader.BaseStream.Seek(-0x4, SeekOrigin.Current);
}
//TPAG
if (Encoding.UTF8.GetString(reader.ReadBytes(4)) == "TPAG")
{
sectLen = reader.ReadUInt32();
reader.BaseStream.Seek(sectLen, SeekOrigin.Current);
}
else
{
reader.BaseStream.Seek(-0x4, SeekOrigin.Current);
}
//TGIN
if (Encoding.UTF8.GetString(reader.ReadBytes(4)) == "TGIN")
{
sectLen = reader.ReadUInt32();
reader.BaseStream.Seek(sectLen, SeekOrigin.Current);
}
else
{
reader.BaseStream.Seek(-0x4, SeekOrigin.Current);
}
//CODE
if (Encoding.UTF8.GetString(reader.ReadBytes(4)) == "CODE")
{
sectLen = reader.ReadUInt32();
reader.BaseStream.Seek(sectLen, SeekOrigin.Current);
}
else
{
reader.BaseStream.Seek(-0x4, SeekOrigin.Current);
}
//VARI
if (Encoding.UTF8.GetString(reader.ReadBytes(4)) == "VARI")
{
sectLen = reader.ReadUInt32();
reader.BaseStream.Seek(sectLen, SeekOrigin.Current);
}
else
{
reader.BaseStream.Seek(-0x4, SeekOrigin.Current);
}
//FUNC
if (Encoding.UTF8.GetString(reader.ReadBytes(4)) == "FUNC")
{
sectLen = reader.ReadUInt32();
reader.BaseStream.Seek(sectLen, SeekOrigin.Current);
}
else
{
reader.BaseStream.Seek(-0x4, SeekOrigin.Current);
}
//STRG
reader.BaseStream.Seek(4, SeekOrigin.Current);
sectLen = reader.ReadUInt32();
currentOffset = (uint)reader.BaseStream.Position;
if (MessageBox.Show("Do you want to load the STRG (strings) section?\nNote: This will take a lot longer and will take up a lot more RAM", "GM2Explorer", MessageBoxButtons.YesNo) == DialogResult.Yes)
{
progress.SetText("Reading STRG Section...");
uint stringCount = reader.ReadUInt32();
progress.SetProgressValue(0);
progress.SetProgressMax((int)stringCount);
for (int i = 0; i < stringCount; i++)
{
progress.SetProgressValue(i);
progress.SetText($"Reading STRG section... {i}/{stringCount} - {(int)(((float)i / (float)stringCount) * 100)}");
uint pos = (uint)reader.BaseStream.Position;
reader.BaseStream.Seek(reader.ReadUInt32(), SeekOrigin.Begin);
//Console.WriteLine($"{i}: 0x{pos.ToString("X8")} >> 0x{reader.BaseStream.Position.ToString("X8")}");
STRGList.Add(Encoding.UTF8.GetString(reader.ReadBytes(reader.ReadInt32())));
reader.BaseStream.Seek(pos + 4, SeekOrigin.Begin);
}
}
reader.BaseStream.Seek(currentOffset, SeekOrigin.Begin);
reader.BaseStream.Seek(sectLen, SeekOrigin.Current);
//TXTR
progress.SetText("Reading TXTR Section...");
reader.BaseStream.Seek(4, SeekOrigin.Current);
sectLen = reader.ReadUInt32();
currentOffset = (uint)reader.BaseStream.Position;
uint sectionEndOffset = currentOffset + sectLen;
uint fileCount = reader.ReadUInt32();
uint fileListStart = (uint)reader.BaseStream.Position;
progress.SetProgressValue(0);
progress.SetProgressMax((int)fileCount);
List <uint> fileOffsets = new List <uint>();
for (int f = 0; f < fileCount; f++)
{
uint pos = (uint)reader.BaseStream.Position;
reader.BaseStream.Seek(reader.ReadUInt32() + texOffset, SeekOrigin.Begin);
fileOffsets.Add(reader.ReadUInt32());
reader.BaseStream.Seek(pos + 4, SeekOrigin.Begin);
}
for (int f = 0; f < fileOffsets.Count; f++)
{
progress.SetProgressValue(f);
progress.SetText($"Reading TXTR section... {f}/{fileCount} - {(int)(((float)f / (float)fileCount) * 100)}");
reader.BaseStream.Seek(fileOffsets[f], SeekOrigin.Begin);
byte[] tex = new byte[] { };
if (f == fileOffsets.Count - 1)
{
tex = reader.ReadBytes((int)(sectionEndOffset - fileOffsets[f]));
}
else
{
tex = reader.ReadBytes((int)(fileOffsets[f + 1] - fileOffsets[f]));
}
try
{
MemoryStream stream = new MemoryStream(tex);
Image img = Image.FromStream(stream);
TXTR.Add(new Bitmap(img));
stream.Dispose();
img.Dispose();
}
catch { }
}
fileOffsets.Clear();
reader.BaseStream.Seek(currentOffset, SeekOrigin.Begin);
reader.BaseStream.Seek(sectLen, SeekOrigin.Current);
//AUDO
progress.SetText("Reading AUDO Section...");
reader.BaseStream.Seek(4, SeekOrigin.Current);
sectLen = reader.ReadUInt32();
AudioGroup audo = AudioGroupList[0];
//Console.WriteLine("Found AUDO Section at 0x" + currentOffset.ToString("X8"));
fileCount = reader.ReadUInt32();
fileListStart = (uint)reader.BaseStream.Position;
progress.SetProgressValue(0);
progress.SetProgressMax((int)fileCount);
fileOffsets = new List <uint>();
for (int f = 0; f < fileCount; f++)
{
uint audoDataOffset = reader.ReadUInt32();
fileOffsets.Add(audoDataOffset);
}
for (int f = 0; f < fileOffsets.Count; f++)
{
progress.SetProgressValue(f);
progress.SetText($"Reading TXTR section... {f}/{fileCount} - {(int)(((float)f / (float)fileCount) * 100)}");
reader.BaseStream.Seek(fileOffsets[f], SeekOrigin.Begin);
//Console.WriteLine("Reading audio " + f + " at offset 0x" + fileOffsets[f].ToString("X8"));
List <byte> audio = new List <byte>();
uint fileLength = reader.ReadUInt32();
audio.AddRange(reader.ReadBytes((int)fileLength));
audo.files.Add(audio.ToArray());
audio.Clear();
}
AudioGroupList[0] = audo;
fileOffsets.Clear();
reader.Dispose();
progress.SetProgressValue(0);
progress.SetText("Reading AudioGroups...");
if (path.EndsWith(".exe"))
{
path = path.Replace("\\" + path.Split('\\').Last(), "");
}
string[] audiogroups = Directory.GetFiles(path, "audiogroup*.dat");
progress.SetProgressMax(audiogroups.Length);
for (int i = 0; i < audiogroups.Length; i++)
{
progress.SetProgressValue(i);
progress.SetText($"Reading TXTR section... {i}/{audiogroups.Length} - {(int)(((float)i / (float)audiogroups.Length) * 100)}");
this.Text = "GM2Explorer - Reading \"" + path + "\\" + audiogroups[i].Replace(path + "\\", "") + "\"";
reader = new BinaryReader(new FileStream(audiogroups[i], FileMode.Open));
reader.BaseStream.Seek(0x10, SeekOrigin.Begin);
audo = AudioGroupList[i + 1];
audo.files = new List <byte[]>();
//Console.WriteLine("Found AUDO Section at 0x" + currentOffset.ToString("X8"));
fileCount = reader.ReadUInt32();
fileListStart = (uint)reader.BaseStream.Position;
fileOffsets = new List <uint>();
for (int f = 0; f < fileCount; f++)
{
uint audoDataOffset = reader.ReadUInt32();
fileOffsets.Add(audoDataOffset);
}
for (int f = 0; f < fileOffsets.Count; f++)
{
reader.BaseStream.Seek(fileOffsets[f], SeekOrigin.Begin);
//Console.WriteLine("Reading audio " + f + " at offset 0x" + fileOffsets[f].ToString("X8"));
List <byte> audio = new List <byte>();
uint fileLength = reader.ReadUInt32();
audio.AddRange(reader.ReadBytes((int)fileLength));
audo.files.Add(audio.ToArray());
audio.Clear();
}
AudioGroupList[i + 1] = audo;
}
reader.Dispose();
texList.BeginUpdate();
spriteList.BeginUpdate();
audioList.BeginUpdate();
stringList.BeginUpdate();
for (int i = 0; i < TXTR.Count; i++)
{
texList.Items.Add("tex_" + i);
}
for (int i = 0; i < SPRTList.Count; i++)
{
spriteList.Items.Add(SPRTList[i].name);
}
for (int i = 0; i < AudioGroupList.Count; i++)
{
audioList.Nodes.Add(AudioGroupList[i].name);
for (int a = 0; a < AudioGroupList[i].files.Count; a++)
{
if (AudioGroupList[i].fileNames[a] != "")
{
audioList.Nodes[i].Nodes.Add(AudioGroupList[i].fileNames[a]);
}
else
{
audioList.Nodes[i].Nodes.Add("audio_" + a);
}
}
}
for (int i = 0; i < STRGList.Count; i++)
{
stringList.Items.Add(STRGList[i]);
}
texList.EndUpdate();
spriteList.EndUpdate();
audioList.EndUpdate();
stringList.EndUpdate();
file = "";
reader.Dispose();
sNum.Maximum = TXTR.Count - 1;
this.Text = "GM2Explorer";
this.Cursor = Cursors.Default;
this.Enabled = true;
this.BringToFront();
audioList.EndUpdate();
texList.EndUpdate();
spriteList.EndUpdate();
if (Directory.Exists(@"C:\gmetemp"))
{
Directory.Delete(@"C:\gmetemp", true);
}
progress.Close();
}
private static void ConvertSound(Sound sound)
{
if (!sound.HasStartFile && !sound.HasStartFile)
{
return;
}
FileInfo outFile = CurrentDirectory.GetDirectory("out").GetFile($"{sound.Name}.{Arguments.Format.ToString().ToLower()}");
if (!Arguments.Overwrite && outFile.Exists)
{
return;
}
FileInfo tempWave = new FileInfo(Path.GetTempFileName());
WaveReader reader = new WaveReader();
AudioData audio = null;
Console.WriteLine($"Processing {sound.Name}...");
if (sound.HasStartFile && !sound.HasLoopFile)
{
using (VorbisWaveReader vorbisStart = new VorbisWaveReader(GameSounds.GetFile(sound.StartFileName).FullName))
{
WaveFileWriter.CreateWaveFile(tempWave.FullName, vorbisStart.ToWaveProvider16());
}
using (FileStream stream = tempWave.OpenRead())
{
audio = reader.Read(stream);
}
}
else if (sound.HasStartFile && sound.HasLoopFile)
{
VorbisWaveReader vorbisStart = new VorbisWaveReader(GameSounds.GetFile(sound.StartFileName).FullName);
VorbisWaveReader vorbisLoop = new VorbisWaveReader(GameSounds.GetFile(sound.LoopFileName).FullName);
if (vorbisStart.WaveFormat.SampleRate < vorbisLoop.WaveFormat.SampleRate)
{
MediaFoundationResampler sampeler = new MediaFoundationResampler(vorbisStart, vorbisLoop.WaveFormat.SampleRate);
WaveFileWriter.CreateWaveFile(tempWave.FullName, sampeler.ToSampleProvider().FollowedBy(vorbisLoop).ToWaveProvider16());
}
else if (vorbisStart.WaveFormat.SampleRate > vorbisLoop.WaveFormat.SampleRate)
{
MediaFoundationResampler sampeler = new MediaFoundationResampler(vorbisLoop, vorbisStart.WaveFormat.SampleRate);
WaveFileWriter.CreateWaveFile(tempWave.FullName, vorbisStart.FollowedBy(sampeler.ToSampleProvider()).ToWaveProvider16());
}
else
{
WaveFileWriter.CreateWaveFile(tempWave.FullName, vorbisStart.FollowedBy(vorbisLoop).ToWaveProvider16());
}
VorbisReader dataStart = new VorbisReader(GameSounds.GetFile(sound.StartFileName).FullName);
VorbisReader dataLoop = new VorbisReader(GameSounds.GetFile(sound.LoopFileName).FullName);
int startLoop = (int)dataStart.TotalSamples;
int endLoop = (int)dataStart.TotalSamples + (int)dataLoop.TotalSamples;
vorbisStart.Dispose();
vorbisLoop.Dispose();
dataStart.Dispose();
dataLoop.Dispose();
using (FileStream stream = tempWave.OpenRead())
{
audio = reader.Read(stream);
}
audio.SetLoop(true, startLoop, endLoop);
}
else if (!sound.HasStartFile && sound.HasLoopFile)
{
VorbisWaveReader vorbisLoop = new VorbisWaveReader(GameSounds.GetFile(sound.LoopFileName).FullName);
WaveFileWriter.CreateWaveFile(tempWave.FullName, vorbisLoop.ToWaveProvider16());
VorbisReader dataLoop = new VorbisReader(GameSounds.GetFile(sound.LoopFileName).FullName);
int totalSamples = (int)dataLoop.TotalSamples;
vorbisLoop.Dispose();
dataLoop.Dispose();
audio = reader.Read(tempWave.OpenRead());
audio.SetLoop(true, 0, totalSamples);
}
if (audio != null)
{
BCFstmWriter writer = new BCFstmWriter(Arguments.Target);
writer.Configuration.Codec = Arguments.Codec;
writer.Configuration.Endianness = Arguments.Endianness;
using (FileStream stream = outFile.OpenWrite())
{
writer.WriteToStream(audio, stream);
}
}
}
public int Read(byte[] buffer, int offset, int count)
{
if (count % bytesPerSample != 0)
{
count = (count / bytesPerSample) * bytesPerSample;
}
lock (this)
{
for (int i = 0; i < count;)
{
if (reader.Length - reader.Position <= count - i)
{
i += reader.Read(buffer, offset + i, (int)reader.Length - (int)reader.Position);
reader.Position = loopFrom;
}
else
{
i += reader.Read(buffer, offset + i, count - i);
}
}
#region 淡入淡出
if (preReader != null)
{
if (UseSmoothSwitchWhenPause)
{
unsafe
{
if (buffer1 == null || buffer1.Length < count)
{
buffer1 = new byte[count];
}
for (int i = 0; i < count;)
{
if (preReader.Length - preReader.Position <= count - i)
{
i += preReader.Read(buffer1, i, (int)preReader.Length - (int)preReader.Position);
preReader.Position = preLoopFrom;
}
else
{
i += preReader.Read(buffer1, i, count - i);
}
}
float al, ar, bl, br;
fixed(byte *pa = buffer)
{
fixed(byte *pb = buffer1)
{
float *fpa = (float *)(pa + offset);
float *fpb = (float *)pb;
int end = count / bytesPerSample * 2;
float x;
for (int i = 0; i < end; i += 2)
{
al = fpa[i];
ar = fpa[i + 1];
bl = fpb[i];
br = fpb[i + 1];
x = (i + 1) * 1.0f / end;
fpa[i] = al * x + bl * (1 - x);
fpa[i + 1] = ar * x + br * (1 - x);
}
}
}
}
}
preReader.Dispose();
preFile.Dispose();
preReader = null;
preFile = null;
UseSmoothSwitchWhenPause = true;
}
#endregion
}
return(count);
}
