Ejemplo n.º 1
0
        private void buttonPlay_Click(object sender, System.EventArgs e)
        {
            BassAsio.BASS_ASIO_Stop();
            BassAsio.BASS_ASIO_ChannelReset(false, -1, BASSASIOReset.BASS_ASIO_RESET_PAUSE | BASSASIOReset.BASS_ASIO_RESET_JOIN);
            Bass.BASS_StreamFree(_streamFX);
            if (_fileName != String.Empty)
            {
                // create the decoding stream
                _stream = Bass.BASS_StreamCreateFile(_fileName, 0, 0, BASSFlag.BASS_STREAM_DECODE | BASSFlag.BASS_SAMPLE_FLOAT);
                if (_stream != 0)
                {
                    // now we create a Tempo channel (again a decoding one)...the actual playing channel
                    _streamFX = BassFx.BASS_FX_TempoCreate(_stream, BASSFlag.BASS_STREAM_DECODE | BASSFlag.BASS_FX_FREESOURCE | BASSFlag.BASS_SAMPLE_FLOAT);
                    if (_streamFX == 0)
                    {
                        MessageBox.Show(this, "Can't create FX stream!", Enum.GetName(typeof(BASSError), Bass.BASS_ErrorGetCode()));
                        return;
                    }

                    // now setup ASIO
                    myAsioProc = new ASIOPROC(AsioCallback);

                    // get the stream channel info
                    BASS_CHANNELINFO info = new BASS_CHANNELINFO();
                    Bass.BASS_ChannelGetInfo(_streamFX, info);
                    _originSampleRate = (float)info.freq;
                    this.button2.Text = _originSampleRate.ToString("0");
                    // enable 1st output channel...(0=first)
                    BassAsio.BASS_ASIO_ChannelEnable(false, 0, myAsioProc, new IntPtr(_streamFX));
                    // and join the next channels to it
                    for (int a = 1; a < info.chans; a++)
                    {
                        BassAsio.BASS_ASIO_ChannelJoin(false, a, 0);
                    }
                    // since we joined the channels, the next commands will applay to all channles joined
                    // so setting the values to the first channels changes them all automatically
                    // set the source format (float, as the decoding channel is)
                    BassAsio.BASS_ASIO_ChannelSetFormat(false, 0, BASSASIOFormat.BASS_ASIO_FORMAT_FLOAT);
                    // set the source rate
                    BassAsio.BASS_ASIO_ChannelSetRate(false, 0, (double)info.freq);
                    // try to set the device rate too (saves resampling)
                    BassAsio.BASS_ASIO_SetRate((double)info.freq);
                    // and start playing it...
                    // start output using default buffer/latency
                    if (!BassAsio.BASS_ASIO_Start(0))
                    {
                        MessageBox.Show(this, "Can't start ASIO output", Enum.GetName(typeof(BASSError), BassAsio.BASS_ASIO_ErrorGetCode()));
                    }
                    else
                    {
                        this.labelStatus.Text = "playing";
                        this.timerUpdate.Start();
                    }
                }
            }
        }
Ejemplo n.º 2
0
        public void Asio_Setup(int dev)
        {
            if (!(dev == -1))
            {
                BassAsio.BASS_ASIO_Free();                             //przygotowanie BASS_Asio - zwolnienie istniejącego i
                Bass.BASS_Free();
                BassAsio.BASS_ASIO_SetDevice(dev);                     //wybór urządzenia

                if (!BassAsio.BASS_ASIO_Init(dev, 0))                  //inicjacja urządzenia + przechwycenie wyjątku
                {
                    BASSError blad = BassAsio.BASS_ASIO_ErrorGetCode(); MessageBox.Show("błąd inicjalizacji: " + blad.ToString());
                }
                else
                {
                    Bass.BASS_Init(-1, 48000, BASSInit.BASS_DEVICE_DEFAULT, IntPtr.Zero);

                    int strumien = Bass.BASS_StreamCreateFile(_hGCFile.AddrOfPinnedObject(), 0L, length, BASSFlag.BASS_STREAM_DECODE | BASSFlag.BASS_SAMPLE_FLOAT);
                    _myAsioProc = new Un4seen.BassAsio.ASIOPROC(AsioCallback);
                    BassAsio.BASS_ASIO_ChannelEnable(false, 0, _myAsioProc, new IntPtr(strumien));
                    int num_ch = 0;


                    if (binaural)
                    {
                        first_ch = Convert.ToInt16(textBox1.Text);
                        num_ch   = 2;
                    }
                    else
                    {
                        num_ch   = BitConverter.ToUInt16(audio_buffer, 22);
                        first_ch = 0;
                    }

                    for (int i = first_ch; i < num_ch + first_ch; i++)
                    {
                        BassAsio.BASS_ASIO_ChannelSetFormat(false, i, BASSASIOFormat.BASS_ASIO_FORMAT_FLOAT);
                    }
                    for (int i = first_ch + 1; i < num_ch + first_ch; i++)
                    {
                        BassAsio.BASS_ASIO_ChannelJoin(false, i, 0);
                    }
                }
            }
        }
Ejemplo n.º 3
0
        private bool setupChannel(int Frequency, BASSASIOFormat Format)
        {
            proc = new ASIOPROC(AsioCallback);

            BassAsio.BASS_ASIO_Stop();

            if (!BassAsio.BASS_ASIO_ChannelReset(false,
                                                 -1,
                                                 BASSASIOReset.BASS_ASIO_RESET_PAUSE | BASSASIOReset.BASS_ASIO_RESET_JOIN))
            {
                return(false);
            }

            if (!BassAsio.BASS_ASIO_ChannelEnable(false, 0, proc, IntPtr.Zero))
            {
                return(false);
            }

            if (!BassAsio.BASS_ASIO_ChannelJoin(false, 1, 0))
            {
                return(false);
            }

            if (!BassAsio.BASS_ASIO_ChannelSetFormat(false, 0, Format))
            {
                return(false);
            }

            BassAsio.BASS_ASIO_SetRate((double)Frequency);

            if (!BassAsio.BASS_ASIO_ChannelSetRate(false, 0, (double)Frequency))
            {
                return(false);
            }

            return(BassAsio.BASS_ASIO_Start(0));
        }
