private void trackBarGain_ValueChanged(object sender, EventArgs e)
        {
            if (_gain == null)
            {
                _gain = new DSP_Gain();
            }

            this.textBoxGainDBValue.Text = Convert.ToString(trackBarGain.Value / 1000d);
            buttonSetGain_Click(this, EventArgs.Empty);
        }
        private void buttonSetGain_Click(object sender, EventArgs e)
        {
            if (_gain == null)
            {
                _gain = new DSP_Gain();
            }

            try
            {
                double gainDB = double.Parse(this.textBoxGainDBValue.Text);
                trackBarGain.Value = (int)(gainDB * 1000d);
                SetDSPGain(gainDB);
            }
            catch {}
        }
        private void SetDSPGain(double gainDB)
        {
            if (_gain == null)
            {
                _gain = new DSP_Gain();
            }

            if (gainDB == 0.0)
            {
                _gain.SetBypass(true);
            }
            else
            {
                _gain.SetBypass(false);
                _gain.Gain_dBV = gainDB;
            }
        }
        /// <summary>
        /// Sets the ReplayGain Value, which is read from the Tag of the file
        /// </summary>
        private void SetReplayGain()
        {
            _replayGainInfo.AlbumGain = null;
            _replayGainInfo.AlbumPeak = null;
            _replayGainInfo.TrackGain = null;
            _replayGainInfo.TrackPeak = null;

            _replayGainInfo.AlbumGain = ParseReplayGainTagValue(_musicTag.ReplayGainAlbum);
            _replayGainInfo.AlbumPeak = ParseReplayGainTagValue(_musicTag.ReplayGainAlbumPeak);
            _replayGainInfo.TrackGain = ParseReplayGainTagValue(_musicTag.ReplayGainTrack);
            _replayGainInfo.TrackPeak = ParseReplayGainTagValue(_musicTag.ReplayGainTrackPeak);

            if (_replayGainInfo.TrackGain.HasValue || _replayGainInfo.AlbumGain.HasValue)
            {
                Log.Debug("BASS: Replay Gain Data: Track Gain={0}dB, Track Peak={1}, Album Gain={2}dB, Album Peak={3}",
                          _replayGainInfo.TrackGain,
                          _replayGainInfo.TrackPeak,
                          _replayGainInfo.AlbumGain,
                          _replayGainInfo.AlbumPeak);
            }
            else
            {
                Log.Debug("BASS: No Replay Gain Information found in stream tags");
            }

            float?gain = null;

            if (Config.EnableAlbumReplayGain && _replayGainInfo.AlbumGain.HasValue)
            {
                gain = _replayGainInfo.AlbumGain;
            }
            else if (_replayGainInfo.TrackGain.HasValue)
            {
                gain = _replayGainInfo.TrackGain;
            }

            if (gain.HasValue)
            {
                Log.Debug("BASS: Setting Replay Gain to {0}dB", gain.Value);
                _gain = new DSP_Gain();
                _gain.ChannelHandle = _stream;
                _gain.Gain_dBV      = gain.Value;
                _gain.Start();
            }
        }
Exemple #5
0
        /*
         *  パブリックメソッド
         */
        #region PublicMethod

        /// <summary>
        /// ファイルをオープンする
        /// </summary>
        /// <param name="filePath">再生するファイル</param>
        public void open(string filePath)
        {
            // ストリーム生成
            if (StringUtils.isURL(filePath))
            {
                openStream(filePath);
            }
            else
            {
                sound[PlayerController.MainChannel] = Bass.BASS_StreamCreateFile(filePath, 0, 0, BASSFlag.BASS_DEFAULT);
                _filePath = filePath;

                if (sound[PlayerController.MainChannel] != 0)
                {
                    {
                        long   length  = Bass.BASS_ChannelGetLength(sound[PlayerController.MainChannel]);
                        double seconds = Bass.BASS_ChannelBytes2Seconds(sound[PlayerController.MainChannel], length);

                        // normalize
                        _gain = new DSP_Gain(sound[PlayerController.MainChannel], 0);
                    }
                }
            }
        }
        /// <summary>
        /// Sets the parameter for a given Bass effect
        /// </summary>
        /// <param name="id"></param>
        /// <param name="name"></param>
        /// <param name="value"></param>
        /// <param name="format"></param>
        private void setBassDSP(string id, string name, string value)
        {
            switch (id)
            {
            case "Gain":
                if (name == "Gain_dbV")
                {
                    double gainDB = double.Parse(value);
                    if (_gain == null)
                    {
                        _gain = new DSP_Gain();
                    }

                    if (gainDB == 0.0)
                    {
                        _gain.SetBypass(true);
                    }
                    else
                    {
                        _gain.SetBypass(false);
                        _gain.Gain_dBV = gainDB;
                    }
                }
                break;

            case "DynAmp":
                if (name == "Preset")
                {
                    if (_damp == null)
                    {
                        _damp = new BASS_BFX_DAMP();
                    }

                    switch (Convert.ToInt32(value))
                    {
                    case 0:
                        _damp.Preset_Soft();
                        break;

                    case 1:
                        _damp.Preset_Medium();
                        break;

                    case 2:
                        _damp.Preset_Hard();
                        break;
                    }
                }
                break;

            case "Compressor":
                if (name == "Threshold")
                {
                    if (_comp == null)
                    {
                        _comp = new BASS_BFX_COMPRESSOR();
                    }

                    _comp.Preset_Medium();
                    _comp.fThreshold = (float)Un4seen.Bass.Utils.DBToLevel(Convert.ToInt32(value) / 10d, 1.0);
                }
                break;
            }
        }
