Пример #1
0
        /// <summary>
        /// 再生を開始します。
        /// </summary>
        public void PlayStreaming(string url)
        {
            if (_waveOut == null)
            {
                new Thread(delegate(object o)
                {
                    var response = WebRequest.Create(url).GetResponse();
                    using (var stream = response.GetResponseStream())
                    {
                        byte[] buffer = new byte[65536]; // 64KB chunks

                        int read;

                        while ((read = stream.Read(buffer, 0, buffer.Length)) > 0)
                        {
                            var pos     = ms.Position;
                            ms.Position = ms.Length;
                            ms.Write(buffer, 0, read);
                            ms.Position = pos;
                        }
                    }
                }).Start();
            }


            // Pre-buffering some data to allow NAudio to start playing
            while (ms.Length < 65536 * 10)
            {
                Thread.Sleep(1000);
            }

            int errorCont = 0;

            try
            {
                using (reader = new Mp3FileReader(ms))
                    using (WaveStream pcm = WaveFormatConversionStream.CreatePcmStream(reader))
                        using (WaveStream blockAlignedStream = new BlockAlignReductionStream(pcm))
                        {
                            using (_waveOut = new WaveOut(WaveCallbackInfo.FunctionCallback()))
                            {
                                _waveOut.Init(blockAlignedStream);
                                _waveOut.Play();
                                while (_waveOut.PlaybackState == PlaybackState.Playing)
                                {
                                    Console.WriteLine(reader.CurrentTime);
                                    System.Threading.Thread.Sleep(100);
                                }
                            }
                        }
            }
            catch
            {
                if (errorCont > 10)
                {
                    MessageBox.Show("10回Tryしましたが再生に失敗しました。");
                }
                errorCont++;
            }
        }
Пример #2
0
        private void CreateWaveOut()
        {
            CloseWaveOut();
            int latency = (int)comboBoxLatency.SelectedItem;

            if (radioButtonWaveOut.Checked)
            {
                WaveCallbackInfo callbackInfo = checkBoxWaveOutWindow.Checked ?
                                                WaveCallbackInfo.NewWindow() : WaveCallbackInfo.FunctionCallback();
                WaveOut outputDevice = new WaveOut(callbackInfo);
                outputDevice.DesiredLatency = latency;
                waveOut = outputDevice;
            }
            else if (radioButtonDirectSound.Checked)
            {
                waveOut = new DirectSoundOut(latency);
            }
            else if (radioButtonAsio.Checked)
            {
                waveOut = new AsioOut((String)comboBoxAsioDriver.SelectedItem);
                buttonControlPanel.Enabled = true;
            }
            else
            {
                waveOut = new WasapiOut(
                    checkBoxWasapiExclusiveMode.Checked ?
                    AudioClientShareMode.Exclusive :
                    AudioClientShareMode.Shared,
                    checkBoxWasapiEventCallback.Checked,
                    latency);
            }
        }
        /// <summary>
        /// mp3
        /// </summary>
        public AudioFileTimeSource(string path, string device)
        {
            _path = path;

            switch (Path.GetExtension(path).ToUpper().TrimStart('.'))
            {
            case "MP3":
                _rdr = new Mp3FileReader(path);
                break;

            case "WAV":
                _rdr = new WaveFileReader(path);
                break;

            default:
                throw new ArgumentException($"Unsupported Audio file format", nameof(path));
            }

            _wavStream = WaveFormatConversionStream.CreatePcmStream(_rdr);
            _baStream  = new BlockAlignReductionStream(_wavStream);

            _waveOut = new WaveOut(WaveCallbackInfo.FunctionCallback());
            _waveOut.DeviceNumber   = GetDeviceNumber(device);
            _waveOut.DesiredLatency = 150;
            _waveOut.Init(_baStream);
        }
