static void Main(string[] args)
{
Un4seen.Bass.BassNet.Registration("*****@*****.**", "2X113281839322");
Un4seen.Bass.BassNet.OmitCheckVersion = true;
bool bassinit = Un4seen.Bass.Bass.BASS_Init(0, sampleRate, Un4seen.Bass.BASSInit.BASS_DEVICE_DEFAULT, System.IntPtr.Zero);
if (bassinit)
{
streamCreate = new STREAMPROC(WaveformProc);
channel = Bass.BASS_StreamCreate(sampleRate, 2, BASSFlag.BASS_DEFAULT, streamCreate, IntPtr.Zero);
if (channel != 0)
{
bufferLength = Bass.BASS_ChannelSeconds2Bytes(channel, (double)Bass.BASS_GetConfig(BASSConfig.BASS_CONFIG_BUFFER) / 1000d);
data = new short[bufferLength];
playSine();
}
else
{
Un4seen.Bass.BASSError error = Un4seen.Bass.Bass.BASS_ErrorGetCode();
Console.WriteLine(error.ToString());
}
}
else
{
Console.WriteLine("FAIL");
}
Console.ReadLine();
}
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();
}
}
/// <summary>
/// Register the Fade out Event
/// </summary>
/// <param name="stream"></param>
/// <param name="fadeOutMS"></param>
/// <returns></returns>
private int RegisterCrossFadeEvent(int stream)
{
int syncHandle = 0;
long len = Bass.BASS_ChannelGetLength(stream); // length in bytes
double totaltime = Bass.BASS_ChannelBytes2Seconds(stream, len); // the total time length
double fadeOutSeconds = 0;
if (Config.CrossFadeIntervalMs > 0)
{
fadeOutSeconds = Config.CrossFadeIntervalMs / 1000.0;
}
long bytePos = Bass.BASS_ChannelSeconds2Bytes(stream, totaltime - fadeOutSeconds);
syncHandle = Bass.BASS_ChannelSetSync(stream,
BASSSync.BASS_SYNC_POS,
bytePos, _playbackCrossFadeProcDelegate,
IntPtr.Zero);
if (syncHandle == 0)
{
Log.Debug("BASS: RegisterCrossFadeEvent of stream {0} failed with error {1}", stream,
Enum.GetName(typeof(BASSError), Bass.BASS_ErrorGetCode()));
}
return(syncHandle);
}
/// <summary>
/// Sets a SyncPos on the mixer stream
/// </summary>
/// <param name="stream"></param>
/// <param name="timePos"></param>
public void SetSyncPos(MusicStream stream, double timePos)
{
double fadeOutSeconds = Config.CrossFadeIntervalMs / 1000.0;
double totalStreamLen = Bass.BASS_ChannelBytes2Seconds(stream.BassStream, Bass.BASS_ChannelGetLength(stream.BassStream, BASSMode.BASS_POS_BYTES));
long mixerPos = Bass.BASS_ChannelGetPosition(_mixer, BASSMode.BASS_POS_BYTES | BASSMode.BASS_POS_DECODE);
long syncPos = mixerPos + Bass.BASS_ChannelSeconds2Bytes(_mixer, totalStreamLen - timePos - fadeOutSeconds);
if (_syncProc != 0)
{
Bass.BASS_ChannelRemoveSync(_mixer, _syncProc);
}
// We might have stored the pinned object already, because we are skipping
// Only store object it, when it doesn't exist
if (!_pinnedObjects.ContainsKey(stream.BassStream))
{
Log.Debug("BASS: Updating Dictionary for GCHandle for stream {0}", stream.BassStream);
// Add the pinned object to the global dictionary, so that we can free it later in the Sync End Proc
_pinnedObjects.Add(stream.BassStream, GCHandle.Alloc(stream));
}
_syncProc = Bass.BASS_ChannelSetSync(_mixer,
BASSSync.BASS_SYNC_ONETIME | BASSSync.BASS_SYNC_POS | BASSSync.BASS_SYNC_MIXTIME,
syncPos, _playbackEndProcDelegate,
new IntPtr(stream.BassStream));
}
/// <summary>
/// Creates audio stream.
/// Locks file.
/// </summary>
public void CreateStream()
{
if (!(State == ReadyState.Started || State == ReadyState.ClosedStream))
{
throw new InvalidOperationException("Not ready.");
}
// Create stream.
stream = Bass.BASS_StreamCreateFile(filePath, 0, 0, BASSFlag.BASS_STREAM_DECODE | BASSFlag.BASS_SAMPLE_FLOAT | BASSFlag.BASS_STREAM_PRESCAN);
if (stream == 0)
{
throw new Exception(Bass.BASS_ErrorGetCode().ToString());
}
// Set number of frames.
long trackLengthInBytes = Bass.BASS_ChannelGetLength(stream);
long frameLengthInBytes = Bass.BASS_ChannelSeconds2Bytes(stream, 0.01d);
NumFrames = (int)Math.Round(1f * trackLengthInBytes / frameLengthInBytes);
#if DEBUG
Console.WriteLine(stream);
BASS_CHANNELINFO info = new BASS_CHANNELINFO();
Bass.BASS_ChannelGetInfo(stream, info);
Console.WriteLine(info.ToString());
Console.WriteLine($"track length in bytes from waveformgenerator.cs: {trackLengthInBytes}");
Console.WriteLine($"how many bytes in 20 ms from waveformgenerator.cs: {frameLengthInBytes}");
Console.WriteLine($"NumFrames: {NumFrames}");
#endif
// Change state.
State = ReadyState.CreatedStream;
}
// 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);
}
}
}
}
private void buttonSetEnvelope_Click(object sender, EventArgs e)
{
if (_currentTrack.Channel != 0)
{
BASS_MIXER_NODE[] nodes =
{
new BASS_MIXER_NODE(Bass.BASS_ChannelSeconds2Bytes(_mixer, 10d), 1f),
new BASS_MIXER_NODE(Bass.BASS_ChannelSeconds2Bytes(_mixer, 13d), 0f),
new BASS_MIXER_NODE(Bass.BASS_ChannelSeconds2Bytes(_mixer, 17d), 0f),
new BASS_MIXER_NODE(Bass.BASS_ChannelSeconds2Bytes(_mixer, 20d), 1f)
};
BassMix.BASS_Mixer_ChannelSetEnvelope(_currentTrack.Channel, BASSMIXEnvelope.BASS_MIXER_ENV_VOL, nodes);
// already align the envelope position to the current playback position
// pause mixer
Bass.BASS_ChannelLock(_mixer, true);
long pos = BassMix.BASS_Mixer_ChannelGetPosition(_currentTrack.Channel);
// convert source pos to mixer pos
long envPos = Bass.BASS_ChannelSeconds2Bytes(_mixer, Bass.BASS_ChannelBytes2Seconds(_currentTrack.Channel, pos));
BassMix.BASS_Mixer_ChannelSetEnvelopePos(_currentTrack.Channel, BASSMIXEnvelope.BASS_MIXER_ENV_VOL, envPos);
// resume mixer
Bass.BASS_ChannelLock(_mixer, false);
// and show it in our waveform
_WF.DrawVolume = WaveForm.VOLUMEDRAWTYPE.Solid;
foreach (BASS_MIXER_NODE node in nodes)
{
_WF.AddVolumePoint(node.pos, node.val);
}
DrawWave();
}
}
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);
}
/// <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);
}
}
void MixTrack(int pMixer, Track pTrack, Dictionary <AudioSample, int> pSamples)
{
foreach (Note n in pTrack.Notes)
{
//TODO: Maybe use another length instead of 0
long start = Bass.BASS_ChannelSeconds2Bytes(pMixer, PositionOfNote(n));
BassMix.BASS_Mixer_StreamAddChannelEx(pMixer, pSamples[n.Sample], 0, start, 0);
}
}
private void setGain(int deck, float gain)
{
// annoying dsp code to write
// each node is like a (value,time) pair
BASS_MIXER_NODE[] nodes =
{
new BASS_MIXER_NODE(Bass.BASS_ChannelSeconds2Bytes(deck, 0d), gain),
};
BassMix.BASS_Mixer_ChannelSetEnvelope(deck, BASSMIXEnvelope.BASS_MIXER_ENV_VOL, nodes);
}
/// <summary>
/// Sets the position of the player
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
public static bool SetPos(double value)
{
try {
var sec = (value / 100) * SoundCloudCore.Tracks[Tracks[TrackIndex]].Duration.TotalSeconds;
var pos = Bass.BASS_ChannelSeconds2Bytes(channel, sec);
Bass.BASS_ChannelSetPosition(channel, pos);
return(true);
}
catch { return(false); }
}
public void Run()
{
Logger.Info("Starting ...");
Bass.BASS_ChannelSetPosition(_soundStream, Bass.BASS_ChannelSeconds2Bytes(_soundStream, 0.0), BASSMode.BASS_POS_BYTES);
Bass.BASS_ChannelPlay(_soundStream, false);
_stopwatch.Start();
_globalTime.Start();
RenderLoop.Run(_form, () => Update());
}
public void SetPosSeconds(int chan, double seconds)
{
long curPos = Bass.BASS_ChannelGetPosition(chan);
long pos = Bass.BASS_ChannelSeconds2Bytes(chan, seconds);
if (!Bass.BASS_ChannelSetPosition(chan, pos, BASSMode.BASS_POS_BYTES))
{
GetBassErrorTrow("Could not seek to " + seconds);
}
}
public bool Seek(double seconds)
{
if (State == ChannelStates.Playing || State == ChannelStates.Paused)
{
var bytes = Bass.BASS_ChannelSeconds2Bytes(Stream, seconds);
return(Bass.BASS_ChannelSetPosition(Stream, bytes, BASSMode.BASS_POS_BYTE));
}
else
{
return(false);
}
}
private void SetEnvelopePos(int source, long newPos)
{
// pause mixer
Bass.BASS_ChannelLock(_mixer, true);
BassMix.BASS_Mixer_ChannelSetPosition(source, newPos);
// convert source pos to mixer pos
long envPos = Bass.BASS_ChannelSeconds2Bytes(_mixer, Bass.BASS_ChannelBytes2Seconds(source, newPos));
BassMix.BASS_Mixer_ChannelSetEnvelopePos(source, BASSMIXEnvelope.BASS_MIXER_ENV_VOL, envPos);
// resume mixer
Bass.BASS_ChannelLock(_mixer, false);
}
/// <summary>
/// Set the end position of a song inside a CUE file
/// </summary>
/// <param name="startPos"></param>
/// <param name="endPos"></param>
public void SetCueTrackEndPos(float startPos, float endPos)
{
if (_cueTrackEndEventHandler != 0)
{
Bass.BASS_ChannelRemoveSync(_stream, _cueTrackEndEventHandler);
}
Bass.BASS_ChannelSetPosition(_stream, Bass.BASS_ChannelSeconds2Bytes(_stream, startPos));
if (endPos > startPos)
{
_cueTrackEndEventHandler = RegisterCueTrackEndEvent(Bass.BASS_ChannelSeconds2Bytes(_stream, endPos));
}
}
public DSP_IIRDelay(int channel, int priority, float maxDelay) : base(channel, priority, IntPtr.Zero)
{
if (maxDelay > 60f)
{
maxDelay = 60f;
}
else if (maxDelay < 0.001f)
{
maxDelay = 0.001f;
}
this._maxDelay = maxDelay;
this.MAX_DELAY = (int)(Bass.BASS_ChannelSeconds2Bytes(base.ChannelHandle, (double)maxDelay) / (long)(base.ChannelBitwidth / 8));
this.buffer = new double[this.MAX_DELAY];
}
//开始
public void Start()
{
if (_fileName != String.Empty)
{
if (_stream != 0)
{
playPause = false;
// used in RMS
_30mslength = (int)Bass.BASS_ChannelSeconds2Bytes(_stream, 0.03); // 30ms window // latency from milliseconds to bytes
_deviceLatencyBytes = (int)Bass.BASS_ChannelSeconds2Bytes(_stream, _deviceLatencyMS / 1000.0);
if (WF2 != null && WF2.IsRendered)
{
// make sure playback and wave form are in sync, since
// we rended with 16-bit but play here with 32-bit
WF2.SyncPlayback(_stream);
//long cuein = WF2.GetMarker("CUE");
long cueout = WF2.GetMarker("END");
//int cueinFrame = WF2.Position2Frames(cuein);
//int cueoutFrame = WF2.Position2Frames(cueout);
//Console.WriteLine("CueIn at {0}sec.; CueOut at {1}sec.", WF2.Frame2Seconds(cueinFrame), WF2.Frame2Seconds(cueoutFrame));
//if (cuein >= 0)
//{
// Bass.BASS_ChannelSetPosition(_stream, cuein);
//}
if (cueout >= 0)
{
Bass.BASS_ChannelRemoveSync(_stream, _syncer);
_syncer = Bass.BASS_ChannelSetSync(_stream, BASSSync.BASS_SYNC_POS, cueout, _sync, IntPtr.Zero);
}
}
if (_stream != 0 && Bass.BASS_ChannelPlay(_stream, false))
{
_updateTimer.Start();
}
else
{
Console.WriteLine("Error={0}", Bass.BASS_ErrorGetCode());
}
}
}
}
// calculates the level of a stereo signal between 0 and 65535
// where 0 = silent, 32767 = 0dB and 65535 = +6dB
private void GetLevel(int channel, out int peakL, out int peakR)
{
float maxL = 0f;
float maxR = 0f;
// length of a 20ms window in bytes
int length20ms = (int)Bass.BASS_ChannelSeconds2Bytes(channel, 0.02);
// the number of 32-bit floats required (since length is in bytes!)
int l4 = length20ms / 4; // 32-bit = 4 bytes
// create a data buffer as needed
float[] sampleData = new float[l4];
int length = Bass.BASS_ChannelGetData(channel, sampleData, length20ms);
// the number of 32-bit floats received
// as less data might be returned by BASS_ChannelGetData as requested
l4 = length / 4;
for (int a = 0; a < l4; a++)
{
float absLevel = Math.Abs(sampleData[a]);
// decide on L/R channel
if (a % 2 == 0)
{
// Left channel
if (absLevel > maxL)
{
maxL = absLevel;
}
}
else
{
// Right channel
if (absLevel > maxR)
{
maxR = absLevel;
}
}
}
// limit the maximum peak levels to +6bB = 65535 = 0xFFFF
// the peak levels will be int values, where 32767 = 0dB
// and a float value of 1.0 also represents 0db.
peakL = (int)Math.Round(32767f * maxL) & 0xFFFF;
peakR = (int)Math.Round(32767f * maxR) & 0xFFFF;
}
public void ReSync()
{
if (!base.IsAssigned)
{
return;
}
if (this._isOutputBuffered && this.TargetMixerStream != 0 && this.SourceMixerStream != 0)
{
Bass.BASS_ChannelLock(this.SourceMixerStream, true);
int num = Bass.BASS_ChannelGetData(this.TargetMixerStream, IntPtr.Zero, 0);
if (num > 0)
{
num = (int)Bass.BASS_ChannelSeconds2Bytes(this._streamCopy, Bass.BASS_ChannelBytes2Seconds(this.TargetMixerStream, (long)num));
if (!this._isSourceMixerNonstop && this._isTargetMixerNonstop)
{
this._streamCopyDelay = num;
BassMix.BASS_Mixer_ChannelSetPosition(this._streamCopy, 0L);
}
else if (!this._isTargetMixerNonstop)
{
int num2 = Bass.BASS_ChannelGetData(this.SourceMixerStream, IntPtr.Zero, 0);
num2 = (int)Bass.BASS_ChannelSeconds2Bytes(this._streamCopy, Bass.BASS_ChannelBytes2Seconds(this.SourceMixerStream, (long)num2));
if (num2 > num)
{
byte[] buffer = new byte[num2 - num];
Bass.BASS_StreamPutData(this._streamCopy, buffer, num2 - num);
}
}
}
else if (this._isSourceMixerNonstop)
{
int num3 = Bass.BASS_ChannelGetData(this.SourceMixerStream, IntPtr.Zero, 0);
num3 = (int)Bass.BASS_ChannelSeconds2Bytes(this._streamCopy, Bass.BASS_ChannelBytes2Seconds(this.SourceMixerStream, (long)num3));
int num4 = (int)Bass.BASS_ChannelSeconds2Bytes(this._streamCopy, (double)this._outputLatency / 1000.0);
if (num3 > num4)
{
BassMix.BASS_Mixer_ChannelSetPosition(this._streamCopy, 0L);
byte[] buffer2 = new byte[num3 - num4];
Bass.BASS_StreamPutData(this._streamCopy, buffer2, num3 - num4);
}
}
if (this._isTargetMixerImmediate && !this._isTargetMixerNonstop)
{
Bass.BASS_ChannelUpdate(this.TargetMixerStream, 0);
}
Bass.BASS_ChannelLock(this.SourceMixerStream, false);
}
}
private int BassStreamProc(int handle, IntPtr buffer, int length, IntPtr user)
{
if (base.IsBypassed)
{
return(0);
}
DSP_BufferStream obj;
if (this.OutputHandle != 0)
{
int num = Bass.BASS_ChannelGetData(this.OutputHandle, IntPtr.Zero, 0);
num = (int)Bass.BASS_ChannelSeconds2Bytes(handle, Bass.BASS_ChannelBytes2Seconds(this.OutputHandle, (long)num));
if (num > this._bufferLength)
{
num = this._bufferLength;
}
else if (num < 0)
{
num = 0;
}
if (length > num)
{
length = num;
}
obj = this;
lock (obj)
{
Marshal.Copy(this._buffer, this._bufferLength - num, buffer, length);
return(length);
}
}
if (this._lastPos + length > this._bufferLength)
{
length = this._bufferLength - this._lastPos;
}
obj = this;
lock (obj)
{
Marshal.Copy(this._buffer, this._lastPos, buffer, length);
this._lastPos += length;
if (this._lastPos > this._bufferLength)
{
this._lastPos = this._bufferLength;
}
}
return(length);
}
public static bool BASSPlayBackEngineRT(Double[] CustomFramerates, ref Int64 pos, ref Int64 es)
{
double fpssim = MainWindow.FPSSimulator.NextDouble() * (CustomFramerates[0] - CustomFramerates[1]) + CustomFramerates[1];
int length = Convert.ToInt32(Bass.BASS_ChannelSeconds2Bytes(MainWindow.KMCGlobals._recHandle, fpssim));
byte[] buffer = new byte[length];
for (int i = 0; i <= 15; i++)
{
BassMidi.BASS_MIDI_StreamEvent(MainWindow.KMCGlobals._recHandle, i, BASSMIDIEvent.MIDI_EVENT_MIXLEVEL, MainWindow.KMCStatus.ChannelsVolume[i]);
}
while (es < MainWindow.KMCGlobals.eventc && MainWindow.KMCGlobals.events[es].pos < pos + length)
{
BassMidi.BASS_MIDI_StreamEvent(MainWindow.KMCGlobals._recHandle, MainWindow.KMCGlobals.events[es].chan, MainWindow.KMCGlobals.events[es].eventtype, MainWindow.KMCGlobals.events[es].param);
es++;
}
if (MainWindow.VSTs.VSTInfo[0].isInstrument)
{
Bass.BASS_ChannelGetData(MainWindow.VSTs._VSTiHandle, buffer, length);
}
int got = Bass.BASS_ChannelGetData(MainWindow.KMCGlobals._recHandle, buffer, length);
if (got < 0)
{
MainWindow.KMCGlobals.CancellationPendingValue = MainWindow.KMCConstants.CONVERSION_ENDED;
return(false);
}
pos += got;
if (es == MainWindow.KMCGlobals.eventc)
{
BassMidi.BASS_MIDI_StreamEvent(MainWindow.KMCGlobals._recHandle, 0, BASSMIDIEvent.MIDI_EVENT_END, 0);
}
float fpsstring = 1 / (float)fpssim;
IntPtr UnmanagedBuffer = Marshal.AllocHGlobal(buffer.Length);
Marshal.Copy(buffer, 0, UnmanagedBuffer, buffer.Length);
BassWasapi.BASS_WASAPI_PutData(UnmanagedBuffer, length);
Marshal.FreeHGlobal(UnmanagedBuffer);
return(true);
}
/// <summary>
/// Create a Fingerprint and lookup the Recordings
/// </summary>
/// <param name="file"></param>
/// <returns></returns>
private async Task <List <Recording> > GetRecordings(string file)
{
var stream = Bass.BASS_StreamCreateFile(file, 0, 0, BASSFlag.BASS_STREAM_DECODE);
var chInfo = Bass.BASS_ChannelGetInfo(stream);
var bufLen = (int)Bass.BASS_ChannelSeconds2Bytes(stream, 120.0);
var buf = new short[bufLen];
var chromaContext = new ChromaContext();
chromaContext.Start(chInfo.freq, chInfo.chans);
var length = Bass.BASS_ChannelGetData(stream, buf, bufLen);
chromaContext.Feed(buf, length / 2);
chromaContext.Finish();
var fingerPrint = chromaContext.GetFingerprint();
Configuration.ClientKey = "mfbgmu2P";
var lookupSvc = new LookupService();
var len = Bass.BASS_ChannelGetLength(stream, BASSMode.BASS_POS_BYTE);
var time = Bass.BASS_ChannelBytes2Seconds(stream, len);
Bass.BASS_StreamFree(stream);
//var result = await lookupSvc.GetAsync(fingerPrint, Convert.ToInt32(time), new[] { "recordingids", "releases", "artists" });
var trackIds = await lookupSvc.GetAsync(fingerPrint, Convert.ToInt32(time), new[] { "recordingids" });
var recordings = new List <Recording>();
foreach (var trackId in trackIds.Results)
{
foreach (var rec in trackId.Recordings)
{
System.Threading.Thread.Sleep(400);
var recording = await Recording.GetAsync(rec.Id, new[] { "releases", "artists", "media", "discids" });
recordings.Add(recording);
}
}
return(recordings);
}
public void StopFile(int handle, bool fadeOut, int fadeOutTime, bool isCrossFade)
{
if (!fadeOut || fadeOutTime == 0)
{
Bass.BASS_ChannelStop(handle); // no error handling, unimportant
FileFinished(handle, true);
}
else
{
long pos = Bass.BASS_ChannelGetPosition(handle);
long length = Bass.BASS_ChannelGetLength(handle);
long remaining = length - pos;
long fadeOutLength = Bass.BASS_ChannelSeconds2Bytes(handle, 0.001 * fadeOutTime);
if (fadeOutLength == -1)
{
// on error, just stop the file
Bass.BASS_ChannelStop(handle);
FileFinished(handle, true);
return;
}
if (pos == -1 || length == -1 || remaining <= 0)
{
// web radio doesn't have a length
remaining = fadeOutLength;
}
if (fadeOutLength > remaining)
{
fadeOutLength = remaining;
}
// if (Bass.BASS_ChannelSetSync(handle, BASSSync.BASS_SYNC_POS, pos + fadeOutLength, m_StopSync, new IntPtr(0)) == 0)
if (Bass.BASS_ChannelSetSync(handle, BASSSync.BASS_SYNC_SLIDE | BASSSync.BASS_SYNC_ONETIME, 0, m_StopSync, new IntPtr(handle)) == 0)
{
// on error, just stop the file
Bass.BASS_ChannelStop(handle);
FileFinished(handle, true);
return;
}
FadeOut(handle, fadeOutTime);
if (isCrossFade)
{
// call finished immediately to start the next file
FileFinished(handle, false);
}
}
}
private int BassStreamProc(int handle, IntPtr buffer, int length, IntPtr user)
{
if (base.IsBypassed)
{
return(0);
}
if (OutputHandle != 0)
{
int num = Bass.BASS_ChannelGetData(OutputHandle, IntPtr.Zero, 0);
num =
(int)
Bass.BASS_ChannelSeconds2Bytes(handle, Bass.BASS_ChannelBytes2Seconds(OutputHandle, (long)num));
if (num > _bufferLength)
{
num = _bufferLength;
}
else if (num < 0)
{
num = 0;
}
if (length > num)
{
length = num;
}
lock (this)
{
Marshal.Copy(_buffer, _bufferLength - num, buffer, length);
return(length);
}
}
if ((_lastPos + length) > _bufferLength)
{
length = _bufferLength - _lastPos;
}
lock (this)
{
Marshal.Copy(_buffer, _lastPos, buffer, length);
_lastPos += length;
if (_lastPos > _bufferLength)
{
_lastPos = _bufferLength;
}
}
return(length);
}
private void Encode(string filename)
{
// Отключаем кнопки
playButton.Enabled = false;
saveButton.Enabled = false;
selectButton.Enabled = false;
encodeProgress.Visible = true;
// Энкодим в мп3
ThreadPool.QueueUserWorkItem(w =>
{
int encoder = BassEnc.BASS_Encode_Start(fxStream, "lame -b192 - \"" + filename + "\"", 0, null, IntPtr.Zero /*this.Handle*/);
long i = 0;
long chanLenght = Bass.BASS_ChannelGetLength(fxStream);
while (i < chanLenght - 1)
{
// Так как буфер в 1сек, то и записываем по одной секунде данных в проход
Bass.BASS_ChannelSetPosition(fxStream, i, BASSMode.BASS_POS_BYTES);
long len = Bass.BASS_ChannelSeconds2Bytes(fxStream, 1);
Bass.BASS_ChannelUpdate(fxStream, 1000);
i += len;
this.Invoke((MethodInvoker) delegate
{
encodeProgress.Value = (int)(i * 100 / chanLenght);
debugInfo.Text = Bass.BASS_ErrorGetCode().ToString() + "\n" + len + "\n" + i + "\n" + Bass.BASS_ChannelGetLength(fxStream);
});
}
// ехал инвок через инвок
this.Invoke((MethodInvoker) delegate
{
encodeProgress.Visible = false;
playButton.Enabled = true;
saveButton.Enabled = true;
selectButton.Enabled = true;
});
BassEnc.BASS_Encode_Stop(encoder);
});
}
/// <summary>
/// Sets a SyncPos on the mixer stream
/// </summary>
/// <param name="stream"></param>
/// <param name="timePos"></param>
public void SetSyncPos(MusicStream stream, double timePos)
{
double fadeOutSeconds = Config.CrossFadeIntervalMs / 1000.0;
double totalStreamLen = Bass.BASS_ChannelBytes2Seconds(stream.BassStream, Bass.BASS_ChannelGetLength(stream.BassStream, BASSMode.BASS_POS_BYTES));
long mixerPos = Bass.BASS_ChannelGetPosition(_mixer, BASSMode.BASS_POS_BYTES | BASSMode.BASS_POS_DECODE);
long syncPos = mixerPos + Bass.BASS_ChannelSeconds2Bytes(_mixer, totalStreamLen - timePos - fadeOutSeconds);
if (_syncProc != 0)
{
Bass.BASS_ChannelRemoveSync(_mixer, _syncProc);
}
GCHandle pFilePath = GCHandle.Alloc(stream);
_syncProc = Bass.BASS_ChannelSetSync(_mixer,
BASSSync.BASS_SYNC_ONETIME | BASSSync.BASS_SYNC_POS | BASSSync.BASS_SYNC_MIXTIME,
syncPos, _playbackEndProcDelegate,
GCHandle.ToIntPtr(pFilePath));
}
public List <MusicBrainzTrack> GetMusicBrainzTrack(string fileName)
{
log.Debug("Identify: Creating Fingerprint");
// Create a Decoding Channel
int channel = Bass.BASS_StreamCreateFile(fileName, 0, 0, BASSFlag.BASS_STREAM_DECODE);
if (channel == 0)
{
return(null);
}
// Now get information about channel and retrieve length
BASS_CHANNELINFO chinfo;
chinfo = Bass.BASS_ChannelGetInfo(channel);
// Get 135 Seconds of the file to be used for the fingerprint
int sampleLength = (int)Bass.BASS_ChannelSeconds2Bytes(channel, 135);
byte[] samples = new byte[sampleLength];
sampleLength = Bass.BASS_ChannelGetData(channel, samples, sampleLength);
lengthInMS = (int)Bass.BASS_ChannelBytes2Seconds(channel, Bass.BASS_ChannelGetLength(channel)) * 1000;
Bass.BASS_StreamFree(channel);
// Get Fingerprint
puid = "";
StringBuilder fp = new StringBuilder(758);
if (NativeMethods.ofa_create_print(fp, samples, 0, sampleLength / 2, chinfo.freq, chinfo.chans == 2 ? true : false))
{
fingerprint = fp.ToString();
puid = GetPuid();
}
if (puid == "")
{
return(null);
}
return(RetrieveMusicBrainzTrack(puid));
}
private void ProcessDecompressedData()
{
if (mixerHandle != 0)
{
int bytesRead = 0;
do
{
int bufferSizeInBytes = (int)Bass.BASS_ChannelSeconds2Bytes(mixerHandle, 1.0);
if (inSecBuffer == null)
{
inSecBuffer = new float[bufferSizeInBytes / 4]; // we hebben floats
inSecPtr = 0;
}
else
{
bufferSizeInBytes = (inSecBuffer.Length - inSecPtr) * 4;
}
float[] buffer = new float[bufferSizeInBytes / 4];
bytesRead = Bass.BASS_ChannelGetData(mixerHandle, buffer, bufferSizeInBytes | (int)BASSData.BASS_DATA_FLOAT);
if (bytesRead <= 0)
{
return;
}
// nu data naar insecbuffer kopieren
Buffer.BlockCopy(buffer, 0, inSecBuffer, inSecPtr * 4, bytesRead);
inSecPtr += (int)(bytesRead / 4);
if (inSecPtr >= inSecBuffer.Length)
{
if (OnStreamUpdate != null)
{
DoCallback(OnStreamUpdate, this, new StreamUpdateEventArgs(inSecBuffer));
}
inSecBuffer = null;
inSecPtr = 0;
}
} while (bytesRead > 0);
} //if basshandle valid
}