internal static void seekTo(int milliseconds)
{
if (milliseconds < 0)
{
milliseconds = 0;
}
else if (milliseconds > AudioLength)
{
milliseconds = AudioLength;
}
if (AudioState != AudioStates.Stopped)
{
if (Math.Abs(milliseconds - Time) > 200)
{
Bass.BASS_ChannelSetPosition(audioStream, (float)(milliseconds + Offset) / 1000);
}
AudioState = AudioStates.Seeking;
}
else
{
cachedSeek = milliseconds + Offset;
}
//Time = milliseconds;
UpdateAudioTime();
}
// Token: 0x060000B5 RID: 181 RVA: 0x0001A734 File Offset: 0x00018934
public void method_36(float float_1)
{
if (!this.isSongLoaded)
{
return;
}
this.PauseSong();
if (float_1 < 0f)
{
float_1 = 0f;
}
if ((double)float_1 > this.double_1)
{
this.bool_2 = true;
return;
}
this.bool_2 = false;
for (int i = 0; i < this.stemChannels.Length; i++)
{
if (this.stemChannels[i] != 0)
{
long num = Bass.BASS_ChannelGetLength(this.stemChannels[i]);
if (Bass.BASS_ChannelSeconds2Bytes(this.stemChannels[i], (double)float_1) < num)
{
Bass.BASS_ChannelSetPosition(this.stemChannels[i], (double)float_1);
}
}
}
}
//-----------------------------------------------------------------------------------------------
//ファイルを再生する
//-----------------------------------------------------------------------------------------------
public bool PlaySound(string fileName, int vol = 255, bool isLoop = false, double second = 0)
{
StopSound();
playHandle = GetHandle(fileName);
//if ((Bass.BASS_ChannelFlags(playHandle, BASSFlag.BASS_DEFAULT, BASSFlag.BASS_DEFAULT) & BASSFlag.BASS_SAMPLE_LOOP) == BASSFlag.BASS_SAMPLE_LOOP)
if (isLoop == false)
{
// loop flag was set, so remove it
Bass.BASS_ChannelFlags(playHandle, BASSFlag.BASS_DEFAULT, BASSFlag.BASS_SAMPLE_LOOP);
}
else
{
// loop flag was not set, so set it
Bass.BASS_ChannelFlags(playHandle, BASSFlag.BASS_SAMPLE_LOOP, BASSFlag.BASS_SAMPLE_LOOP);
}
Bass.BASS_ChannelPlay(playHandle, false);
// int syncHandle = Bass.BASS_ChannelSetSync(playHandle, BASSSync.BASS_SYNC_END, 0, proc, IntPtr.Zero);
// if (syncHandle == 0) throw new InvalidOperationException("cannot set sync");
Bass.BASS_ChannelSetPosition(playHandle, second);
SetVolume(vol);
//ret = Bass.BASS_ChannelGetLength(playHandle);
m_length = Bass.BASS_ChannelBytes2Seconds(playHandle, Bass.BASS_ChannelGetLength(playHandle));
return(true);
}
public void Play(List <string> albumTracksUrls)
{
if (Bass.BASS_Init(-1, 44100, BASSInit.BASS_DEVICE_DEFAULT, IntPtr.Zero))
{
int stream1 = Bass.BASS_StreamCreateURL(albumTracksUrls[0], 0, BASSFlag.BASS_SAMPLE_MONO, null, IntPtr.Zero);
int stream2 = Bass.BASS_StreamCreateURL(albumTracksUrls[1], 0, BASSFlag.BASS_SAMPLE_MONO, null, IntPtr.Zero);
int stream3 = Bass.BASS_StreamCreateURL(albumTracksUrls[2], 0, BASSFlag.BASS_SAMPLE_MONO, null, IntPtr.Zero);
Bass.BASS_ChannelSetPosition(stream1, Bass.BASS_ChannelSeconds2Bytes(stream1, 0.01), BASSMode.BASS_POS_BYTES);
Bass.BASS_ChannelSlideAttribute(stream1, BASSAttribute.BASS_ATTRIB_VOL, 0, 0);
Bass.BASS_ChannelPlay(stream1, false);
VolumeUpSlow(stream1);
Bass.BASS_ChannelSlideAttribute(stream1, BASSAttribute.BASS_ATTRIB_VOL, 0, 3000);//volume down
Thread.Sleep(2500);
Bass.BASS_ChannelSetPosition(stream2, Bass.BASS_ChannelSeconds2Bytes(stream2, 0.5), BASSMode.BASS_POS_BYTES);
Bass.BASS_ChannelSlideAttribute(stream2, BASSAttribute.BASS_ATTRIB_VOL, 0, 0);
Bass.BASS_ChannelPlay(stream2, false);
Bass.BASS_StreamFree(stream1);
VolumeUpSlow(stream2);
Thread.Sleep(3000);
Bass.BASS_ChannelSlideAttribute(stream2, BASSAttribute.BASS_ATTRIB_VOL, 0, 3000);//volume down
Bass.BASS_ChannelSlideAttribute(stream3, BASSAttribute.BASS_ATTRIB_VOL, 0, 0);
Bass.BASS_ChannelPlay(stream3, false);
VolumeUpSlow(stream3);
Bass.BASS_StreamFree(stream2);
Thread.Sleep(5000);
Bass.BASS_ChannelSlideAttribute(stream3, BASSAttribute.BASS_ATTRIB_VOL, 0, 3000);//volume down
Thread.Sleep(3000);
Bass.BASS_StreamFree(stream3);
// free BASS
Bass.BASS_Free();
}
}
public static void BASSPlayBackEngine(Int64 length, Int64 pos)
{
if (MainWindow.Seeking)
{
BassMidi.BASS_MIDI_StreamEvent(MainWindow.KMCGlobals._recHandle, 0, BASSMIDIEvent.MIDI_EVENT_NOTESOFF, 0);
BassVst.BASS_VST_ProcessEvent(MainWindow.VSTs._VSTiHandle, 0, BASSMIDIEvent.MIDI_EVENT_NOTESOFF, 0);
Bass.BASS_ChannelSetPosition(MainWindow.KMCGlobals._recHandle, MainWindow.CurrentSeek, BASSMode.BASS_POS_MIDI_TICK);
MainWindow.Seeking = false;
return;
}
Int32 tempo = BassMidi.BASS_MIDI_StreamGetEvent(MainWindow.KMCGlobals._recHandle, 0, BASSMIDIEvent.MIDI_EVENT_TEMPO);
MainWindow.KMCGlobals.OriginalTempo = 60000000 / tempo;
Bass.BASS_ChannelFlags(MainWindow.KMCGlobals._recHandle, Properties.Settings.Default.DisableEffects ? BASSFlag.BASS_MIDI_NOFX : 0, BASSFlag.BASS_MIDI_NOFX);
Bass.BASS_ChannelFlags(MainWindow.KMCGlobals._recHandle, Properties.Settings.Default.NoteOff1 ? BASSFlag.BASS_MIDI_NOTEOFF1 : 0, BASSFlag.BASS_MIDI_NOTEOFF1);
for (Int32 i = 0; i <= 15; i++)
{
BassMidi.BASS_MIDI_StreamEvent(MainWindow.KMCGlobals._recHandle, i, BASSMIDIEvent.MIDI_EVENT_MIXLEVEL, MainWindow.KMCStatus.ChannelsVolume[i]);
}
MainWindow.KMCGlobals._VolFXParam.fCurrent = 1.0f;
MainWindow.KMCGlobals._VolFXParam.fTarget = Properties.Settings.Default.Volume;
MainWindow.KMCGlobals._VolFXParam.fTime = 0.0f;
MainWindow.KMCGlobals._VolFXParam.lCurve = 0;
Bass.BASS_FXSetParameters(MainWindow.KMCGlobals._VolFX, MainWindow.KMCGlobals._VolFXParam);
Bass.BASS_ChannelSetAttribute(MainWindow.KMCGlobals._recHandle, BASSAttribute.BASS_ATTRIB_MIDI_VOICES, Properties.Settings.Default.Voices);
}
public void Stop()
{
this._positionInByte = 0L;
Bass.BASS_ChannelSetPosition(this._stream, this._positionInByte);
Bass.BASS_StreamFree(this._stream);
this._stream = 0;
}
public void SetPosition(int seconds)
{
if (_deviceReady && _handle != 0 && GetTrackLength() >= seconds)
{
Bass.BASS_ChannelSetPosition(_handle, (double)seconds);
}
}
public void SetCurrentStreamPosition(double value)
{
if (ActiveStreamHandle != 0)
{
Bass.BASS_ChannelSetPosition(ActiveStreamHandle, value);
}
}
private static void TransferBytes(int channel, long startByte, long endByte)
{
var totalTransferLength = endByte - startByte;
Bass.BASS_ChannelSetPosition(channel, startByte, BASSMode.BASS_POS_BYTES);
while (totalTransferLength > 0)
{
var buffer = new byte[65536];
var transferLength = totalTransferLength;
if (transferLength > buffer.Length)
{
transferLength = buffer.Length;
}
// get the decoded sample data
var transferred = Bass.BASS_ChannelGetData(channel, buffer, (int)transferLength);
if (transferred < 1)
{
break; // error or the end
}
totalTransferLength -= transferred;
}
}
private void SliderTrack_ValueChanged(object sender, RoutedPropertyChangedEventArgs <double> e)
{
if (!(Math.Abs(e.NewValue - e.OldValue) <= 1.1))
{
Bass.BASS_ChannelSetPosition(Stream, SliderTrack.Value);
}
}
private Bitmap DrawSpectrogram(string fileName, int height, int stepsPerSecond, IntPtr Handle)
{
Bass.BASS_Init(-1, 44100, BASSInit.BASS_DEVICE_DEFAULT, Handle);
int channel = Bass.BASS_StreamCreateFile(fileName, 0, 0, BASSFlag.BASS_DEFAULT);
long len = Bass.BASS_ChannelGetLength(channel, BASSMode.BASS_POS_BYTES); // the length in bytes
double time = Bass.BASS_ChannelBytes2Seconds(channel, len); // the length in seconds
int steps = (int)Math.Floor(stepsPerSecond * time);
Bitmap result = new Bitmap(steps, height);
Graphics g = Graphics.FromImage(result);
Visuals visuals = new Visuals();
Bass.BASS_ChannelPlay(channel, false);
for (int i = 0; i < steps; i++)
{
Bass.BASS_ChannelSetPosition(channel, 1.0 * i / stepsPerSecond);
visuals.CreateSpectrum3DVoicePrint(channel, g, new Rectangle(0, 0, result.Width, result.Height), Color.Black, Color.White, i, true, true);
}
Bass.BASS_ChannelStop(channel);
Bass.BASS_Stop();
Bass.BASS_Free();
return(result);
}
/// <summary>
/// Sets the current stream position in samples.
/// </summary>
/// <param name="position">Number of samples to set the current position to.</param>
public void SetSamplePosition(long position)
{
if (!Bass.BASS_ChannelSetPosition(Handle, position * BassConstants.FloatBytes))
{
CheckException("BASS_ChannelSetPosition");
}
}
public int ChangeSpeed(int chan, string loc, float speed)
{
// get position to resume playback at
long pos = Bass.BASS_ChannelGetPosition(chan, BASSMode.BASS_POS_BYTES);
if (!Bass.BASS_StreamFree(chan))
{
GetBassErrorTrow("Could not free stream: " + chan);
}
chan = OpenFile(loc, BASSFlag.BASS_STREAM_DECODE | BASSFlag.BASS_SAMPLE_FLOAT);
chan = BassFx.BASS_FX_TempoCreate(chan, BASSFlag.BASS_SAMPLE_LOOP);
if (chan == 0)
{
GetBassErrorTrow("Could not open file: " + loc);
}
if (!Bass.BASS_ChannelSetPosition(chan, pos, BASSMode.BASS_POS_BYTES))
{
GetBassErrorTrow("Could not seek to " + pos + " bytes");
}
if (!Bass.BASS_ChannelSetAttribute(chan, BASSAttribute.BASS_ATTRIB_TEMPO, CheckTempoRange(speed) - 100))
{
GetBassErrorTrow("Could not set attribute: " + BASSAttribute.BASS_ATTRIB_TEMPO);
}
return(chan);
}
/// <summary>
/// This function makes sure your default device is being used, if not, reload Bass and the song back and continue as if nothing happened.
/// </summary>
private void CheckDevice()
{
if (!BassManager.CheckDevice(streamID))
{
var pos = Bass.BASS_ChannelGetPosition(streamID, BASSMode.BASS_POS_BYTES);
var secs = TimeSpan.FromSeconds(Bass.BASS_ChannelBytes2Seconds(streamID, pos));
var state = Bass.BASS_ChannelIsActive(streamID);
var volume = 0.3f;
Bass.BASS_ChannelGetAttribute(streamID, BASSAttribute.BASS_ATTRIB_VOL, ref volume);
BassManager.Reload();
Load(lastFile);
Volume = volume;
CurrentTime = secs;
switch (state)
{
case BASSActive.BASS_ACTIVE_PAUSED:
case BASSActive.BASS_ACTIVE_STOPPED:
Bass.BASS_ChannelPause(streamID);
Bass.BASS_ChannelSetPosition(streamID, pos, BASSMode.BASS_POS_BYTES);
break;
case BASSActive.BASS_ACTIVE_STALLED:
case BASSActive.BASS_ACTIVE_PLAYING:
Bass.BASS_ChannelPlay(streamID, false);
break;
}
}
}
private void ProcSync(int handle, int channel, int data, IntPtr user)
{
if (!Bass.BASS_ChannelSetPosition(channel, startPos, BASSMode.BASS_POS_BYTES))// try seeking to loop start
{
//Bass.BASS_ChannelSetPosition(channel, 0, BASSMode.BASS_POS_BYTES); // failed, go to start of file instead
}
}
public void Stop()
{
CheckDevice();
Bass.BASS_ChannelStop(streamID);
Bass.BASS_ChannelSetPosition(streamID, 0, BASSMode.BASS_POS_BYTES);
}
public void SetPosition(int iPositionInSecond)
{
double pos = System.Convert.ToDouble(iPositionInSecond);
this._positionInByte = Bass.BASS_ChannelSeconds2Bytes(this._stream, pos);
Bass.BASS_ChannelSetPosition(this._stream, this._positionInByte);
}
private void MainProgressBar_MouseUp(object sender, System.Windows.Input.MouseButtonEventArgs e)
{
if (_stream != 0)
{
Bass.BASS_ChannelSetPosition(_stream, (double)MainProgressBar.Value);
}
}
public void SetPosition(double position)
{
Bass.BASS_ChannelPause(_stream);
Bass.BASS_ChannelSetPosition(_stream, position);
Bass.BASS_ChannelPlay(_stream, false);
vm.AudioPosition = position;
}
public void skipToPostition(double percent)
{
long len = Bass.BASS_ChannelGetLength(Stream, BASSMode.BASS_POS_BYTES);
long bytesPos = (len * (long)percent) / 100;
Bass.BASS_ChannelSetPosition(Stream, bytesPos);
}
async void Position_Change()
{
while (Visibility == Visibility.Visible)
{
if (IsEnded)
{
await Task.Delay(500);
Bass.BASS_ChannelPause(Stream);
Bass.BASS_ChannelSetPosition(Stream, 0, BASSMode.BASS_POS_BYTES);
IsPaused = true;
IsEnded = false;
Location_S.Value = 0;
Location_T.Text = "00:00";
}
if (Bass.BASS_ChannelIsActive(Stream) == BASSActive.BASS_ACTIVE_PLAYING && !IsLocationChanging)
{
long position = Bass.BASS_ChannelGetPosition(Stream);
Location_S.Value = Bass.BASS_ChannelBytes2Seconds(Stream, position);
TimeSpan Time = TimeSpan.FromSeconds(Location_S.Value);
string Minutes = Time.Minutes.ToString();
string Seconds = Time.Seconds.ToString();
if (Time.Minutes < 10)
{
Minutes = "0" + Time.Minutes;
}
if (Time.Seconds < 10)
{
Seconds = "0" + Time.Seconds;
}
Location_T.Text = Minutes + ":" + Seconds;
}
await Task.Delay(100);
}
}
public void Pause()
{
var pos = Bass.BASS_ChannelGetPosition(streamID, BASSMode.BASS_POS_BYTES);
Bass.BASS_ChannelPause(streamID);
Bass.BASS_ChannelSetPosition(streamID, pos, BASSMode.BASS_POS_BYTES);
}
public void StopSample(int _stream)
{
if (_stream != 0)
{
Bass.BASS_SampleStop(_stream);
Bass.BASS_ChannelSetPosition(Bass.BASS_SampleGetChannel(_stream, false), 0);
}
}
/// <summary>
/// Sets the current playback position
/// </summary>
/// <param name="position">The desired position, in percent (0 - 1)</param>
public void SetPosition(double position)
{
if (streamHandle != 0)
{
var channelLength = Bass.BASS_ChannelGetLength(streamHandle, 0);
Bass.BASS_ChannelSetPosition(streamHandle, (long)(position * channelLength));
}
}
private void MainProgressBar_DragCompleted(object sender, System.Windows.Controls.Primitives.DragCompletedEventArgs e)
{
if (_stream != 0)
{
_maintimer.Start();
}
Bass.BASS_ChannelSetPosition(_stream, (double)MainProgressBar.Value);
}
/// <summary>
/// 再生位置を変更する
/// </summary>
/// <param name="ms"></param>
public void setPosition(uint ms)
{
if (sound[PlayerController.MainChannel] != 0)
{
long position = Bass.BASS_ChannelSeconds2Bytes(sound[PlayerController.MainChannel], (double)((double)ms / 1000));
Bass.BASS_ChannelSetPosition(sound[PlayerController.MainChannel], position);
}
}
internal static void checkCachedSeek()
{
if (cachedSeek >= 0)
{
Bass.BASS_ChannelSetPosition(audioStream, (float)(cachedSeek - Offset) / 1000);
cachedSeek = -1;
}
}
public void StopStream(int _stream)
{
if (_stream != 0)
{
Bass.BASS_ChannelStop(_stream);
Bass.BASS_ChannelSetPosition(_stream, 0);
}
}
public void PlaySample(Sample sample)
{
BassMix.BASS_Mixer_ChannelPause(sample.Channel);
Bass.BASS_ChannelSetPosition(sample.Channel, 1);
BassMix.BASS_Mixer_ChannelPlay(sample.Channel);
}
internal static void Stop()
{
Time = 0;
cachedSeek = -1;
Bass.BASS_ChannelSetPosition(audioStream, 0);
Bass.BASS_ChannelStop(audioStream);
AudioState = AudioStates.Stopped;
}