Пример #4
0
        void StartEncoding()
        {
            _startTime     = DateTime.Now;
            _bytesSent     = 0;
            _segmentFrames = 960;
            var channels = 1;

            _encoder         = Codec.OpusEncoder.Create(48000, channels, Codec.Opus.Application.Voip);
            _encoder.Bitrate = 8192;
            _decoder         = Codec.OpusDecoder.Create(48000, channels);
            _bytesPerSegment = _encoder.FrameByteCount(_segmentFrames);

            _waveIn = new WaveIn(WaveCallbackInfo.FunctionCallback());
            _waveIn.BufferMilliseconds = 50;
            _waveIn.DeviceNumber       = comboBox1.SelectedIndex;
            _waveIn.DataAvailable     += _waveIn_DataAvailable;
            _waveIn.WaveFormat         = new WaveFormat(48000, 16, channels);

            _playBuffer = new BufferedWaveProvider(new WaveFormat(48000, 16, channels));

            _waveOut = new WaveOut(WaveCallbackInfo.FunctionCallback());
            _waveOut.DeviceNumber = comboBox2.SelectedIndex;
            _waveOut.Init(_playBuffer);

            _waveOut.Play();
            _waveIn.StartRecording();

            if (_timer == null)
            {
                _timer          = new Timer();
                _timer.Interval = 1000;
                _timer.Tick    += _timer_Tick;
            }
            _timer.Start();
        }
 public void PlayMp3FromUrl(string url, int timeout)
 {
     using (Stream ms = new MemoryStream())
     {
         using (Stream stream = WebRequest.Create(url)
                                .GetResponse().GetResponseStream())
         {
             byte[] buffer = new byte[32768];
             int    read;
             while ((read = stream.Read(buffer, 0, buffer.Length)) > 0)
             {
                 ms.Write(buffer, 0, read);
             }
         }
         ms.Position = 0;
         using (WaveStream blockAlignedStream =
                    new BlockAlignReductionStream(
                        WaveFormatConversionStream.CreatePcmStream(
                            new Mp3FileReader(ms))))
         {
             using (WaveOut waveOut = new WaveOut(WaveCallbackInfo.FunctionCallback()))
             {
                 waveOut.Init(blockAlignedStream);
                 waveOut.PlaybackStopped += (sender, e) =>
                 {
                     waveOut.Stop();
                 };
                 waveOut.Play();
                 waiting = true;
                 stop.WaitOne(timeout);
                 waiting = false;
             }
         }
     }
 }
Пример #6
0
        //Functionality that plays the passed stream back to the user.
        //This will "freeze" the UI untill playback is completed.
        //INPUT: memoryStream
        //OUTPUT: Function result
        public functionResult onPlayback(ref Stream ms)
        {
            functionResult result = new functionResult();

            try
            {
                //Go to position 0 of the audio stream
                ms.Position = 0;
                //Conver the stream to a wavefile and create the required heades
                using (WaveStream blockAlignedStream = new BlockAlignReductionStream(WaveFormatConversionStream.CreatePcmStream(new WaveFileReader(ms))))
                {
                    using (WaveOut waveOut = new WaveOut(WaveCallbackInfo.FunctionCallback()))
                    {
                        //Start playing
                        waveOut.Init(blockAlignedStream);
                        waveOut.Play();
                        //While we are playing, prevent anything from happenign on the UI. Might be worth expanding this to have a "Stop" button
                        while (waveOut.PlaybackState == PlaybackState.Playing)
                        {
                            System.Threading.Thread.Sleep(100);
                        }
                    }
                }
                result.Result  = true;
                result.Message = "onPlayback - OK";
            }
            catch (Exception ex)
            {
                result.Result  = false;
                result.Message = "ERROR - onPlayback - " + ex.ToString();
            }
            return(result);
        }
Пример #7
0
        public void PlaySound(string name, Action done = null)
        {
            FileStream ms        = File.OpenRead(_soundLibrary[name]);
            var        rdr       = new Mp3FileReader(ms);
            WaveStream wavStream = WaveFormatConversionStream.CreatePcmStream(rdr);
            var        baStream  = new BlockAlignReductionStream(wavStream);
            var        waveOut   = new WaveOut(WaveCallbackInfo.FunctionCallback());

            waveOut.Init(baStream);
            waveOut.Play();
            var bw = new BackgroundWorker();

            bw.DoWork += (s, o) =>
            {
                while (waveOut.PlaybackState == PlaybackState.Playing)
                {
                    Thread.Sleep(100);
                }
                waveOut.Dispose();
                baStream.Dispose();
                wavStream.Dispose();
                rdr.Dispose();
                ms.Dispose();
                if (done != null)
                {
                    done();
                }
            };
            bw.RunWorkerAsync();
        }