Ejemplo n.º 4
0
        /// <summary>
        /// Create a mixer using the stream attributes
        /// </summary>
        /// <param name="stream"></param>
        /// <returns></returns>
        public bool CreateMixer(MusicStream stream)
        {
            Log.Debug("BASS: ---------------------------------------------");
            Log.Debug("BASS: Creating BASS mixer stream");

            bool result = false;

            BASSFlag mixerFlags = BASSFlag.BASS_MIXER_NONSTOP | BASSFlag.BASS_SAMPLE_FLOAT | BASSFlag.BASS_MIXER_NORAMPIN;

            if (Config.MusicPlayer == AudioPlayer.Asio || Config.MusicPlayer == AudioPlayer.WasApi)
            {
                mixerFlags |= BASSFlag.BASS_STREAM_DECODE;
            }

            int outputChannels = _bassPlayer.DeviceChannels;

            _mixingMatrix = null;

            // See, if we need Upmixing
            if (outputChannels > stream.ChannelInfo.chans)
            {
                Log.Debug("BASS: Found more output channels ({0}) than input channels ({1}). Check for upmixing.", outputChannels,
                          stream.ChannelInfo.chans);
                _mixingMatrix = CreateMixingMatrix(stream.ChannelInfo.chans);
                if (_mixingMatrix != null)
                {
                    outputChannels = Math.Min(_mixingMatrix.GetLength(0), outputChannels);
                    _upmixing      = true;
                }
                else
                {
                    outputChannels = stream.ChannelInfo.chans;
                }
            }
            else if (outputChannels < stream.ChannelInfo.chans)
            {
                // Downmix to Stereo
                Log.Debug("BASS: Found more input channels ({0}) than output channels ({1}). Downmix.", stream.ChannelInfo.chans,
                          outputChannels);
                outputChannels = Math.Min(outputChannels, 2);
            }

            Log.Debug("BASS: Creating {0} channel mixer with sample rate of {1}", outputChannels, stream.ChannelInfo.freq);
            _mixer = BassMix.BASS_Mixer_StreamCreate(stream.ChannelInfo.freq, outputChannels, mixerFlags);
            if (_mixer == 0)
            {
                Log.Error("BASS: Unable to create Mixer.  Reason: {0}.",
                          Enum.GetName(typeof(BASSError), Bass.BASS_ErrorGetCode()));
                return(false);
            }

            switch (Config.MusicPlayer)
            {
            case AudioPlayer.Bass:
            case AudioPlayer.DShow:

                if (!Bass.BASS_ChannelPlay(_mixer, false))
                {
                    Log.Error("BASS: Unable to start Mixer.  Reason: {0}.", Enum.GetName(typeof(BASSError), Bass.BASS_ErrorGetCode()));
                    return(false);
                }

                result = true;

                break;

            case AudioPlayer.Asio:

                Log.Info("BASS: Initialising ASIO device");

                if (BassAsio.BASS_ASIO_IsStarted() && !BassAsio.BASS_ASIO_Stop())
                {
                    Log.Error("BASS: Error stopping Asio Device: {0}", BassAsio.BASS_ASIO_ErrorGetCode());
                }

                // Disable and Unjoin all the channels
                if (!BassAsio.BASS_ASIO_ChannelReset(false, -1, BASSASIOReset.BASS_ASIO_RESET_ENABLE))
                {
                    Log.Error("BASS: Error disabling Asio Channels: {0}", BassAsio.BASS_ASIO_ErrorGetCode());
                }

                if (!BassAsio.BASS_ASIO_ChannelReset(false, -1, BASSASIOReset.BASS_ASIO_RESET_JOIN))
                {
                    Log.Error("BASS: Error unjoining Asio Channels: {0}", BassAsio.BASS_ASIO_ErrorGetCode());
                }

                _asioProc = new ASIOPROC(AsioCallback);

                BassAsio.BASS_ASIO_ChannelSetVolume(false, -1, (float)Config.StreamVolume / 100f);

                // enable 1st output channel...(0=first)
                Log.Debug("BASS: Joining Asio Channel #{0}", "0");
                BassAsio.BASS_ASIO_ChannelEnable(false, 0, _asioProc, new IntPtr(_mixer));

                // and join the next channels to it
                int numChannels = Math.Max(stream.ChannelInfo.chans, outputChannels);
                for (int i = 1; i < numChannels; i++)
                {
                    Log.Debug("BASS: Joining Asio Channel #{0}", i);
                    BassAsio.BASS_ASIO_ChannelJoin(false, i, 0);
                }

                // since we joined the channels, the next commands will apply to all channles joined
                // so setting the values to the first channels changes them all automatically
                // set the source format (float, as the decoding channel is)
                if (!BassAsio.BASS_ASIO_ChannelSetFormat(false, 0, BASSASIOFormat.BASS_ASIO_FORMAT_FLOAT))
                {
                    Log.Error("BASS: Error setting Asio Sample Format: {0}", BassAsio.BASS_ASIO_ErrorGetCode());
                }

                // set the source rate
                Log.Debug("BASS: Set sample rate to {0}", stream.ChannelInfo.freq);
                if (!BassAsio.BASS_ASIO_ChannelSetRate(false, 0, (double)stream.ChannelInfo.freq))
                {
                    Log.Error("BASS: Error setting Asio Channel Samplerate: {0}", BassAsio.BASS_ASIO_ErrorGetCode());
                }

                // try to set the device rate too (saves resampling)
                if (!BassAsio.BASS_ASIO_SetRate((double)stream.ChannelInfo.freq))
                {
                    Log.Error("BASS: Error setting Asio Samplerate: {0}", BassAsio.BASS_ASIO_ErrorGetCode());
                }

                // and start playing it...start output using default buffer/latency
                if (!BassAsio.BASS_ASIO_Start(0))
                {
                    Log.Error("BASS: Error starting Asio playback: {0}", BassAsio.BASS_ASIO_ErrorGetCode());
                }
                Log.Info("BASS: Finished initialising ASIO device");
                result = true;

                break;

            case AudioPlayer.WasApi:

                Log.Info("BASS: Initialising WASAPI device");

                try
                {
                    BassWasapi.BASS_WASAPI_Free();
                    Log.Debug("BASS: Freed WASAPI device");
                }
                catch (Exception ex)
                {
                    Log.Error("BASS: Exception freeing WASAPI. {0} {1}", ex.Message, ex.StackTrace);
                }

                BASSWASAPIInit initFlags = BASSWASAPIInit.BASS_WASAPI_AUTOFORMAT;

                _wasapiProc = new WASAPIPROC(WasApiCallback);

                bool wasApiExclusiveSupported = true;

                // Check if we have an uneven number of channels
                var chkChannels = outputChannels % 2;
                if (chkChannels == 1)
                {
                    Log.Warn("BASS: Found uneven number of channels {0}. increase output channels.", outputChannels);
                    outputChannels++;                 // increase the number of output channels
                    wasApiExclusiveSupported = false; // And indicate that we need a new mixer
                }

                // Handle the special cases of 3.0, 4.0 and 5.0 files being played on a 5.1 or 6.1 device
                if (outputChannels == 3) // a 3.0 file
                {
                    Log.Info("BASS: Found a 3 channel file. Set upmixing with LFE, LR, RR set to silent");
                    _mixingMatrix            = CreateThreeDotZeroUpMixMatrix();
                    outputChannels           = _bassPlayer.DeviceChannels; // WASAPI device should be initialised with all channels active
                    wasApiExclusiveSupported = false;                      // And indicate that we need a new mixer
                }
                else if (outputChannels == 4)                              // a 4.0 file
                {
                    Log.Info("BASS: Found a 4 channel file. Set upmixing with Center and LFE set to silent");
                    _mixingMatrix            = CreateFourDotZeroUpMixMatrix();
                    outputChannels           = _bassPlayer.DeviceChannels; // WASAPI device should be initialised with all channels active
                    wasApiExclusiveSupported = false;                      // And indicate that we need a new mixer
                }
                else if (outputChannels == 5)                              // a 5.0 file
                {
                    Log.Info("BASS: Found a 5 channel file. Set upmixing with LFE set to silent");
                    _mixingMatrix            = CreateFiveDotZeroUpMixMatrix();
                    outputChannels           = _bassPlayer.DeviceChannels; // WASAPI device should be initialised with all channels active
                    wasApiExclusiveSupported = false;                      // And indicate that we need a new mixer
                }

                // If Exclusive mode is used, check, if that would be supported, otherwise init in shared mode
                if (Config.WasApiExclusiveMode)
                {
                    initFlags        |= BASSWASAPIInit.BASS_WASAPI_EXCLUSIVE;
                    _wasapiShared     = false;
                    _wasapiMixedChans = 0;
                    _wasapiMixedFreq  = 0;

                    BASSWASAPIFormat wasapiFormat = BassWasapi.BASS_WASAPI_CheckFormat(_bassPlayer.DeviceNumber,
                                                                                       stream.ChannelInfo.freq,
                                                                                       outputChannels,
                                                                                       BASSWASAPIInit.BASS_WASAPI_EXCLUSIVE);
                    if (wasapiFormat == BASSWASAPIFormat.BASS_WASAPI_FORMAT_UNKNOWN)
                    {
                        Log.Warn("BASS: WASAPI exclusive mode not directly supported. Let BASS WASAPI choose better mode.");
                        wasApiExclusiveSupported = false;
                    }
                }
                else
                {
                    Log.Debug("BASS: Init WASAPI shared mode with Event driven system enabled.");
                    initFlags |= BASSWASAPIInit.BASS_WASAPI_SHARED | BASSWASAPIInit.BASS_WASAPI_EVENT;

                    // In case of WASAPI Shared mode we need to setup the mixer to use the same sample rate as set in
                    // the Windows Mixer, otherwise we wioll have increased playback speed
                    BASS_WASAPI_DEVICEINFO devInfo = BassWasapi.BASS_WASAPI_GetDeviceInfo(_bassPlayer.DeviceNumber);
                    Log.Debug("BASS: Creating {0} channel mixer for frequency {1}", devInfo.mixchans, devInfo.mixfreq);
                    _mixer = BassMix.BASS_Mixer_StreamCreate(devInfo.mixfreq, devInfo.mixchans, mixerFlags);
                    if (_mixer == 0)
                    {
                        Log.Error("BASS: Unable to create Mixer.  Reason: {0}.",
                                  Enum.GetName(typeof(BASSError), Bass.BASS_ErrorGetCode()));
                        return(false);
                    }
                    _wasapiShared = true;
                }

                Log.Debug("BASS: Try to init WASAPI with a Frequency of {0} and {1} channels", stream.ChannelInfo.freq, outputChannels);

                if (BassWasapi.BASS_WASAPI_Init(_bassPlayer.DeviceNumber, stream.ChannelInfo.freq, outputChannels,
                                                initFlags | BASSWASAPIInit.BASS_WASAPI_BUFFER, Convert.ToSingle(Config.BufferingMs / 1000.0), 0f, _wasapiProc, IntPtr.Zero))
                {
                    BASS_WASAPI_INFO wasapiInfo = BassWasapi.BASS_WASAPI_GetInfo();

                    Log.Debug("BASS: ---------------------------------------------");
                    Log.Debug("BASS: Buffer Length: {0}", wasapiInfo.buflen);
                    Log.Debug("BASS: Channels: {0}", wasapiInfo.chans);
                    Log.Debug("BASS: Frequency: {0}", wasapiInfo.freq);
                    Log.Debug("BASS: Format: {0}", wasapiInfo.format.ToString());
                    Log.Debug("BASS: InitFlags: {0}", wasapiInfo.initflags.ToString());
                    Log.Debug("BASS: Exclusive: {0}", wasapiInfo.IsExclusive.ToString());
                    Log.Debug("BASS: ---------------------------------------------");
                    Log.Info("BASS: WASAPI Device successfully initialised");

                    // Now we need to check, if WASAPI decided to switch to a different mode
                    if (Config.WasApiExclusiveMode && !wasApiExclusiveSupported)
                    {
                        // Recreate Mixer with new value
                        Log.Debug("BASS: Creating new {0} channel mixer for frequency {1}", wasapiInfo.chans, wasapiInfo.freq);
                        _mixer = BassMix.BASS_Mixer_StreamCreate(wasapiInfo.freq, wasapiInfo.chans, mixerFlags);
                        if (_mixer == 0)
                        {
                            Log.Error("BASS: Unable to create Mixer.  Reason: {0}.",
                                      Enum.GetName(typeof(BASSError), Bass.BASS_ErrorGetCode()));
                            return(false);
                        }
                    }

                    BassWasapi.BASS_WASAPI_SetVolume(BASSWASAPIVolume.BASS_WASAPI_CURVE_DB, (float)Config.StreamVolume / 100f);
                    BassWasapi.BASS_WASAPI_Start();
                    result = true;
                }
                else
                {
                    Log.Error("BASS: Couldn't init WASAPI device. Error: {0}", Enum.GetName(typeof(BASSError), Bass.BASS_ErrorGetCode()));
                }
                break;
            }

            if (result)
            {
                Log.Debug("BASS: Successfully created BASS Mixer stream");
            }
            return(result);
        }