Exemple #7
0
        public void Init(int handle)
        {
            try
            {
                m_handle = handle;

                if (m_isEnabled)
                {
                    if (handle != -1)
                    {
                        BASS_BFX_PEAKEQ      eq     = new BASS_BFX_PEAKEQ();
                        BASS_BFX_COMPRESSOR2 comp   = new BASS_BFX_COMPRESSOR2();
                        BASS_BFX_VOLUME      preamp = new BASS_BFX_VOLUME();


                        m_bandValue = new BandValue();

                        // int compVal = Bass.BASS_ChannelSetFX(handle, BASSFXType.BASS_FX_BFX_COMPRESSOR2, 0);

                        // comp.lChannel = BASSFXChan.BASS_BFX_CHANALL;
                        //comp.fGain = 7.0f;
                        //comp.fAttack = 24.9f;
                        //comp.fRelease = 99.9f;
                        //comp.fThreshold = -11.0f;
                        //comp.fRatio = 4f;
                        // Bass.BASS_FXSetParameters(compVal, comp);

                        m_bandValue.Handle = Bass.BASS_ChannelSetFX(handle, BASSFXType.BASS_FX_BFX_PEAKEQ, 5);

                        if (m_dsp_gain != null)
                        {
                            m_dsp_gain.Dispose();
                        }
                        m_dsp_gain          = new DSP_Gain(handle, 6);
                        m_dsp_gain.Gain_dBV = ArrBandValue[10].PreAmp / 10;
                        //  m_preampHandle = Bass.BASS_ChannelSetFX(handle, BASSFXType.BASS_FX_BFX_VOLUME, 6);
                        //  preamp.lChannel = BASSFXChan.BASS_BFX_CHANNONE;
                        //  preamp.fVolume = (float)Math.Pow(10, (ArrBandValue[10].PreAmp / 10) / 20); //ArrBandValue[10].PreAmp;
                        //   Bass.BASS_FXSetParameters(m_preampHandle, preamp);

                        // m_handle = handle;

                        eq.fQ         = 0f;
                        eq.fBandwidth = 0.6f;
                        eq.lChannel   = BASSFXChan.BASS_BFX_CHANALL;

                        for (int i = 0; i < m_centers.Length; i++)
                        {
                            eq.lBand   = i;
                            eq.fCenter = m_centers[i];
                            Bass.BASS_FXSetParameters(m_bandValue.Handle, eq);
                            float gain = ArrBandValue[i].Gain;
                            UpdateEQBass(i, gain);
                            Console.WriteLine(m_bandValue.Handle + " : " + gain + " : " + i);
                        }
                    }
                    else
                    {
                        if (m_equalizer != null)
                        {
                            m_equalizer.Dispose();
                        }

                        m_equalizer = new Implementation.Equalizer();
                        // m_equalizer.Preamp = ArrBandValue[10].PreAmp / 10;

                        for (int i = 0; i < m_centers.Length; i++)
                        {
                            float gain = ArrBandValue[i].Gain;
                            UpdateEQVlc(i, gain);
                        }

                        // m_handle = handle;
                        m_bandValue.Handle = -1;
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.LogFile(ex.Message, "", "Init", ex.LineNumber(), "Equalizer Class");
            }
        }