Пример #8
0
        void play()
        {
            if (!this.initialized)
            {
                this.Init();
            }

            if (!this.initialized)
            {
                return;
            }

            if (this.waveOut != null)
            {
                this.waveOut.PlaybackStopped -= WaveOut_PlaybackStopped;
                this.waveOut.Stop();
                this.waveOut.Dispose();
                this.waveOut = null;
            }

            this.Content.SetPosition(0);
            this.waveOut = new WaveOut(WaveCallbackInfo.FunctionCallback());
            this.waveOut.Init(blockAlignedStream);
            this.waveOut.PlaybackStopped += WaveOut_PlaybackStopped;
            this.waveOut.Play();
            this.timer.Start();
        }
Пример #9
0
 public void DownloadFile(string urlAddress, string location)
 {
     using (webClient = new WebClient())
     {
         try
         {
             Uri URL = new Uri(urlAddress);
             // Start downloading the file
             webClient.DownloadFile(URL, location);
             using (FileStream memoryStream = File.OpenRead(location))
             {
                 memoryStream.Position = 0;
                 using (
                     WaveStream blockAlignedStream = new BlockAlignReductionStream(WaveFormatConversionStream.CreatePcmStream(new Mp3FileReader(memoryStream))))
                 {
                     using (_waveOut = new WaveOut(WaveCallbackInfo.FunctionCallback()))
                     {
                         _waveOut.Init(blockAlignedStream);
                         _waveOut.Play();
                         while (_waveOut.PlaybackState == PlaybackState.Playing)
                         {
                             Thread.Sleep(100);
                         }
                         _waveOut.Stop();
                         _waveOut.Dispose();
                     }
                 }
             }
         }
         catch (Exception ex)
         {
             Console.WriteLine(ex.Message);
         }
     }
 }
Пример #10
0
 private void PlayMp3(string url)
 {
     try
     {
         Stream ms = new MemoryStream();
         // 设置参数
         HttpWebRequest request = WebRequest.Create(url) as HttpWebRequest;
         //发送请求并获取相应回应数据
         HttpWebResponse response = request.GetResponse() as HttpWebResponse;
         //直到request.GetResponse()程序才开始向目标网页发送Post请求
         Stream responseStream = response.GetResponseStream();
         byte[] buffer         = new byte[1024];
         int    size           = 0;
         //size是读入缓冲区中的总字节数。 如果当前可用的字节数没有请求的字节数那么多,则总字节数可能小于请求的字节数,或者如果已到达流的末尾,则为零 (0)。
         while ((size = responseStream.Read(buffer, 0, buffer.Length)) != 0) //将responseStream的内容读入buffer数组
         {
             ms.Write(buffer, 0, size);                                      //将buffer数组的内容写入内存流ms
         }
         responseStream.Close();                                             //关闭流并释放连接以供重用
         ms.Position = 0;                                                    //将内存流数据读取位置归零
         WaveStream blockAlignedStream = new BlockAlignReductionStream(WaveFormatConversionStream.CreatePcmStream(new Mp3FileReader(ms)));
         WaveOut    waveOut            = new WaveOut(WaveCallbackInfo.FunctionCallback());
         waveOut.Init(blockAlignedStream);
         //waveOut.PlaybackStopped += (sender, e) => { waveOut.Stop(); };
         waveOut.Play();
         while (waveOut.PlaybackState == PlaybackState.Playing)
         {
             Thread.Sleep(100);
         }
     }
     catch (Exception ex)
     {
         ex.Message.ToString();
     }
 }
Пример #11
0
        // ------ Wave Player Methods ------

        // Creates the wave player. The wave provider is required to initialize the wave player.
        // Wave players created through this method should be released by the ReleaseWavePlayer method.
        private IWavePlayer CreateWavePlayer(IWaveProvider waveProvider)
        {
            IWavePlayer player = new WaveOut(WaveCallbackInfo.FunctionCallback());

            player.Init(waveProvider);
            return(player);
        }