Ejemplo n.º 5
0
        // メソッド

        public CSoundDeviceASIO(long n希望バッファサイズms, int _nASIODevice)
        {
            // 初期化。

            Trace.TraceInformation("BASS (ASIO) の初期化を開始します。");
            this.e出力デバイス            = ESoundDeviceType.Unknown;
            this.n実出力遅延ms           = 0;
            this.n経過時間ms            = 0;
            this.n経過時間を更新したシステム時刻ms = CTimer.n未使用;
            this.tmシステムタイマ          = new CTimer();
            this.nASIODevice        = _nASIODevice;

            #region [ BASS registration ]
            // BASS.NET ユーザ登録(BASSスプラッシュが非表示になる)。
            BassNet.Registration("*****@*****.**", "2X9181017152222");
            #endregion

            #region [ BASS Version Check ]
            // BASS のバージョンチェック。
            int nBASSVersion = Utils.HighWord(Bass.BASS_GetVersion());
            if (nBASSVersion != Bass.BASSVERSION)
            {
                throw new DllNotFoundException(string.Format("bass.dll のバージョンが異なります({0})。このプログラムはバージョン{1}で動作します。", nBASSVersion, Bass.BASSVERSION));
            }

            int nBASSMixVersion = Utils.HighWord(BassMix.BASS_Mixer_GetVersion());
            if (nBASSMixVersion != BassMix.BASSMIXVERSION)
            {
                throw new DllNotFoundException(string.Format("bassmix.dll のバージョンが異なります({0})。このプログラムはバージョン{1}で動作します。", nBASSMixVersion, BassMix.BASSMIXVERSION));
            }

            int nBASSASIO = Utils.HighWord(BassAsio.BASS_ASIO_GetVersion());
            if (nBASSASIO != BassAsio.BASSASIOVERSION)
            {
                throw new DllNotFoundException(string.Format("bassasio.dll のバージョンが異なります({0})。このプログラムはバージョン{1}で動作します。", nBASSASIO, BassAsio.BASSASIOVERSION));
            }
            #endregion

            // BASS の設定。

            this.bIsBASSFree = true;

            if (!Bass.BASS_SetConfig(BASSConfig.BASS_CONFIG_UPDATEPERIOD, 0))           // 0:BASSストリームの自動更新を行わない。
            {
                Trace.TraceWarning($"BASS_SetConfig({nameof(BASSConfig.BASS_CONFIG_UPDATEPERIOD)}) に失敗しました。[{Bass.BASS_ErrorGetCode()}]");
            }
            if (!Bass.BASS_SetConfig(BASSConfig.BASS_CONFIG_UPDATETHREADS, 0))           // 0:BASSストリームの自動更新を行わない。
            {
                Trace.TraceWarning($"BASS_SetConfig({nameof(BASSConfig.BASS_CONFIG_UPDATETHREADS)}) に失敗しました。[{Bass.BASS_ErrorGetCode()}]");
            }

            // BASS の初期化。

            int nデバイス = 0;                      // 0:"no device" … BASS からはデバイスへアクセスさせない。アクセスは BASSASIO アドオンから行う。
            int n周波数  = 44100;                  // 仮決め。最終的な周波数はデバイス(≠ドライバ)が決める。
            if (!Bass.BASS_Init(nデバイス, n周波数, BASSInit.BASS_DEVICE_DEFAULT, IntPtr.Zero))
            {
                throw new Exception(string.Format("BASS の初期化に失敗しました。(BASS_Init)[{0}]", Bass.BASS_ErrorGetCode().ToString()));
            }

            Bass.BASS_SetConfig(BASSConfig.BASS_CONFIG_CURVE_VOL, true);

//Debug.WriteLine( "BASS_Init()完了。" );
            #region [ デバッグ用: ASIOデバイスのenumerateと、ログ出力 ]
//			CEnumerateAllAsioDevices.GetAllASIODevices();
//Debug.WriteLine( "BassAsio.BASS_ASIO_GetDeviceInfo():" );
//            int a, count = 0;
//            BASS_ASIO_DEVICEINFO asioDevInfo;
//            for ( a = 0; ( asioDevInfo = BassAsio.BASS_ASIO_GetDeviceInfo( a ) ) != null; a++ )
//            {
//                Trace.TraceInformation( "ASIO Device {0}: {1}, driver={2}", a, asioDevInfo.name, asioDevInfo.driver );
//                count++; // count it
//            }
            #endregion

            // BASS ASIO の初期化。
            BASS_ASIO_INFO asioInfo = null;
            if (BassAsio.BASS_ASIO_Init(nASIODevice, BASSASIOInit.BASS_ASIO_THREAD))                    // 専用スレッドにて起動
            {
                #region [ ASIO の初期化に成功。]
                //-----------------
                this.e出力デバイス           = ESoundDeviceType.ASIO;
                asioInfo               = BassAsio.BASS_ASIO_GetInfo();
                this.n出力チャンネル数         = asioInfo.outputs;
                this.db周波数             = BassAsio.BASS_ASIO_GetRate();
                this.fmtASIOデバイスフォーマット = BassAsio.BASS_ASIO_ChannelGetFormat(false, 0);

                Trace.TraceInformation("BASS を初期化しました。(ASIO, デバイス:\"{0}\", 入力{1}, 出力{2}, {3}Hz, バッファ{4}~{6}sample ({5:0.###}~{7:0.###}ms), デバイスフォーマット:{8})",
                                       asioInfo.name,
                                       asioInfo.inputs,
                                       asioInfo.outputs,
                                       this.db周波数.ToString("0.###"),
                                       asioInfo.bufmin, asioInfo.bufmin * 1000 / this.db周波数,
                                       asioInfo.bufmax, asioInfo.bufmax * 1000 / this.db周波数,
                                       this.fmtASIOデバイスフォーマット.ToString()
                                       );
                this.bIsBASSFree = false;
                #region [ debug: channel format ]
                //BASS_ASIO_CHANNELINFO chinfo = new BASS_ASIO_CHANNELINFO();
                //int chan = 0;
                //while ( true )
                //{
                //    if ( !BassAsio.BASS_ASIO_ChannelGetInfo( false, chan, chinfo ) )
                //        break;
                //    Debug.WriteLine( "Ch=" + chan + ": " + chinfo.name.ToString() + ", " + chinfo.group.ToString() + ", " + chinfo.format.ToString() );
                //    chan++;
                //}
                #endregion
                //-----------------
                #endregion
            }
            else
            {
                #region [ ASIO の初期化に失敗。]
                //-----------------
                BASSError errcode = Bass.BASS_ErrorGetCode();
                string    errmes  = errcode.ToString();
                if (errcode == BASSError.BASS_OK)
                {
                    errmes = "BASS_OK; The device may be dissconnected";
                }
                Bass.BASS_Free();
                this.bIsBASSFree = true;
                throw new Exception(string.Format("BASS (ASIO) の初期化に失敗しました。(BASS_ASIO_Init)[{0}]", errmes));
                //-----------------
                #endregion
            }


            // ASIO 出力チャンネルの初期化。

            this.tAsioProc = new ASIOPROC(this.tAsio処理);                                  // アンマネージに渡す delegate は、フィールドとして保持しておかないとGCでアドレスが変わってしまう。
            if (!BassAsio.BASS_ASIO_ChannelEnable(false, 0, this.tAsioProc, IntPtr.Zero)) // 出力チャンネル0 の有効化。
            {
                #region [ ASIO 出力チャンネルの初期化に失敗。]
                //-----------------
                BassAsio.BASS_ASIO_Free();
                Bass.BASS_Free();
                this.bIsBASSFree = true;
                throw new Exception(string.Format("Failed BASS_ASIO_ChannelEnable() [{0}]", BassAsio.BASS_ASIO_ErrorGetCode().ToString()));
                //-----------------
                #endregion
            }
            for (int i = 1; i < this.n出力チャンネル数; i++)                            // 出力チャネルを全てチャネル0とグループ化する。
            {                                                                   // チャネル1だけを0とグループ化すると、3ch以上の出力をサポートしたカードでの動作がおかしくなる
                if (!BassAsio.BASS_ASIO_ChannelJoin(false, i, 0))
                {
                    #region [ 初期化に失敗。]
                    //-----------------
                    BassAsio.BASS_ASIO_Free();
                    Bass.BASS_Free();
                    this.bIsBASSFree = true;
                    throw new Exception(string.Format("Failed BASS_ASIO_ChannelJoin({1}) [{0}]", BassAsio.BASS_ASIO_ErrorGetCode().ToString(), i));
                    //-----------------
                    #endregion
                }
            }
            if (!BassAsio.BASS_ASIO_ChannelSetFormat(false, 0, this.fmtASIOチャンネルフォーマット))                        // 出力チャンネル0のフォーマット
            {
                #region [ ASIO 出力チャンネルの初期化に失敗。]
                //-----------------
                BassAsio.BASS_ASIO_Free();
                Bass.BASS_Free();
                this.bIsBASSFree = true;
                throw new Exception(string.Format("Failed BASS_ASIO_ChannelSetFormat() [{0}]", BassAsio.BASS_ASIO_ErrorGetCode().ToString()));
                //-----------------
                #endregion
            }

            // ASIO 出力と同じフォーマットを持つ BASS ミキサーを作成。

            var flag = BASSFlag.BASS_MIXER_NONSTOP | BASSFlag.BASS_STREAM_DECODE;               // デコードのみ=発声しない。ASIO に出力されるだけ。
            if (this.fmtASIOデバイスフォーマット == BASSASIOFormat.BASS_ASIO_FORMAT_FLOAT)
            {
                flag |= BASSFlag.BASS_SAMPLE_FLOAT;
            }
            this.hMixer = BassMix.BASS_Mixer_StreamCreate((int)this.db周波数, this.n出力チャンネル数, flag);

            if (this.hMixer == 0)
            {
                BASSError err = Bass.BASS_ErrorGetCode();
                BassAsio.BASS_ASIO_Free();
                Bass.BASS_Free();
                this.bIsBASSFree = true;
                throw new Exception(string.Format("BASSミキサ(mixing)の作成に失敗しました。[{0}]", err));
            }

            // BASS ミキサーの1秒あたりのバイト数を算出。

            var mixerInfo    = Bass.BASS_ChannelGetInfo(this.hMixer);
            int nサンプルサイズbyte = 0;
            switch (this.fmtASIOチャンネルフォーマット)
            {
            case BASSASIOFormat.BASS_ASIO_FORMAT_16BIT: nサンプルサイズbyte = 2; break;

            case BASSASIOFormat.BASS_ASIO_FORMAT_24BIT: nサンプルサイズbyte = 3; break;

            case BASSASIOFormat.BASS_ASIO_FORMAT_32BIT: nサンプルサイズbyte = 4; break;

            case BASSASIOFormat.BASS_ASIO_FORMAT_FLOAT: nサンプルサイズbyte = 4; break;
            }
            //long nミキサーの1サンプルあたりのバイト数 = /*mixerInfo.chans*/ 2 * nサンプルサイズbyte;
            long nミキサーの1サンプルあたりのバイト数 = mixerInfo.chans * nサンプルサイズbyte;
            this.nミキサーの1秒あたりのバイト数 = nミキサーの1サンプルあたりのバイト数 * mixerInfo.freq;


            // 単純に、hMixerの音量をMasterVolumeとして制御しても、
            // ChannelGetData()の内容には反映されない。
            // そのため、もう一段mixerを噛ませて、一段先のmixerからChannelGetData()することで、
            // hMixerの音量制御を反映させる。
            this.hMixer_DeviceOut = BassMix.BASS_Mixer_StreamCreate(
                (int)this.db周波数, this.n出力チャンネル数, flag);
            if (this.hMixer_DeviceOut == 0)
            {
                BASSError errcode = Bass.BASS_ErrorGetCode();
                BassAsio.BASS_ASIO_Free();
                Bass.BASS_Free();
                this.bIsBASSFree = true;
                throw new Exception(string.Format("BASSミキサ(最終段)の作成に失敗しました。[{0}]", errcode));
            }
            {
                bool b1 = BassMix.BASS_Mixer_StreamAddChannel(this.hMixer_DeviceOut, this.hMixer, BASSFlag.BASS_DEFAULT);
                if (!b1)
                {
                    BASSError errcode = Bass.BASS_ErrorGetCode();
                    BassAsio.BASS_ASIO_Free();
                    Bass.BASS_Free();
                    this.bIsBASSFree = true;
                    throw new Exception(string.Format("BASSミキサ(最終段とmixing)の接続に失敗しました。[{0}]", errcode));
                }
                ;
            }


            // 出力を開始。

            this.nバッファサイズsample = (int)(n希望バッファサイズms * this.db周波数 / 1000.0);
            //this.nバッファサイズsample = (int)  nバッファサイズbyte;
            if (!BassAsio.BASS_ASIO_Start(this.nバッファサイズsample))                         // 範囲外の値を指定した場合は自動的にデフォルト値に設定される。
            {
                BASSError err = BassAsio.BASS_ASIO_ErrorGetCode();
                BassAsio.BASS_ASIO_Free();
                Bass.BASS_Free();
                this.bIsBASSFree = true;
                throw new Exception("ASIO デバイス出力開始に失敗しました。" + err.ToString());
            }
            else
            {
                int n遅延sample   = BassAsio.BASS_ASIO_GetLatency(false);                 // この関数は BASS_ASIO_Start() 後にしか呼び出せない。
                int n希望遅延sample = (int)(n希望バッファサイズms * this.db周波数 / 1000.0);
                this.n実バッファサイズms = this.n実出力遅延ms = (long)(n遅延sample * 1000.0f / this.db周波数);
                Trace.TraceInformation("ASIO デバイス出力開始:バッファ{0}sample(希望{1}) [{2}ms(希望{3}ms)]", n遅延sample, n希望遅延sample, this.n実出力遅延ms, n希望バッファサイズms);
            }
        }
