public void UpdateDistortion()
{
BassEngine engine = BassEngine.Instance;
if (DistortionITM.switchx)
{
if (DistortionITM.fxState == false)
{
Bass.BASS_FXSetParameters(_fxDistortionHandle, _distortionfx);
}
if (DistortionITM.fxState == false)
{
_fxDistortionHandle = Bass.BASS_ChannelSetFX(engine.ActiveStreamHandle,
BASSFXType.BASS_FX_DX8_DISTORTION, 0);
}
_distortionfx.Preset_Default();
switch (DistortionITM.SelUTx)
{
case "Default Preset":
_distortionfx.Preset_Default();
break;
}
}
else
{
Bass.BASS_ChannelRemoveFX(engine.ActiveStreamHandle, _fxDistortionHandle);
}
}
public void SetEQ(float[] _gains)
{
//if (stream != 0)
{
for (int i = 0; i < 18; i++)
{
fxBands[i] = Bass.BASS_ChannelSetFX(stream, BASSFXType.BASS_FX_DX8_PARAMEQ, 0);
gains[i] = _gains[i];
}
//BASS_DX8_PARAMEQ p = new BASS_DX8_PARAMEQ();
Bass.BASS_FXSetParameters(fxBands[0], new BASS_DX8_PARAMEQ(31f, 1f, gains[0]));
Bass.BASS_FXSetParameters(fxBands[1], new BASS_DX8_PARAMEQ(63f, 2f, gains[1]));
Bass.BASS_FXSetParameters(fxBands[2], new BASS_DX8_PARAMEQ(87f, 3f, gains[2]));
Bass.BASS_FXSetParameters(fxBands[3], new BASS_DX8_PARAMEQ(125f, 4f, gains[3]));
Bass.BASS_FXSetParameters(fxBands[4], new BASS_DX8_PARAMEQ(175f, 5f, gains[4]));
Bass.BASS_FXSetParameters(fxBands[5], new BASS_DX8_PARAMEQ(250f, 6f, gains[5]));
Bass.BASS_FXSetParameters(fxBands[6], new BASS_DX8_PARAMEQ(350f, 7f, gains[6]));
Bass.BASS_FXSetParameters(fxBands[7], new BASS_DX8_PARAMEQ(500f, 8f, gains[7]));
Bass.BASS_FXSetParameters(fxBands[8], new BASS_DX8_PARAMEQ(700f, 9f, gains[8]));
Bass.BASS_FXSetParameters(fxBands[9], new BASS_DX8_PARAMEQ(1000f, 10f, gains[9]));
Bass.BASS_FXSetParameters(fxBands[10], new BASS_DX8_PARAMEQ(1400f, 11f, gains[10]));
Bass.BASS_FXSetParameters(fxBands[11], new BASS_DX8_PARAMEQ(2000f, 12f, gains[11]));
Bass.BASS_FXSetParameters(fxBands[12], new BASS_DX8_PARAMEQ(2800f, 13f, gains[12]));
Bass.BASS_FXSetParameters(fxBands[13], new BASS_DX8_PARAMEQ(4000f, 14f, gains[13]));
Bass.BASS_FXSetParameters(fxBands[14], new BASS_DX8_PARAMEQ(5600f, 15f, gains[14]));
Bass.BASS_FXSetParameters(fxBands[15], new BASS_DX8_PARAMEQ(8000f, 16f, gains[15]));
Bass.BASS_FXSetParameters(fxBands[16], new BASS_DX8_PARAMEQ(11200f, 17f, gains[16]));
Bass.BASS_FXSetParameters(fxBands[17], new BASS_DX8_PARAMEQ(16000f, 18f, gains[17]));
}
}
private void checkBoxFlanger_CheckedChanged(object sender, System.EventArgs e)
{
if (_StreamFX == 0)
{
return;
}
if (this.checkBoxFlanger.Checked)
{
// and add a DSP here as well...
_flangerFX = Bass.BASS_ChannelSetFX(_StreamFX, BASSFXType.BASS_FX_BFX_FLANGER, -4);
BASS_BFX_FLANGER flanger = new BASS_BFX_FLANGER();
flanger.Preset_Default();
Bass.BASS_FXSetParameters(_flangerFX, flanger);
// just to demo how to get
BASS_BFX_FLANGER f = new BASS_BFX_FLANGER();
Bass.BASS_FXGetParameters(_flangerFX, f);
}
else
{
// remove the DSP
Bass.BASS_ChannelRemoveFX(_StreamFX, _flangerFX);
_flangerFX = 0;
}
}
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 UpdateFlanger()
{
BassEngine engine = BassEngine.Instance;
if (FlangerITM.switchx)
{
if (FlangerITM.fxState == false)
{
Bass.BASS_FXSetParameters(_fxFlangerHandle, _flangerfx);
}
if (FlangerITM.fxState == false)
{
_fxFlangerHandle = Bass.BASS_ChannelSetFX(engine.ActiveStreamHandle, BASSFXType.BASS_FX_DX8_FLANGER,
0);
}
switch (FlangerITM.SelUTx)
{
case "Default Preset":
_flangerfx.Preset_Default();
break;
case "Preset: A":
_flangerfx.Preset_A();
break;
case "Preset: B":
_flangerfx.Preset_B();
break;
}
}
else
{
Bass.BASS_ChannelRemoveFX(engine.ActiveStreamHandle, _fxFlangerHandle);
}
}
public void SetEqualizerPosition(int freq, float position)
{
var par = new BASS_DX8_PARAMEQ(freq, 5, position);
Bass.BASS_FXSetParameters(GetFXHandle(freq), par);
_lastEqualizerValues[freq] = position;
}
public void UpdateI3Dl2Reverb()
{
BassEngine engine = BassEngine.Instance;
if (I3DL2ReverbITM.switchx)
{
if (I3DL2ReverbITM.fxState == false)
{
Bass.BASS_FXSetParameters(_fxI3Dl2ReverbHandle, _i3Dl2Reverbfx);
}
if (I3DL2ReverbITM.fxState == false)
{
_fxI3Dl2ReverbHandle = Bass.BASS_ChannelSetFX(engine.ActiveStreamHandle,
BASSFXType.BASS_FX_DX8_I3DL2REVERB, 0);
}
switch (I3DL2ReverbITM.SelUTx)
{
case "Default Preset":
_i3Dl2Reverbfx.Preset_Default();
break;
}
}
else
{
Bass.BASS_ChannelRemoveFX(engine.ActiveStreamHandle, _fxI3Dl2ReverbHandle);
}
}
public void UpdateGargle()
{
BassEngine engine = BassEngine.Instance;
if (GargleITM.switchx)
{
if (GargleITM.fxState == false)
{
Bass.BASS_FXSetParameters(_fxGargleHandle, _garglefx);
}
if (GargleITM.fxState == false)
{
_fxGargleHandle = Bass.BASS_ChannelSetFX(engine.ActiveStreamHandle, BASSFXType.BASS_FX_DX8_GARGLE, 0);
}
switch (GargleITM.SelUTx)
{
case "Default Preset":
_garglefx.Preset_Default();
break;
}
}
else
{
Bass.BASS_ChannelRemoveFX(engine.ActiveStreamHandle, _fxGargleHandle);
}
}
/// <summary>
/// Sets the equalizer value according to frequency.
/// </summary>
/// <param name="frequency"></param>
/// <param name="value"></param>
public void SetEqualizerFrequency(Int32 frequency, Double value)
{
EqualizerValue equalizerValue = new EqualizerValue(frequency, value);
BASS_DX8_PARAMEQ parameqDX8 = new BASS_DX8_PARAMEQ();
if (values.ContainsKey(frequency))
{
Handle eqValueHandle = values[frequency]?.Handle;
if (eqValueHandle != null)
{
Bass.BASS_ChannelRemoveFX(handle, eqValueHandle);
}
}
Int32 fxHandle = Bass.BASS_ChannelSetFX(handle, BASSFXType.BASS_FX_DX8_PARAMEQ, frequency);
equalizerValue.Handle = new Handle(fxHandle);
parameqDX8.fCenter = frequency;
parameqDX8.fGain = (Single)value;
parameqDX8.fBandwidth = 8f;
Bass.BASS_FXSetParameters(equalizerValue.Handle, parameqDX8);
values[frequency] = equalizerValue;
}
public void UpdateChorus()
{
BassEngine engine = BassEngine.Instance;
if (chorusITM.switchx)
{
if (chorusITM.fxState == false)
{
Bass.BASS_FXSetParameters(_fxChorusHandle, _chorusfx);
}
if (chorusITM.fxState == false)
{
_fxChorusHandle = Bass.BASS_ChannelSetFX(engine.ActiveStreamHandle, BASSFXType.BASS_FX_DX8_CHORUS, 0);
}
switch (chorusITM.SelUTx)
{
case "Default Preset":
_chorusfx.Preset_Default();
break;
case "Preset: A":
_chorusfx.Preset_A();
break;
case "Preset: B":
_chorusfx.Preset_B();
break;
}
}
else
{
Bass.BASS_ChannelRemoveFX(engine.ActiveStreamHandle, _fxChorusHandle);
}
}
public void UpdateEQBass(int band, float gain)
{
try
{
BASS_BFX_PEAKEQ eq = new BASS_BFX_PEAKEQ();
ArrBandValue[band].Gain = gain;
if (m_bandValue.Handle == -1)
{
// AppSettings.Set("AudioEQBand" + band, gain.ToString());
return;
}
//m_bandValue.Gain = gain;
// get values of the selected band
eq.lBand = band;
Bass.BASS_FXGetParameters(m_bandValue.Handle, eq);
eq.fGain = gain / 10;
Bass.BASS_FXSetParameters(m_bandValue.Handle, eq);
Console.WriteLine(m_bandValue.Handle + " : " + eq.fCenter + " : " + eq.fGain + " : " + ArrBandValue[band].Gain);
//AppSettings.Set("AudioEQBand" + band, gain.ToString("0.0"));
}
catch (Exception ex)
{
Logger.LogFile(ex.Message, "", "UpdateEQBass", ex.LineNumber(), "Equalizer Class");
}
}
/// <summary>
/// Equalizer parameter
/// </summary>
/// <param name="fxchan">_fx Array channel</param>
/// <param name="center"> Center band</param>
/// <param name="gain"> Gain for the band</param>
/// <returns></returns>
public bool SetEqParams(int fxchan, double center, double gain)
{
_parEq.fBandwidth = 18.0f;
_parEq.fCenter = (float)center;
_parEq.fGain = (float)gain;
return(Bass.BASS_FXSetParameters(_fx[fxchan], _parEq));
}
public bool SetParametersEQ(int fx, int center, float gain)
{
pARAMEQ.fBandwidth = 18.0f;
pARAMEQ.fCenter = (float)center;
pARAMEQ.fGain = (float)gain;
return(Bass.BASS_FXSetParameters(fx, pARAMEQ));
}
/// <summary>
/// Sets the replay gain for a channel.
/// </summary>
/// <param name="audioStream">The audio stream.</param>
private static void SetReplayGain(AudioStream audioStream)
{
if (audioStream == null || !audioStream.IsAudioLoaded())
{
throw new Exception("Audio file null or not audio not loaded");
}
if (!audioStream.IsGainChannelInitialized() && audioStream.Gain == 0)
{
return;
}
var volume = DecibelToPercent(audioStream.Gain);
// DebugHelper.WriteLine("SetReplayGain for " + audioStream + " to " + volume);
if (!audioStream.IsGainChannelInitialized())
{
audioStream.GainChannel = Bass.BASS_ChannelSetFX(audioStream.ChannelId, BASSFXType.BASS_FX_BFX_VOLUME, int.MaxValue);
}
var volumeParameters = new BASS_BFX_VOLUME(volume, BASSFXChan.BASS_BFX_CHANALL);
Bass.BASS_FXSetParameters(audioStream.GainChannel, volumeParameters);
}
private void PrepareChannelsToSplit(int index, IList <int> ArrangedChannels, int channels, float vol, string file, MoggSplitFormat format, string quality, bool slave = true)
{
var channel_map = new int[channels == 2 ? 3 : 2];
channel_map[0] = ArrangedChannels[index];
channel_map[1] = channels == 2 ? ArrangedChannels[index + 1] : -1;
if (channels == 2)
{
channel_map[2] = -1;
}
var flags = slave ? BASSFlag.BASS_STREAM_DECODE | BASSFlag.BASS_SPLIT_SLAVE : BASSFlag.BASS_STREAM_DECODE;
var out_stream = BassMix.BASS_Split_StreamCreate(SourceStream, flags, channel_map);
var volumeFX = Bass.BASS_ChannelSetFX(out_stream, BASSFXType.BASS_FX_BFX_VOLUME, 0);
var volume = new BASS_BFX_VOLUME {
lChannel = 0, fVolume = vol
};
Bass.BASS_FXSetParameters(volumeFX, volume);
Splits.Add(out_stream);
if (format == MoggSplitFormat.OGG)
{
var cmd = "bin\\oggenc2.exe -q" + quality + " - -o\"" + file + "\"";
BassEnc.BASS_Encode_Start(out_stream, cmd, BASSEncode.BASS_ENCODE_FP_24BIT | BASSEncode.BASS_ENCODE_AUTOFREE, null, IntPtr.Zero);
}
else
{
BassEnc.BASS_Encode_Start(out_stream, file, BASSEncode.BASS_ENCODE_PCM | BASSEncode.BASS_ENCODE_AUTOFREE, null, IntPtr.Zero);
}
}
public void UpdateApf()
{
BassEngine engine = BassEngine.Instance;
if (APFITM.switchx)
{
if (APFITM.fxState == false)
{
Bass.BASS_FXSetParameters(_fxApfHandle, _apFfx);
}
if (APFITM.fxState == false)
{
_fxApfHandle = Bass.BASS_ChannelSetFX(engine.ActiveStreamHandle, BASSFXType.BASS_FX_BFX_APF, 0);
}
_apFfx.Preset_RobotVoice();
switch (APFITM.SelUTx)
{
case "Default Preset":
_apFfx.Preset_RobotVoice();
break;
}
}
else
{
Bass.BASS_ChannelRemoveFX(engine.ActiveStreamHandle, _fxApfHandle);
}
}
public void UpdateEcho()
{
BassEngine engine = BassEngine.Instance;
if (EchoITM.switchx)
{
if (EchoITM.fxState == false)
{
Bass.BASS_FXSetParameters(_fxEchoHandle, _echofx);
}
if (EchoITM.fxState == false)
{
_fxEchoHandle = Bass.BASS_ChannelSetFX(engine.ActiveStreamHandle, BASSFXType.BASS_FX_DX8_ECHO, 0);
}
switch (EchoITM.SelUTx)
{
case "Default Preset":
_echofx.Preset_Default();
break;
case "Preset: Short":
_echofx.Preset_Long();
break;
case "Preset: Long":
_echofx.Preset_Small();
break;
}
}
else
{
Bass.BASS_ChannelRemoveFX(engine.ActiveStreamHandle, _fxEchoHandle);
}
}
public void UpdatePhaser()
{
BassEngine engine = BassEngine.Instance;
if (PhaserITM.switchx)
{
if (PhaserITM.fxState == false)
{
Bass.BASS_FXSetParameters(_fxPhaserHandle, _phaserfx);
}
if (PhaserITM.fxState == false)
{
_fxPhaserHandle = Bass.BASS_ChannelSetFX(engine.ActiveStreamHandle, BASSFXType.BASS_FX_BFX_PHASER, 0);
}
_phaserfx.Preset_PhaseShift();
switch (PhaserITM.SelUTx)
{
case "Default Preset":
break;
}
}
else
{
Bass.BASS_ChannelRemoveFX(engine.ActiveStreamHandle, _fxPhaserHandle);
}
}
public void UpdateAutoWah()
{
BassEngine engine = BassEngine.Instance;
if (AutoWahITM.switchx)
{
if (AutoWahITM.fxState == false)
{
Bass.BASS_FXSetParameters(_fxAutoWahHandle, _autoWahfx);
}
if (AutoWahITM.fxState == false)
{
_fxAutoWahHandle = Bass.BASS_ChannelSetFX(engine.ActiveStreamHandle, BASSFXType.BASS_FX_BFX_AUTOWAH,
0);
}
_autoWahfx.Preset_SlowAutoWah();
switch (AutoWahITM.SelUTx)
{
case "Default Preset":
_autoWahfx.Preset_HiFastAutoWah();
break;
}
}
else
{
Bass.BASS_ChannelRemoveFX(engine.ActiveStreamHandle, _fxAutoWahHandle);
}
}
public static void BASSVolumeSlideInit()
{
MainWindow.KMCGlobals._VolFX = Bass.BASS_ChannelSetFX((MainWindow.VSTs.VSTInfo[0].isInstrument ? MainWindow.VSTs._VSTiHandle : MainWindow.KMCGlobals._recHandle), BASSFXType.BASS_FX_VOLUME, 1);
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);
}
private void UpdateEQ(int band, float gain)
{
BASS_DX8_PARAMEQ eq = new BASS_DX8_PARAMEQ();
if (Bass.BASS_FXGetParameters(_fxEQ[band], eq))
{
eq.fGain = gain;
Bass.BASS_FXSetParameters(_fxEQ[band], eq);
}
}
protected virtual void UpdateDSP()
{
if (this.FChannel != null)
{
if (this.FChannel.BassHandle.HasValue && this.FDSPHandle != 0)
{
Bass.BASS_FXSetParameters(this.FDSPHandle, this.FDsp);
}
}
}
public static void UpdateEq(int band, double gain)
{
Eq[band] = gain;
var eq = new BASS_DX8_PARAMEQ();
if (Bass.BASS_FXGetParameters(FxEq[band], eq))
{
eq.fGain = (float)gain;
Bass.BASS_FXSetParameters(FxEq[band], eq);
}
}
//public void SetReverb(int progress)
//{
// BASS_DX8_REVERB p = new BASS_DX8_REVERB();
// Bass.BASS_FXGetParameters(fxReverb, p);
// p.fReverbMix = (float)(progress > 15 ? Math.Log((double)progress / 20.0) * 20.0 : -96.0);
// Bass.BASS_FXSetParameters(fxReverb, p);
//}
public void UpdateEQ(int band, float gain)
{
BASS_DX8_PARAMEQ p = new BASS_DX8_PARAMEQ();
if (Bass.BASS_FXGetParameters(fxBands[band], p))
{
gains[band] = gain;
p.fGain = gain;
Bass.BASS_FXSetParameters(fxBands[band], p);
}
}
public void UpdateCompressor()
{
BassEngine engine = BassEngine.Instance;
if (CompressorITM.switchx)
{
if (CompressorITM.fxState == false)
{
Bass.BASS_FXSetParameters(_fxCompressorHandle, _compressorfx);
}
if (CompressorITM.fxState == false)
{
_fxCompressorHandle = Bass.BASS_ChannelSetFX(engine.ActiveStreamHandle,
BASSFXType.BASS_FX_DX8_COMPRESSOR, 0);
}
switch (FlangerITM.SelUTx)
{
case "Default Preset":
_compressorfx.Preset_Default();
break;
case "Preset: Soft":
_compressorfx.Preset_Soft();
break;
case "Preset: Soft 2":
_compressorfx.Preset_Soft2();
break;
case "Preset: Medium":
_compressorfx.Preset_Medium();
break;
case "Preset: Hard":
_compressorfx.Preset_Hard();
break;
case "Preset: Hard 2":
_compressorfx.Preset_Hard2();
break;
case "Preset: Hard Commercial":
_compressorfx.Preset_HardCommercial();
break;
}
}
else
{
Bass.BASS_ChannelRemoveFX(engine.ActiveStreamHandle, _fxCompressorHandle);
}
}
private void SetBassEq(decimal gain)
{
// 3-band EQ
var eq = new BASS_DX8_PARAMEQ
{
fBandwidth = 18f,
fCenter = 100f,
fGain = (float)gain
};
Bass.BASS_FXSetParameters(_eqChannel, eq);
}
private void trackBarCompressor_ValueChanged(object sender, EventArgs e)
{
labelCompThreshold.Text = String.Format("Threshold: {0:#0.0} dB", trackBarCompressor.Value / 10d);
if (_stream == 0)
{
return;
}
_comp.fThreshold = (float)Un4seen.Bass.Utils.DBToLevel(trackBarCompressor.Value / 10d, 1.0);
Bass.BASS_FXSetParameters(_stream, _comp);
}
private void UpdateEQ(int band, float gain)
{
try
{
BASS_DX8_PARAMEQ eq = new BASS_DX8_PARAMEQ();
if (Bass.BASS_FXGetParameters(Player.PlayController.bassEng._fxEQ[band], eq))
{
eq.fGain = gain;
Bass.BASS_FXSetParameters(Player.PlayController.bassEng._fxEQ[band], eq);
}
}
catch { }
}
public void SetEQ(int index, float gain)
{
BASS_DX8_PARAMEQ eq = new BASS_DX8_PARAMEQ();
if (fxEQ.Length > 0)
{
if (Bass.BASS_FXGetParameters(fxEQ[index], eq))
{
eq.fGain = gain;
Bass.BASS_FXSetParameters(fxEQ[index], eq);
}
}
}
private void distAmount_Scroll(object sender, EventArgs e)
{
if (fxStream != 0)
{
// Изменение драйва и вета дисторшена
BASS_BFX_DISTORTION dist = new BASS_BFX_DISTORTION();
Bass.BASS_FXGetParameters(distortion, dist);
dist.fDrive = distAmount.Value;
dist.fWetMix = distAmount.Value / 3.0f;
Bass.BASS_FXSetParameters(distortion, dist);
}
}