Пример #12
0
        public WzMp3Streamer(WzBinaryProperty sound, bool repeat)
        {
            this.repeat = repeat;
            this.sound  = sound;
            byteStream  = new MemoryStream(sound.GetBytes(false));

            this.bIsMP3File = !sound.Name.EndsWith("wav"); // mp3 file does not end with any extension

            wavePlayer = new WaveOut(WaveCallbackInfo.FunctionCallback());
            try
            {
                if (bIsMP3File)
                {
                    mpegStream = new Mp3FileReader(byteStream);
                    wavePlayer.Init(mpegStream);
                }
                else
                {
                    waveFileStream = new WaveFileReader(byteStream);
                    wavePlayer.Init(waveFileStream);
                }
            }
            catch (System.Exception e)
            {
                playbackSuccessfully = false;
                //InvalidDataException
                // Message = "Not a WAVE file - no RIFF header"
            }
            Volume = 0.5f; // default volume
            wavePlayer.PlaybackStopped += new EventHandler <StoppedEventArgs>(wavePlayer_PlaybackStopped);
        }
Пример #13
0
        protected override SinkSourceMode driverConnect()
        {
            if (selectedDevice <= 0)
            {
                return(SinkSourceMode.Offline);
            }
            owner.logText(String.Format("Opening Audio Device {0}", devices[selectedDevice]));

            try
            {
                waveIn                    = new WaveIn(WaveCallbackInfo.FunctionCallback());
                waveIn.WaveFormat         = new WaveFormat(owner.sampleRate, 16, 2);
                waveIn.DeviceNumber       = devindex[selectedDevice];
                waveIn.DataAvailable     += WaveIn_DataAvailable;
                waveIn.BufferMilliseconds = 25; // 1200 samples at 48 kHz

                setChannels(new RTIO[] { ioL, ioR }, null);

                waveIn.StartRecording();
                owner.logText(String.Format("Device {0} open", devices[selectedDevice]));
                processingType = ProcessingType.SynchronousSource;
                return(SinkSourceMode.Online);
            }
            catch (Exception e)
            {
                owner.showLogWin();
                owner.logText(e.Message);
                return(SinkSourceMode.Error);
            }
        }
        public WzMp3Streamer(WzSoundProperty sound, bool repeat)
        {
            this.repeat = repeat;
            this.sound  = sound;
            byteStream  = new MemoryStream(sound.GetBytes(false));

            wavePlayer = new WaveOut(WaveCallbackInfo.FunctionCallback());
            try
            {
                mpegStream = new Mp3FileReader(byteStream);
                wavePlayer.Init(mpegStream);
            }
            catch (System.InvalidOperationException)
            {
                try
                {
                    waveFileStream = new WaveFileReader(byteStream);
                    wavePlayer.Init(waveFileStream);
                }
                catch (FormatException)
                {
                    playbackSuccessfully = false;
                }
                //InvalidDataException
            }
            wavePlayer.PlaybackStopped += new EventHandler <StoppedEventArgs>(wavePlayer_PlaybackStopped);
        }
Пример #15
0
        public void Stream(string url, bool async)
        {
            if (url == null)
            {
                return;
            }

            WaveOut WaveOutPlay = new WaveOut(WaveCallbackInfo.FunctionCallback());

            WaveOutPlay.DeviceNumber = device;

            using (var ms = new MemoryStream())
                using (var stream = WebRequest.Create(url).GetResponse().GetResponseStream()) {
                    byte[] buffer = new byte[32768]; int read;
                    while ((read = stream.Read(buffer, 0, buffer.Length)) > 0)
                    {
                        ms.Write(buffer, 0, read);
                    }
                    ms.Position = 0;

                    // Play WaveStream
                    bool wav    = url.ToLower().EndsWith(".wav") || url.ToLower().EndsWith(".wma");
                    var  reader = wav ? WaveFormatConversionStream.CreatePcmStream(new WaveFileReader(ms))
                         : (WaveStream) new Mp3FileReader(ms);

                    RunSession(WaveOutPlay, reader, url);
                }

            WaveOutPlay.Dispose();
        }