Ejemplo n.º 6
0
        public static void SetDevice(int inputChannel, int outputChannel)
        {
            //  Bass.BASS_SetConfig(BASSConfig.BASS_CONFIG_UPDATEPERIOD, 0);
            //   Bass.BASS_SetConfig(BASSConfig.BASS_CONFIG_FLOATDSP, true);
            // BassAsio.BASS_ASIO_Init(0, BASSASIOInit.BASS_ASIO_DEFAULT);
            //   Bass.BASS_Init(0, (int)samplerate, 0, IntPtr.Zero);

            //   m_asioInputHandlers = new BassAsioHandler();
            //   m_asioOutputHandlers = new BassAsioHandler();
            devinfo              = new BASS_ASIO_DEVICEINFO();
            m_asioInputChannels  = new List <object>();
            m_asioOutputChannels = new List <object>();
            thisControl          = PlayerControl.MainFormControl;
            m_inputChannel       = inputChannel;
            m_outputChannel      = outputChannel;

            /*   for (int n = 0; BassAsio.BASS_ASIO_GetDeviceInfo(n, devinfo); n++)
             * {
             *     if (devinfo.name.Contains("ASIO4ALL"))
             *     {
             *         if (!BassAsio.BASS_ASIO_IsStarted())
             *             BassAsio.BASS_ASIO_Init(n, BASSASIOInit.BASS_ASIO_DEFAULT);
             *
             *         samplerate = BassAsio.BASS_ASIO_GetRate();
             *         m_asiodevice = n;
             *
             *         BASS_ASIO_INFO asioinfo = BassAsio.BASS_ASIO_GetInfo();
             *         if (asioinfo != null)
             *         {
             *             // assuming stereo input
             *             for (int i = 0; i < asioinfo.inputs; i += 2)
             *             {
             *                 BASS_ASIO_CHANNELINFO chanInfo = BassAsio.BASS_ASIO_ChannelGetInfo(true, i);
             *                 if (chanInfo != null)
             *                     GetAsioInputChannels.Add(chanInfo);
             *
             *                 if (chanInfo.name.Contains("VB-Audio Point 1"))
             *                     GetVlcAsioInputChannel = i;
             *             }
             *
             *             for (int o = 0; o < asioinfo.outputs; o += 2)
             *             {
             *                 BASS_ASIO_CHANNELINFO chanInfo = BassAsio.BASS_ASIO_ChannelGetInfo(false, o);
             *                 if (chanInfo != null)
             *                     GetAsioOutputChannels.Add(chanInfo);
             *             }
             *         }
             *     }
             *
             * }
             *
             * CreateInputs(m_inputChannel);
             * CreateOutput(m_outputChannel);
             * Connect();
             * int ggg = 0;*/


            for (int n = 0; BassAsio.BASS_ASIO_GetDeviceInfo(n, devinfo); n++)
            {
                if (devinfo.name.Contains("ASIO4ALL"))
                {
                    if (!BassAsio.BASS_ASIO_IsStarted())
                    {
                        BassAsio.BASS_ASIO_Init(n, BASSASIOInit.BASS_ASIO_THREAD);
                    }

                    samplerate   = BassAsio.BASS_ASIO_GetRate();
                    m_asiodevice = n;

                    BASS_ASIO_INFO asioinfo = BassAsio.BASS_ASIO_GetInfo();
                    if (asioinfo != null)
                    {
                        // assuming stereo input
                        for (int i = 0; i < asioinfo.inputs; i += 2)
                        {
                            BASS_ASIO_CHANNELINFO chanInfo = BassAsio.BASS_ASIO_ChannelGetInfo(true, i);
                            if (chanInfo != null)
                            {
                                GetAsioInputChannels.Add(chanInfo);
                            }

                            if (chanInfo.name.Contains("VB-Audio Point 1"))
                            {
                                VlcAsioInputChannel = i;
                            }
                        }

                        for (int o = 0; o < asioinfo.outputs; o += 2)
                        {
                            BASS_ASIO_CHANNELINFO chanInfo = BassAsio.BASS_ASIO_ChannelGetInfo(false, o);
                            if (chanInfo != null)
                            {
                                AsioOutputChannels.Add(chanInfo);
                            }
                        }
                    }

                    BassAsio.BASS_ASIO_ChannelSetVolume(true, m_inputChannel, PlayerControl.MicVolumeScroll.Value * 0.01f);
                    BassAsio.BASS_ASIO_ChannelSetVolume(true, m_inputChannel + 1, PlayerControl.MicVolumeScroll.Value * 0.01f);

                    _asioProc = new ASIOPROC(AsioCallback);
                }
            }

            if (!m_bassinit)
            {
                Bass.BASS_SetConfig(BASSConfig.BASS_CONFIG_UPDATEPERIOD, 0);
                Bass.BASS_SetConfig(BASSConfig.BASS_CONFIG_FLOATDSP, true);
                Bass.BASS_Init(0, 48000, 0, IntPtr.Zero);

                Player.Mixer = MixerStreamCreate((int)samplerate);

                if (Player.Mixer == 0)
                {
                    var error = Bass.BASS_ErrorGetCode();
                    MessageBox.Show(error.ToString(), "Could not create mixer!");
                    Bass.BASS_Free();
                    return;
                }

                m_mixerChannel = Player.Mixer;

                m_streamInputMic = Bass.BASS_StreamCreatePush((int)samplerate, 2, BASSFlag.BASS_STREAM_DECODE | BASSFlag.BASS_SAMPLE_FLOAT, IntPtr.Zero);
                StreamInputVlc   = Bass.BASS_StreamCreatePush((int)samplerate, 2, BASSFlag.BASS_STREAM_DECODE | BASSFlag.BASS_SAMPLE_FLOAT, IntPtr.Zero);

                //m_streamInputMic = Bass.BASS_StreamCreateFile(f, 0L, 0L, BASSFlag.BASS_STREAM_DECODE | BASSFlag.BASS_SAMPLE_FLOAT | BASSFlag.BASS_SAMPLE_LOOP);
                //m_stream[0] = BassMix.BASS_Split_StreamCreate(m_streamInputMic, BASSFlag.BASS_SAMPLE_FLOAT | BASSFlag.BASS_STREAM_DECODE, null);//_instream;
                //m_stream[1] = BassMix.BASS_Split_StreamCreate(m_streamInputMic, BASSFlag.BASS_SAMPLE_FLOAT | BASSFlag.BASS_STREAM_DECODE, null);// _instream;
                //m_stream[2] = BassMix.BASS_Split_StreamCreate(m_streamInputMic, BASSFlag.BASS_SAMPLE_FLOAT | BASSFlag.BASS_STREAM_DECODE, null);//_instream;
                //m_stream[3] = BassMix.BASS_Split_StreamCreate(m_streamInputMic, BASSFlag.BASS_SAMPLE_FLOAT | BASSFlag.BASS_STREAM_DECODE, null);//_instream;


                //Group 1 VST Effects ============================================================
                Channel1Fx.SetEffects(m_streamInputMic);


                //Group 2 VST Effects ============================================================
                // Channel2Fx.SetEffects(m_stream[1]);


                //Group 3 VST Effects ============================================================
                // Channel3Fx.SetEffects(m_stream[2]);


                //Group 4 VST Effects ============================================================
                // Channel4Fx.SetEffects(m_stream[3]);

                BassMix.BASS_Mixer_StreamAddChannel(m_mixerChannel, StreamInputVlc, BASSFlag.BASS_MIXER_DOWNMIX | BASSFlag.BASS_STREAM_AUTOFREE);
                BassMix.BASS_Mixer_StreamAddChannel(m_mixerChannel, m_streamInputMic, BASSFlag.BASS_MIXER_DOWNMIX | BASSFlag.BASS_STREAM_AUTOFREE);
                // BassMix.BASS_Mixer_StreamAddChannel(m_mixerChannel, m_stream[1], BASSFlag.BASS_MIXER_DOWNMIX | BASSFlag.BASS_STREAM_AUTOFREE);
                //BassMix.BASS_Mixer_StreamAddChannel(m_mixerChannel, m_stream[2], BASSFlag.BASS_MIXER_DOWNMIX | BASSFlag.BASS_STREAM_AUTOFREE);
                //BassMix.BASS_Mixer_StreamAddChannel(m_mixerChannel, m_stream[3], BASSFlag.BASS_MIXER_DOWNMIX | BASSFlag.BASS_STREAM_AUTOFREE);
                BASS_CHANNELINFO info = Bass.BASS_ChannelGetInfo(m_mixerChannel);

                m_bassinit = true;
            }

            //BassAsio.BASS_ASIO_ControlPanel();
            BassAsio.BASS_ASIO_ChannelEnable(true, VlcAsioInputChannel, _asioProc, new IntPtr(StreamInputVlc));
            BassAsio.BASS_ASIO_ChannelJoin(true, VlcAsioInputChannel + 1, VlcAsioInputChannel);
            BassAsio.BASS_ASIO_ChannelSetFormat(true, VlcAsioInputChannel, BASSASIOFormat.BASS_ASIO_FORMAT_FLOAT);
            BassAsio.BASS_ASIO_ChannelSetRate(true, VlcAsioInputChannel, samplerate);
            BassAsio.BASS_ASIO_SetRate(samplerate);

            BassAsio.BASS_ASIO_ChannelEnable(true, m_inputChannel, _asioProc, new IntPtr(m_streamInputMic));
            BassAsio.BASS_ASIO_ChannelJoin(true, m_inputChannel + 1, m_inputChannel);
            BassAsio.BASS_ASIO_ChannelSetFormat(true, m_inputChannel, BASSASIOFormat.BASS_ASIO_FORMAT_FLOAT);
            BassAsio.BASS_ASIO_ChannelSetRate(true, m_inputChannel, samplerate);
            BassAsio.BASS_ASIO_SetRate(samplerate);

            BassAsio.BASS_ASIO_ChannelEnable(false, m_outputChannel, _asioProc, new IntPtr(m_mixerChannel));
            BassAsio.BASS_ASIO_ChannelJoin(false, m_outputChannel + 1, m_outputChannel);
            BassAsio.BASS_ASIO_ChannelSetFormat(false, m_outputChannel, BASSASIOFormat.BASS_ASIO_FORMAT_FLOAT);
            BassAsio.BASS_ASIO_ChannelSetRate(false, m_outputChannel, samplerate);
            BassAsio.BASS_ASIO_SetRate(samplerate);
        }
