public void PlayTestSong()
{
int stream = BassMidi.BASS_MIDI_StreamCreateFile("zumn.mid", 0, 0, 0, 0);
BassMidi.BASS_MIDI_StreamSetFonts(stream, Fonts, 1);
PlayInVolume(stream, true, volumeNote);
}
public void GetTags()
{
if (Program.mainWindow == null)
{
return;
}
try
{
if (Program.mainWindow.supportedModuleTypes.Contains(Path.GetExtension(filename).ToLower()))
{
Bass.BASS_Init(-1, 44100, BASSInit.BASS_DEVICE_DEFAULT, IntPtr.Zero);
int track = Bass.BASS_MusicLoad(filename, 0, 0, BASSFlag.BASS_MUSIC_NOSAMPLE | BASSFlag.BASS_MUSIC_PRESCAN, 0);
title = Bass.BASS_ChannelGetMusicName(track);
artist = Bass.BASS_ChannelGetMusicMessage(track);
length = (int)Bass.BASS_ChannelBytes2Seconds(track, (int)Bass.BASS_ChannelGetLength(track));
Bass.BASS_Free();
}
else if (Program.mainWindow.supportedMidiTypes.Contains(Path.GetExtension(filename).ToLower()))
{
Bass.BASS_Init(-1, 44100, BASSInit.BASS_DEVICE_DEFAULT, IntPtr.Zero);
int track = BassMidi.BASS_MIDI_StreamCreateFile(filename, 0, 0, BASSFlag.BASS_DEFAULT, 0);
title = Path.GetFileName(filename);
length = (int)Bass.BASS_ChannelBytes2Seconds(track, (int)Bass.BASS_ChannelGetLength(track));
Bass.BASS_Free();
}
else
{
TagLib.File tagFile = TagLib.File.Create(filename);
title = tagFile.Tag.Title;
if (tagFile.Tag.Performers.Length > 0)
{
artist = tagFile.Tag.Performers[0];
}
album = tagFile.Tag.Album;
//year = tagFile.Tag.Year+"";
//comment = tagFile.Tag.Comment;
length = (int)tagFile.Properties.Duration.TotalSeconds;
bitrate = tagFile.Properties.AudioBitrate;
tagFile.Dispose();
}
}
catch (Exception)
{
title = filename;
length = 0;
}
if (String.IsNullOrWhiteSpace(title))
{
title = Path.GetFileName(filename);
}
try
{
listened = Int32.Parse(Program.mainWindow.xmlCacher.GetListened(filename));
}
catch (Exception)
{
listened = 0;
}
}
public static long GetMIDILength(string str)
{
Bass.BASS_Init(0, 22050, BASSInit.BASS_DEVICE_NOSPEAKER, IntPtr.Zero);
Int32 time = BassMidi.BASS_MIDI_StreamCreateFile(str, 0L, 0L, BASSFlag.BASS_STREAM_DECODE, 0);
Bass.BASS_StreamFree(time);
Bass.BASS_Free();
return(Bass.BASS_ChannelGetLength(time));
}
private void InitializeBASSMIDIStream()
{
// Init stream
ChangePreviewButtonText("Initializing stream...", false);
ChangeWindowTitle("Initializing stream...");
hStream = BassMidi.BASS_MIDI_StreamCreateFile(MIDIPreview, 0L, 0L,
BASSFlag.BASS_SAMPLE_FLOAT |
BASSFlag.BASS_SAMPLE_SOFTWARE |
(Convert.ToBoolean(Program.SynthSettings.GetValue("EnableSFX", 0)) ? BASSFlag.BASS_DEFAULT : BASSFlag.BASS_MIDI_NOFX) |
(LoopYesNo.Checked ? BASSFlag.BASS_SAMPLE_LOOP : BASSFlag.BASS_DEFAULT),
0);
Bass.BASS_ChannelSetAttribute(hStream, BASSAttribute.BASS_ATTRIB_MIDI_CPU, (int)(Convert.ToInt32(Program.SynthSettings.GetValue("MaxRenderingTime", 75)) / 100));
System.Threading.Thread.Sleep(50);
// Init SoundFont
ChangePreviewButtonText("Loading SoundFont...", false);
ChangeWindowTitle("Loading SoundFont...");
BASS_MIDI_FONTEX[] fonts = new BASS_MIDI_FONTEX[1];
if (OriginalSF.ToLower().IndexOf('=') != -1)
{
var matches = System.Text.RegularExpressions.Regex.Matches(OriginalSF, "[0-9]+");
string sf = OriginalSF.Substring(OriginalSF.LastIndexOf('|') + 1);
fonts[0].font = BassMidi.BASS_MIDI_FontInit(sf);
fonts[0].spreset = Convert.ToInt32(matches[0].ToString());
fonts[0].sbank = Convert.ToInt32(matches[1].ToString());
fonts[0].dpreset = Convert.ToInt32(matches[2].ToString());
fonts[0].dbank = Convert.ToInt32(matches[3].ToString());
}
else
{
fonts[0].font = BassMidi.BASS_MIDI_FontInit(OriginalSF);
fonts[0].spreset = -1;
fonts[0].sbank = -1;
fonts[0].dpreset = -1;
fonts[0].dbank = 0;
}
BassMidi.BASS_MIDI_FontSetVolume(fonts[0].font, 1.0f);
BassMidi.BASS_MIDI_StreamSetFonts(hStream, fonts, 1);
BassMidi.BASS_MIDI_StreamLoadSamples(hStream);
}
private void InitializeBASSMIDIStream()
{
// Init stream
ChangePreviewButtonText("Initializing stream...", false);
ChangeWindowTitle("Initializing stream...");
hStream = BassMidi.BASS_MIDI_StreamCreateFile(MIDIPreview, 0L, 0L, BASSFlag.BASS_SAMPLE_FLOAT | BASSFlag.BASS_SAMPLE_SOFTWARE, 0);
Bass.BASS_ChannelSetAttribute(hStream, BASSAttribute.BASS_ATTRIB_MIDI_CPU, (int)(KeppySynthConfiguratorMain.Delegate.MaxCPU.Value / 100));
System.Threading.Thread.Sleep(50);
// Init SoundFont
ChangePreviewButtonText("Loading SoundFont...", false);
ChangeWindowTitle("Loading SoundFont...");
BASS_MIDI_FONTEX[] fonts = new BASS_MIDI_FONTEX[1];
List <int> termsList = new List <int>();
termsList.Reverse();
if (OriginalSF.ToLower().IndexOf('=') != -1)
{
var matches = System.Text.RegularExpressions.Regex.Matches(OriginalSF, "[0-9]+");
string sf = OriginalSF.Substring(OriginalSF.LastIndexOf('|') + 1);
fonts[0].font = BassMidi.BASS_MIDI_FontInit(sf);
fonts[0].spreset = Convert.ToInt32(matches[0].ToString());
fonts[0].sbank = Convert.ToInt32(matches[1].ToString());
fonts[0].dpreset = Convert.ToInt32(matches[2].ToString());
fonts[0].dbank = Convert.ToInt32(matches[3].ToString());
BassMidi.BASS_MIDI_FontSetVolume(fonts[0].font, 1.0f);
BassMidi.BASS_MIDI_StreamSetFonts(hStream, fonts, 1);
}
else
{
fonts[0].font = BassMidi.BASS_MIDI_FontInit(OriginalSF);
fonts[0].spreset = -1;
fonts[0].sbank = -1;
fonts[0].dpreset = -1;
fonts[0].dbank = 0;
BassMidi.BASS_MIDI_StreamSetFonts(hStream, fonts, 1);
}
BassMidi.BASS_MIDI_StreamLoadSamples(hStream);
}
public static void BASSStreamSystem(String str, Boolean PreviewMode)
{
try
{
MainWindow.KMCGlobals._recHandle = BassMidi.BASS_MIDI_StreamCreateFile(str, 0L, 0L,
BASSFlag.BASS_STREAM_DECODE |
(PreviewMode ? 0 : (Properties.Settings.Default.SincInter ? BASSFlag.BASS_MIDI_SINCINTER : 0)) |
BASSFlag.BASS_SAMPLE_FLOAT |
BASSFlag.BASS_SAMPLE_SOFTWARE |
BASSFlag.BASS_MIDI_DECAYEND,
0);
BASSCheckError();
if (PreviewMode)
{
MainWindow.KMCGlobals._myWasapi = new WASAPIPROC(MyWasapiProc);
BassWasapi.BASS_WASAPI_Init(-1, 0, 2, BASSWASAPIInit.BASS_WASAPI_EVENT, 0, 0, MainWindow.KMCGlobals._myWasapi, IntPtr.Zero);
BASSCheckError();
}
BASSInitializeChanAttributes();
BASSTempoAndFilter();
if (Path.GetFileNameWithoutExtension(str).Length >= 49)
{
MainWindow.KMCGlobals.NewWindowName = Path.GetFileNameWithoutExtension(str).Truncate(45);
}
else
{
MainWindow.KMCGlobals.NewWindowName = Path.GetFileNameWithoutExtension(str);
}
MainWindow.KMCGlobals._plm = new Un4seen.Bass.Misc.DSP_PeakLevelMeter(MainWindow.KMCGlobals._recHandle, 1);
MainWindow.KMCGlobals._plm.CalcRMS = true;
}
catch (Exception ex)
{
BASSCloseStreamException(ex);
}
}
private void OpenMIDIButton_Click(object sender, EventArgs e)
{
if (OpenMIDI.ShowDialog() == DialogResult.OK)
{
Bass.BASS_StreamFree(chan);
if (!IsWinXPOrOlder())
{
BassWasapi.BASS_WASAPI_Free();
WasapiProc = new WASAPIPROC(MyWasapiProc);
BassWasapi.BASS_WASAPI_Init(-1, 0, 2, BASSWASAPIInit.BASS_WASAPI_BUFFER | BASSWASAPIInit.BASS_WASAPI_SHARED, 0.5f, 0, WasapiProc, IntPtr.Zero);
}
LoopSyncProc = null;
LyricSyncProc = null;
EndSyncProc = null;
TempoSyncProc = null;
LyricsFromStream.Text = "";
if ((chan = BassMidi.BASS_MIDI_StreamCreateFile(OpenMIDI.FileName, 0L, 0L,
(IsWinXPOrOlder() ? BASSFlag.BASS_DEFAULT : (BASSFlag.BASS_STREAM_DECODE | BASSFlag.BASS_SAMPLE_FLOAT)) | BASSFlag.BASS_MIDI_DECAYEND | (RvAndChr.Checked ? BASSFlag.BASS_MIDI_NOFX : 0),
0)) == 0)
{
OpenMIDIButton.Text = "Click here to open a file...";
MIDITitle.Text = "";
Position.Text = "-";
Error("Can't play the file");
return;
}
Bass.BASS_ChannelSetAttribute(chan, BASSAttribute.BASS_ATTRIB_MIDI_VOICES, VoiceBar.Value); // apply to current MIDI file too
Bass.BASS_ChannelSetAttribute(chan, BASSAttribute.BASS_ATTRIB_MIDI_CPU, CPUBar.Value); // apply to current MIDI file too
OpenMIDIButton.Text = OpenMIDI.FileName;
{ // set the title (track name of first track)
BASS_MIDI_MARK mark = new BASS_MIDI_MARK();
if (BassMidi.BASS_MIDI_StreamGetMark(chan, BASSMIDIMarker.BASS_MIDI_MARK_TRACK, 0, mark) && mark.track == 0)
{
MIDITitle.Text = mark.text;
}
else
{
MIDITitle.Text = "";
}
}
TrackbarStream.Value = 0;
TrackbarStream.Minimum = 0;
TrackbarStream.Maximum = (int)Bass.BASS_ChannelGetLength(chan, BASSMode.BASS_POS_MIDI_TICK) / 120;
{ // set looping syncs
BASS_MIDI_MARK mark = new BASS_MIDI_MARK();
LoopSyncProc = new SYNCPROC(LoopSync);
if (FindMarker(chan, "loopend", mark)) // found a loop end point
{
Bass.BASS_ChannelSetSync(chan, BASSSync.BASS_SYNC_POS | BASSSync.BASS_SYNC_MIXTIME, mark.pos, LoopSyncProc, IntPtr.Zero); // set a sync there
}
Bass.BASS_ChannelSetSync(chan, BASSSync.BASS_SYNC_END | BASSSync.BASS_SYNC_MIXTIME, 0, LoopSyncProc, IntPtr.Zero); // set one at the end too (eg. in case of seeking past the loop point)
}
{ // clear lyrics buffer and set lyrics syncs
BASS_MIDI_MARK mark = new BASS_MIDI_MARK();
LyricSyncProc = new SYNCPROC(LyricSync);
EndSyncProc = new SYNCPROC(EndSync);
lyrics = "";
if (BassMidi.BASS_MIDI_StreamGetMark(chan, BASSMIDIMarker.BASS_MIDI_MARK_LYRIC, 0, mark)) // got lyrics
{
Bass.BASS_ChannelSetSync(chan, BASSSync.BASS_SYNC_MIDI_MARKER, (long)BASSMIDIMarker.BASS_MIDI_MARK_LYRIC, LyricSyncProc, (IntPtr)BASSMIDIMarker.BASS_MIDI_MARK_LYRIC);
}
else if (BassMidi.BASS_MIDI_StreamGetMark(chan, BASSMIDIMarker.BASS_MIDI_MARK_TEXT, 20, mark)) // got text instead (over 20 of them)
{
Bass.BASS_ChannelSetSync(chan, BASSSync.BASS_SYNC_MIDI_MARKER, (long)BASSMIDIMarker.BASS_MIDI_MARK_TEXT, LyricSyncProc, (IntPtr)BASSMIDIMarker.BASS_MIDI_MARK_TEXT);
}
Bass.BASS_ChannelSetSync(chan, BASSSync.BASS_SYNC_END, 0, EndSyncProc, IntPtr.Zero);
}
{ // override the initial tempo, and set a sync to override tempo events and another to override after seeking
SetTempo(true);
TempoSyncProc = new SYNCPROC(TempoSync);
Bass.BASS_ChannelSetSync(chan, BASSSync.BASS_SYNC_MIDI_EVENT | BASSSync.BASS_SYNC_MIXTIME, (long)BASSMIDIEvent.MIDI_EVENT_TEMPO, TempoSyncProc, IntPtr.Zero);
Bass.BASS_ChannelSetSync(chan, BASSSync.BASS_SYNC_SETPOS | BASSSync.BASS_SYNC_MIXTIME, 0, TempoSyncProc, IntPtr.Zero);
}
{ // get default soundfont in case of matching soundfont being used
BASS_MIDI_FONT[] sf = { new BASS_MIDI_FONT(font, fontp, fontb) };
// now set them
BassMidi.BASS_MIDI_StreamSetFonts(chan, sf, sf.Length);
}
}
Bass.BASS_ChannelSetAttribute(chan, BASSAttribute.BASS_ATTRIB_MIDI_CPU, 95);
if (PlayPauseBtn.Text != "Pause")
{
if (IsWinXPOrOlder())
{
Bass.BASS_ChannelPlay(chan, true);
}
else
{
BassWasapi.BASS_WASAPI_Start();
}
}
}
private static bool buildFileTimingBatch(string pMini2sfPath,
string p2sfFilePath, string pSseqFilePath)
{
bool isSuccess = false;
string arguments;
StreamWriter sw;
StringBuilder strReturn = new StringBuilder(128);
int minutes;
int seconds;
int midiStream;
string _2sfFileName = Path.GetFileName(p2sfFilePath);
string psfpointBatchFilePath = Path.Combine(Path.Combine(pMini2sfPath, "text"), PSFPOINT_BATCH_TXT);
if (!File.Exists(psfpointBatchFilePath))
{
sw = File.CreateText(psfpointBatchFilePath);
}
else
{
sw = new StreamWriter(File.Open(psfpointBatchFilePath, FileMode.Append, FileAccess.Write));
}
try
{
string midiFilePath = pSseqFilePath + ".mid";
if (File.Exists(midiFilePath))
{
// Bass.BASS_Init(-1, 44100, BASSInit.BASS_DEVICE_DEFAULT, IntPtr.Zero, null);
midiStream = BassMidi.BASS_MIDI_StreamCreateFile(midiFilePath, 0L, 0L, BASSFlag.BASS_DEFAULT, 0);
if (midiStream != 0)
{
// play the channel
long length = Bass.BASS_ChannelGetLength(midiStream);
double tlength = Bass.BASS_ChannelBytes2Seconds(midiStream, length);
minutes = (int)(tlength / 60);
seconds = (int)(tlength - (minutes * 60));
if (seconds > 59)
{
minutes++;
seconds -= 60;
}
}
else
{
// error
Console.Write(Environment.NewLine);
Console.WriteLine("Stream error: {0}", Bass.BASS_ErrorGetCode());
return(false);
}
// Do Fade
if (isLoopingTrack(pMini2sfPath, Path.GetFileName(pSseqFilePath)))
{
arguments = " -fade=\"10\" " + _2sfFileName;
if (minutes == 0 && seconds == 0)
{
seconds = 1;
}
}
else
{
arguments = " -fade=\"1\" " + _2sfFileName;
seconds++;
if (seconds > 60)
{
minutes++;
seconds -= 60;
}
}
// Add fade info to batch file
sw.WriteLine("psfpoint.exe" + arguments);
// Add length info to batch file
arguments = " -length=\"" + minutes + ":" + seconds.ToString().PadLeft(2, '0') + "\" " + _2sfFileName;
sw.WriteLine("psfpoint.exe" + arguments);
}
isSuccess = true;
}
catch (Exception e)
{
Console.WriteLine(String.Format("Error timing {0}: {1}", p2sfFilePath, e.Message));
}
finally
{
sw.Close();
sw.Dispose();
}
return(isSuccess);
}
private void FrameConverter_DoWork(object sender, DoWorkEventArgs e)
{
try
{
// Initialize BASS and variables
Bass.BASS_Init(0, 44100, BASSInit.BASS_DEVICE_NOSPEAKER, IntPtr.Zero);
Bass.BASS_SetConfig(BASSConfig.BASS_CONFIG_MIDI_VOICES, 0);
Data.StreamHandle = BassMidi.BASS_MIDI_StreamCreateFile(Data.MIDIToLoad, 0L, 0L, BASSFlag.BASS_MIDI_NOCROP | BASSFlag.BASS_STREAM_DECODE | BASSFlag.BASS_MIDI_DECAYEND, 0);
Data.PlayedNotesAvg = new List <Double>();
// Check if the MIDI file is valid
BASSError Error = Bass.BASS_ErrorGetCode();
if (Error == BASSError.BASS_ERROR_ILLPARAM ||
Error == BASSError.BASS_ERROR_FILEOPEN ||
Error == BASSError.BASS_ERROR_FILEFORM)
{
MessageBox.Show("Invalid MIDI file.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
Settings.Interrupt = true;
return;
}
Data.OsuemSize = Properties.Settings.Default.CounterFont.Size;
Int64 StreamLength = Bass.BASS_ChannelGetLength(Data.StreamHandle);
Int32 ChunkLength = Convert.ToInt32(Bass.BASS_ChannelSeconds2Bytes(Data.StreamHandle, FFMPEGProcess.Hertz));
Byte[] Buffer;
// Initialize played notes sync
Data.NoteSync = new SYNCPROC(NoteSyncProc);
Bass.BASS_ChannelSetSync(Data.StreamHandle, BASSSync.BASS_SYNC_MIDI_EVENT, (long)BASSMIDIEvent.MIDI_EVENT_NOTE, Data.NoteSync, IntPtr.Zero);
// Initialize time signature sync
BassMidi.BASS_MIDI_StreamGetMark(Data.StreamHandle, BASSMIDIMarker.BASS_MIDI_MARK_TIMESIG, 0, Data.Mark);
Data.TimeSigSync = new SYNCPROC(TimeSigSyncProc);
Bass.BASS_ChannelSetSync(Data.StreamHandle, BASSSync.BASS_SYNC_MIDI_TIMESIG, (long)BASSMIDIMarker.BASS_MIDI_MARK_TIMESIG, Data.TimeSigSync, IntPtr.Zero);
// Initialize note count
Data.TotalNotes = Convert.ToUInt32(BassMidi.BASS_MIDI_StreamGetEvents(Data.StreamHandle, -1, (BASSMIDIEvent)0x20000, null));
Data.HowManyZeroesNotes = String.Concat(Enumerable.Repeat("0", Data.TotalNotes.ToString().Length));
// Initialize conversion
if (!StartConversion(Data.MIDIToLoad))
{
return;
}
FPSUpdate();
if (Properties.Settings.Default.StillFramesBeginning)
{
for (int a = 0; a <= (Properties.Settings.Default.FPSExport * 5); a++)
{
// 5 seconds of nothing
if (Settings.Interrupt == true)
{
break;
}
CheckPosition();
Data.NotesPerSecond = "0";
PushFrame(false);
FFMPEGProcess.Frames++;
FPSUpdate();
}
}
while (Bass.BASS_ChannelIsActive(Data.StreamHandle) == BASSActive.BASS_ACTIVE_PLAYING)
{
if (Data.OsuemSize > Properties.Settings.Default.CounterFont.Size)
{
Data.OsuemSize -= (Properties.Settings.Default.CounterFont.Size / 24);
if (Data.OsuemSize < Properties.Settings.Default.CounterFont.Size)
{
Data.OsuemSize = Properties.Settings.Default.CounterFont.Size;
}
}
else
{
Data.OsuemSize = Properties.Settings.Default.CounterFont.Size;
}
if (Settings.Interrupt == true)
{
break;
}
Buffer = new Byte[ChunkLength];
Bass.BASS_ChannelGetData(Data.StreamHandle, Buffer, ChunkLength);
CheckPosition();
if (FFMPEGProcess.Frames % (ulong)Properties.Settings.Default.FPSExport == 0)
{
Data.NotesPerSecond = Data.PlayedNotesFrame.ToString();
Data.PlayedNotesAvg.Add(Data.PlayedNotesFrame);
Data.AverageNotesPerSecond = Data.PlayedNotesAvg.Average().ToString("0.0");
Data.PlayedNotesFrame = 0;
}
PushFrame(false);
FFMPEGProcess.Frames++;
FPSUpdate();
}
Buffer = new Byte[ChunkLength];
Bass.BASS_ChannelGetData(Data.StreamHandle, Buffer, ChunkLength);
if (Properties.Settings.Default.StillFramesEnd)
{
for (int a = 0; a <= (Properties.Settings.Default.FPSExport * 5); a++)
{
if (Data.OsuemSize > Properties.Settings.Default.CounterFont.Size)
{
Data.OsuemSize -= (Properties.Settings.Default.CounterFont.Size / 24);
if (Data.OsuemSize < Properties.Settings.Default.CounterFont.Size)
{
Data.OsuemSize = Properties.Settings.Default.CounterFont.Size;
}
}
else
{
Data.OsuemSize = Properties.Settings.Default.CounterFont.Size;
}
// 5 seconds of nothing
if (Settings.Interrupt == true)
{
break;
}
CheckPosition();
Data.NotesPerSecond = "0";
PushFrame(false);
FFMPEGProcess.Frames++;
FPSUpdate();
}
}
for (int i = 0; i < Data.PlayedNotesChan.Length; i++)
{
Data.PlayedNotesChan[i] = 0;
}
Data.Mark = new BASS_MIDI_MARK();
FFMPEGProcess.Frames = 0;
FFMPEGProcess.FFMPEG.StandardInput.Close();
Bass.BASS_StreamFree(Data.StreamHandle);
Bass.BASS_Free();
Settings.Interrupt = false;
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
}
}
public static string[] GetMoreInfoMIDI(string str)
{
try
{
// Get size of MIDI
long length = new System.IO.FileInfo(str).Length;
string size;
try
{
if (length / 1024f >= 1000000000)
{
size = ((((length / 1024f) / 1024f) / 1024f) / 1024f).ToString("0.0 TiB");
}
else if (length / 1024f >= 1000000)
{
size = (((length / 1024f) / 1024f) / 1024f).ToString("0.0 GiB");
}
else if (length / 1024f >= 1000)
{
size = ((length / 1024f) / 1024f).ToString("0.0 MiB");
}
else if (length / 1024f >= 1)
{
size = (length / 1024f).ToString("0.0 KiB");
}
else
{
size = (length).ToString("0 B");
}
}
catch { size = "-"; }
Bass.BASS_Init(0, 4000, BASSInit.BASS_DEVICE_NOSPEAKER, IntPtr.Zero);
Int32 time = BassMidi.BASS_MIDI_StreamCreateFile(str, 0L, 0L, BASSFlag.BASS_STREAM_DECODE, 0);
if (time == 0)
{
return(null);
}
Int64 pos = Bass.BASS_ChannelGetLength(time);
Double num9 = Bass.BASS_ChannelBytes2Seconds(time, pos);
TimeSpan span = TimeSpan.FromSeconds(num9);
// Get length of MIDI
string Length = span.Minutes.ToString() + ":" + span.Seconds.ToString().PadLeft(2, '0') + "." + span.Milliseconds.ToString().PadLeft(3, '0');
UInt64 count = 0;
Int32 Tracks = BassMidi.BASS_MIDI_StreamGetTrackCount(time);
for (int i = 0; i < Tracks; i++)
{
count += (UInt32)BassMidi.BASS_MIDI_StreamGetEvents(time, i, BASSMIDIEvent.MIDI_EVENT_NOTES, null);
}
Bass.BASS_Free();
return(new string[] {
Length,
String.Format(System.Globalization.CultureInfo.InvariantCulture, "{0:N0}", Tracks),
String.Format(System.Globalization.CultureInfo.InvariantCulture, "{0:N0}", count),
size
});
}
catch
{
MessageBox.Show(String.Format(Languages.Parse("NoEnoughMemoryParseInfo"), str), Languages.Parse("Error"), MessageBoxButtons.OK, MessageBoxIcon.Information);
return(new string[] { Languages.Parse("NA"), Languages.Parse("NA"), Languages.Parse("NA"), Languages.Parse("NA") });
}
}
public static void BASSStreamSystemRT(String str, Boolean PreviewMode)
{
try
{
MainWindow.KMCGlobals._recHandle = BassMidi.BASS_MIDI_StreamCreateFile(str, 0L, 0L, BASSFlag.BASS_STREAM_DECODE | BASSFlag.BASS_SAMPLE_FLOAT, 0);
BASSCheckError();
BASS_MIDI_EVENT[] eventChunk;
try
{
// Thank you so much Falcosoft for helping me there!!!
// Visit his website: http://falcosoft.hu/index.html#start
MainWindow.KMCGlobals.eventc = (UInt32)BassMidi.BASS_MIDI_StreamGetEvents(MainWindow.KMCGlobals._recHandle, -1, 0, null); // Counts all the events in the MIDI
MainWindow.KMCGlobals.events = new BASS_MIDI_EVENT[MainWindow.KMCGlobals.eventc]; // Creates an array with the events count as size
for (int i = 0; i <= (MainWindow.KMCGlobals.eventc / 50000000); i++)
{
int subCount = Math.Min(50000000, (int)MainWindow.KMCGlobals.eventc - (i * 50000000));
eventChunk = new BASS_MIDI_EVENT[subCount];
BassMidi.BASS_MIDI_StreamGetEvents(MainWindow.KMCGlobals._recHandle, -1, 0, eventChunk, i * 50000000, subCount); //Falcosoft: to avoid marshalling errors pass the smaller local buffer to the function
eventChunk.CopyTo(MainWindow.KMCGlobals.events, i * 50000000); //Falcosoft: copy local buffer to global one at each iteration
}
eventChunk = null;
}
catch
{
BASSCloseStreamException(new MIDILoadError("This MIDI is too big for the real-time conversion process.\n\nMake sure you're using the 64-bit version of the converter."));
}
Bass.BASS_StreamFree(MainWindow.KMCGlobals._recHandle);
MainWindow.KMCGlobals._recHandle = BassMidi.BASS_MIDI_StreamCreate(16,
BASSFlag.BASS_STREAM_DECODE |
(PreviewMode ? 0 : (Properties.Settings.Default.SincInter ? BASSFlag.BASS_MIDI_SINCINTER : 0)) |
BASSFlag.BASS_SAMPLE_FLOAT |
BASSFlag.BASS_SAMPLE_SOFTWARE,
0);
BASSCheckError();
if (PreviewMode)
{
BASS_WASAPI_DEVICEINFO infoDW = new BASS_WASAPI_DEVICEINFO();
BassWasapi.BASS_WASAPI_Init(-1, 0, 2, BASSWASAPIInit.BASS_WASAPI_BUFFER, 0, 0, null, IntPtr.Zero);
BassWasapi.BASS_WASAPI_GetDevice();
BassWasapi.BASS_WASAPI_GetDeviceInfo(BassWasapi.BASS_WASAPI_GetDevice(), infoDW);
BassWasapi.BASS_WASAPI_Free();
BassWasapi.BASS_WASAPI_Init(-1, infoDW.mixfreq, 2, BASSWASAPIInit.BASS_WASAPI_SHARED, infoDW.minperiod, 0, null, IntPtr.Zero);
BASSCheckError();
}
BASSInitializeChanAttributes();
BASSTempoAndFilter();
if (Path.GetFileNameWithoutExtension(str).Length >= 49)
{
MainWindow.KMCGlobals.NewWindowName = Path.GetFileNameWithoutExtension(str).Truncate(45);
}
else
{
MainWindow.KMCGlobals.NewWindowName = Path.GetFileNameWithoutExtension(str);
}
MainWindow.KMCGlobals._plm = new Un4seen.Bass.Misc.DSP_PeakLevelMeter(MainWindow.KMCGlobals._recHandle, 1);
MainWindow.KMCGlobals._plm.CalcRMS = true;
}
catch (Exception ex)
{
BASSCloseStreamException(ex);
}
}