Пример #16
0
        public void PlaySound(CachedSound sound)
        {
            switch (sound.Type)
            {
            case TYPE_SOURCE.FILE_LOCAL:
                AddMixerInput(new CachedSoundSampleProvider(sound));
                break;

            case TYPE_SOURCE.FILE_MP3_ONLINE:
                using (MemoryStream mp3file = new MemoryStream(sound.AudioData_FILE_MP3_ONLINE))
                {
                    using (WaveStream blockAlignedStream = new BlockAlignReductionStream(WaveFormatConversionStream.CreatePcmStream(
                                                                                             new Mp3FileReader(mp3file))))
                    {
                        using (WaveOut waveOut = new WaveOut(WaveCallbackInfo.FunctionCallback()))
                        {
                            waveOut.Init(blockAlignedStream);
                            waveOut.Play();
                            while (waveOut.PlaybackState == PlaybackState.Playing)
                            {
                                System.Threading.Thread.Sleep(100);
                            }
                        }
                    }
                }
                break;
            }
        }
Пример #17
0
        private void CreateWaveOut()
        {
            //CloseWaveOut();

            switch (_output)
            {
            case Output.WaveOut:
                var callbackInfo = WaveCallbackInfo.FunctionCallback();
                var outputDevice = new WaveOut(callbackInfo)
                {
                    DesiredLatency = Latency
                };
                waveOut = outputDevice;
                break;

            case Output.DirectSound:
                waveOut = new DirectSoundOut(Latency);

                break;

            case Output.Wasapi:
                waveOut = new WasapiOut(WasapiExclusiveMode?AudioClientShareMode.Exclusive:AudioClientShareMode.Shared, Latency);
                break;

            case Output.Asio:
                waveOut = new AsioOut(AsioDriverName);
                break;
            }
        }
Пример #18
0
        private WaveOut CreatePlay(string file)
        {
            string ext = Path.GetExtension(file);

            if (file.EndsWith(".mp3"))
            {
                using (var reader = new Mp3FileReader(file))
                {
                    using (var waveStream = WaveFormatConversionStream.CreatePcmStream(reader))
                    {
                        using (var blockStream = new BlockAlignReductionStream(waveStream))
                        {
                            play = new WaveOut(WaveCallbackInfo.FunctionCallback());
                            play.Init(blockStream);
                        }
                    }
                }
            }
            System.Media.SoundPlayer
            else if (file.EndsWith(".wma"))
            {
                using (var reader = new WMAFileReader(file))
                {
                    using (var waveStream = WaveFormatConversionStream.CreatePcmStream(reader))
                    {
                        using (var blockStream = new BlockAlignReductionStream(waveStream))
                        {
                            play = new WaveOut(WaveCallbackInfo.FunctionCallback());
                            play.Init(blockStream);
                        }
                    }
                }
            }
        }
Пример #19
0
        private void PlaySoundAsync(object parameter)
        {
            string fileName = (string)parameter;

            using (var archive = DataArchive.Open(Settings.Default.LegendLocation))
                using (var stream = archive.GetEntry(fileName).Open())
                {
                    stream.Position = 0;
                    using (var reader = new Mp3FileReader(stream))
                        using (var conversionStream = WaveFormatConversionStream.CreatePcmStream(reader))
                            using (var provider = new BlockAlignReductionStream(conversionStream))
                                using (var waveOut = new WaveOut(WaveCallbackInfo.FunctionCallback()))
                                {
                                    waveOut.Init(provider);
                                    waveOut.Play();

                                    while (waveOut.PlaybackState == PlaybackState.Playing)
                                    {
                                        Thread.Sleep(100);
                                    }
                                }
                }

            TogglePlayButtonEnabled(true);
        }
Пример #20
0
        private void play_thread()
        {
            log("Record Thread Started");
            func_gen fg = new func_gen(setup);

            fg.SetWaveFormat(48000, 1);
            wo = new WaveOut(WaveCallbackInfo.FunctionCallback());
            wo.DeviceNumber = usedev;
            wo.Init(fg);
            wo.Play();

            log("Playing started");
            while (!killthread)
            {
                System.Threading.Thread.Sleep(50);

                /*fg.freq = freq;
                 * fg.amp = amp;
                 * fg.func = func;
                 * fg.on = on;
                 */
            }
            wo.Stop();
            log("Playing stopped");
        }