Ejemplo n.º 7
0
        public void Evaluate(int SpreadMax)
        {
            try
            {
                #region Channel and device
                if (this.FPinInChannels.PinIsChanged || this.FPinInDevice.PinIsChanged)
                {
                    double dbldevice;
                    this.FPinInDevice.GetValue(0, out dbldevice);

                    this.FDeviceIndex = Convert.ToInt32(dbldevice);
                    if (this.FDeviceIndex != -1)
                    {
                        BassAsio.BASS_ASIO_Init(this.FDeviceIndex);
                        BassAsio.BASS_ASIO_SetDevice(this.FDeviceIndex);
                    }

                    this.FOutputHandled.Clear();
                    BassAsio.BASS_ASIO_Stop();

                    BassAsio.BASS_ASIO_ChannelReset(false, -1, BASSASIOReset.BASS_ASIO_RESET_PAUSE | BASSASIOReset.BASS_ASIO_RESET_JOIN);

                    if (this.FDeviceIndex != -1 && this.FPinInChannels.IsConnected)
                    {
                        int    asiooutindex = 0;
                        double dhandle;
                        for (int i = 0; i < this.FPinInChannels.SliceCount; i++)
                        {
                            this.FPinInChannels.GetValue(i, out dhandle);
                            int handle = Convert.ToInt32(dhandle);

                            if (handle != 0 && handle != -1)
                            {
                                ChannelInfo channel = this.manager.GetChannel(handle);

                                if (channel.BassHandle == null)
                                {
                                    //Initialize channel (in nosound)
                                    channel.Initialize(0);
                                }

                                //Check if the channel has its own handler
                                if (!BassAsioUtils.InputChannels.ContainsKey(handle))
                                {
                                    BASS_CHANNELINFO info = Bass.BASS_ChannelGetInfo(channel.BassHandle.Value);

                                    BassAsio.BASS_ASIO_ChannelEnable(false, asiooutindex, myAsioProc, new IntPtr(handle));
                                    if (info.chans == 1)
                                    {
                                        //No need to join on mono channels
                                        asiooutindex++;
                                    }
                                    else
                                    {
                                        for (int chan = 1; chan < info.chans; chan++)
                                        {
                                            bool join = BassAsio.BASS_ASIO_ChannelJoin(false, asiooutindex + chan, asiooutindex);
                                            if (!join)
                                            {
                                                this.FHost.Log(TLogType.Error, "Error: join failed");
                                                this.FHost.Log(TLogType.Error, BassAsio.BASS_ASIO_ErrorGetCode().ToString());
                                            }
                                        }

                                        BassAsio.BASS_ASIO_ChannelSetFormat(false, asiooutindex, BASSASIOFormat.BASS_ASIO_FORMAT_FLOAT);
                                        BassAsio.BASS_ASIO_ChannelSetRate(false, asiooutindex, (double)info.freq);
                                        BassAsio.BASS_ASIO_SetRate((double)info.freq);

                                        asiooutindex += info.chans;
                                    }
                                }
                                else
                                {
                                    BassAsioHandler handler = BassAsioUtils.InputChannels[handle].Handler;
                                    handler.SetMirror(asiooutindex);
                                    asiooutindex += 2;
                                    this.FOutputHandled.Add(asiooutindex);
                                    this.FOutputHandled.Add(asiooutindex + 1);
                                }
                            }
                        }

                        bool start = BassAsio.BASS_ASIO_Start(0);
                        if (!start)
                        {
                            this.FPinErrorCode.SetString(0, BassAsio.BASS_ASIO_ErrorGetCode().ToString());
                            this.FHost.Log(TLogType.Error, "Error: Start failed");
                            this.FHost.Log(TLogType.Error, BassAsio.BASS_ASIO_ErrorGetCode().ToString());
                        }
                        else
                        {
                            this.FPinErrorCode.SetString(0, "OK");
                        }

                        UpdateChannels();
                    }
                }

                if (FControlPanel.PinIsChanged)
                {
                    double v;
                    FControlPanel.GetValue(0, out v);
                    if (v > 0.5)
                    {
                        BassAsio.BASS_ASIO_ControlPanel();
                    }
                }
                #endregion

                #region Volume
                if (this.FPinInVolumeOutput.PinIsChanged)
                {
                    if (this.FDeviceIndex != -1 || this.FPinInVolumeOutput.SliceCount > 0)
                    {
                        BASS_ASIO_INFO deviceinfo = BassAsio.BASS_ASIO_GetInfo();

                        int current = 0;
                        for (int i = 0; i < deviceinfo.outputs; i++)
                        {
                            double vol;

                            this.FPinInVolumeOutput.GetValue(current, out vol);
                            BassAsio.BASS_ASIO_ChannelSetVolume(false, i, (float)vol);

                            //Bin for the channels
                            current++;
                            if (current == this.FPinInVolumeOutput.SliceCount)
                            {
                                current = 0;
                            }
                        }
                    }
                }
                #endregion

                #region Is Active Pin
                if (this.FPinInActive.PinIsChanged)
                {
                    UpdateChannels();
                }
                #endregion
            }
            catch (Exception ex)
            {
                this.FHost.Log(TLogType.Error, ex.Message);
                this.FHost.Log(TLogType.Error, ex.StackTrace);
            }
        }