Пример #21
0
        private void PlayFromPlaylist(int index)
        {
            _fileStream = File.OpenRead(playList[index].Path);
            _reader     = new Mp3FileReader(_fileStream);
            var wavStream = WaveFormatConversionStream.CreatePcmStream(_reader);

            _blockAlignStream = new BlockAlignReductionStream(wavStream);
            _waveOut          = new WaveOut(WaveCallbackInfo.FunctionCallback());
            _timeSpan         = _reader.TotalTime;
            _waveOut.Volume   = VolBar.Value * (float)0.01;

            ElapsedBar.Maximum = (int)_timeSpan.TotalSeconds;
            MusicNameLbl.Text  = playList[index].Artist + " - " + playList[index].Title;
            string time = _reader.TotalTime.ToString();

            time = time.Remove(time.LastIndexOf('.'), 8);
            MusicSizeLbl.Text = time;
            SetButton();

            if (_isPlaying)
            {
                Thread tt = new Thread(t => PlayAudio());
                tt.Start();
            }
        }
Пример #22
0
        /// <summary>
        /// Plays the audio in the given media and logs the audio transcription if available.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="mediaSegmentContent"></param>
        static void OnMediaSegmentProcessed(object sender, MediaSegmentContent mediaSegmentContent)
        {
            if (mediaSegmentContent.Transcription.NBest != null &&
                mediaSegmentContent.Transcription.NBest.Count > 0)
            {
                Log(mediaSegmentContent.Transcription.NBest[0].Display);
            }
            else
            {
                Log(mediaSegmentContent.TranscriptionResult);
            }

            using (WaveOut waveOut = new WaveOut(WaveCallbackInfo.FunctionCallback()))
            {
                waveOut.Init(mediaSegmentContent.Audio.BlockAlignReductionStream);
                waveOut.Play();

                while (waveOut.PlaybackState == PlaybackState.Playing)
                {
                    System.Threading.Thread.Sleep(100);
                }
            }

            mediaSegmentContent.Dispose();
        }
Пример #23
0
        public static void PlayMp3FromUrl(string url)
        {
            using (Stream ms = new MemoryStream())
            {
                using (Stream stream = WebRequest.Create(url).GetResponse().GetResponseStream())
                {
                    byte[] buffer = new byte[32768];
                    int    read;
                    while ((read = stream.Read(buffer, 0, buffer.Length)) > 0)
                    {
                        ms.Write(buffer, 0, read);
                    }
                }

                ms.Position = 0;
                using (WaveStream blockAlignedStream =
                           new BlockAlignReductionStream(
                               WaveFormatConversionStream.CreatePcmStream(
                                   new Mp3FileReader(ms))))
                {
                    using (WaveOut waveOut = new WaveOut(WaveCallbackInfo.FunctionCallback()))
                    {
                        waveOut.Init(blockAlignedStream);
                        waveOut.Play();
                        while (waveOut.PlaybackState == PlaybackState.Playing)
                        {
                            System.Threading.Thread.Sleep(100);
                        }
                    }
                }
            }
        }
Пример #24
0
        public void TurnOn()
        {
            switch (WorkMode)
            {
            case Waveform.Sine:
                break;

            case Waveform.Sine_Dual:
                break;

            case Waveform.Sine_VarPhase:
                break;

            case Waveform.Square:
                break;

            case Waveform.File:
                using (var rdr = new AudioFileReader(WaveFile.FilePath))
                    using (var wavStream = WaveFormatConversionStream.CreatePcmStream(rdr))
                        using (var baStream = new BlockAlignReductionStream(wavStream))
                            using (var waveOut = new WaveOut(WaveCallbackInfo.FunctionCallback()))
                            {
                                waveOut.Init(baStream);
                                waveOut.Play();
                                while (waveOut.PlaybackState == PlaybackState.Playing)
                                {
                                    Thread.Sleep(100);
                                }
                            }
                break;
            }
        }
Пример #25
0
        private static IWavePlayer CreateWavePlayer()
        {
            var callbackInfo = WaveCallbackInfo.FunctionCallback();
            var outputDevice = new WaveOut(callbackInfo);

            return(outputDevice);
        }
Пример #26
0
        // ------------------------------------------
        //  CONSTRUCTOR
        // ------------------------------------------

        public WSRSpeaker(int device)
        {
            this.device = device;

            this.WaveOutSpeech = new WaveOut(WaveCallbackInfo.FunctionCallback());
            this.WaveOutSpeech.DeviceNumber = device;

            this.synthesizer = new SpeechSynthesizer();
            this.synthesizer.SpeakCompleted += new EventHandler <SpeakCompletedEventArgs>(synthesizer_SpeakCompleted);

            // Enumerate Voices
            foreach (InstalledVoice voice in synthesizer.GetInstalledVoices())
            {
                VoiceInfo info = voice.VoiceInfo;
                WSRConfig.GetInstance().logInfo("TTS", "[" + device + "]" + "Name: " + info.Name + " Culture: " + info.Culture);
            }

            // Select Voice
            String v = WSRConfig.GetInstance().voice;

            if (v != null && v.Trim() != "")
            {
                WSRConfig.GetInstance().logInfo("TTS", "[" + device + "]" + "Select voice: " + v);
                synthesizer.SelectVoice(v);
            }
        }
Пример #27
0
 /// <summary>
 ///     Se encarga de comenzar a reproducir una cancion desde un archivo local
 /// </summary>
 /// <param name="ruta">La ruta de la cancion a reproducir</param>
 private void ReproducirCancionSinConexion(string ruta)
 {
     try
     {
         DetenerRecepcionDeCancion();
         _waveOutEvent.Stop();
         _bufferCancion      = new MemoryStream(File.ReadAllBytes(ruta));
         _mp3Reader          = new Mp3FileReader(_bufferCancion);
         _blockAlignedStream = new WaveChannel32(_mp3Reader);
         _waveOutEvent       = new WaveOut(WaveCallbackInfo.FunctionCallback());
         _waveOutEvent.Init(_blockAlignedStream);
         _estadoReproductor = EstadoReproductor.Reproduciendo;
         _seguidorDeEventosDelReproductor.Start();
         _waveOutEvent.Play();
     }
     catch (Exception ex)
     {
         new MensajeEmergente().MostrarMensajeError(ex.Message);
         _waveOutEvent.Stop();
         OnCambioEstadoReproduccion?.Invoke(false);
         _seguidorDeEventosDelReproductor.Stop();
         _estadoReproductor = EstadoReproductor.Detenido;
         if (_bufferCancion != null && _blockAlignedStream != null)
         {
             _bufferCancion.Dispose();
             _blockAlignedStream.Dispose();
         }
     }
 }
Пример #28
0
        public void Play(string fileName, bool async)
        {
            if (fileName == null)
            {
                return;
            }
            if (fileName.StartsWith("http"))
            {
                Stream(fileName, async);
                return;
            }
            if (!File.Exists(fileName))
            {
                return;
            }

            // Play WaveStream
            bool wav    = fileName.ToLower().EndsWith(".wav") || fileName.ToLower().EndsWith(".wma");
            var  reader = wav ? WaveFormatConversionStream.CreatePcmStream(new WaveFileReader(fileName))
                       : (WaveStream) new Mp3FileReader(fileName);

            WaveOut WaveOutPlay = new WaveOut(WaveCallbackInfo.FunctionCallback());

            WaveOutPlay.DeviceNumber = device;
            RunSession(WaveOutPlay, reader, fileName);
            WaveOutPlay.Dispose();
        }
Пример #29
0
 public AudioPlayer(DiscordVoiceConfig __config)
 {
     config               = __config;
     callbackInfo         = WaveCallbackInfo.FunctionCallback();
     outputDevice         = new WaveOut(callbackInfo);
     bufferedWaveProvider = new BufferedWaveProvider(new WaveFormat(48000, 16, config.Channels));
 }
Пример #30
0
        private void InputDeviceStart()
        {
            InputDeviceStop();

            if (!devp_.InputEnable.Value)
            {
                return;
            }

            try {
                var dev_no = MicDeviceInfo.GetDeviceNo(devp_.InputDeviceId.Value);

                if (dev_no < 0)
                {
                    return;
                }

                var dev_info = WaveIn.GetCapabilities(dev_no);

                wave_in_ = new WaveIn(WaveCallbackInfo.FunctionCallback());
                wave_in_.DataAvailable += OnWaveIn_DataAvailable;
                wave_in_.DeviceNumber   = dev_no;
                wave_in_.WaveFormat     = new WaveFormat(
                    (int)devp_.InputSamplingRate.Value,
                    (int)devp_.InputBitsPerSample.Value,
                    Math.Min((int)devp_.InputChannelNum.Value, dev_info.Channels));

                /* 入力開始 */
                wave_in_.StartRecording();
            } catch {
                InputDeviceStop();
            }
        }