Example #1
0
        public void CanRegisterSourceVoiceCallback()
        {
            const int lengthInSeconds = 2;
            bool      b0 = false, b1 = false;

            var callback = new VoiceCallback();

            using (var masteringVoice = _xaudio2.CreateMasteringVoice())
                using (var sourceVoice = _xaudio2.CreateSourceVoice(_source.WaveFormat, VoiceFlags.None, CSCore.XAudio2.XAudio2.DefaultFrequencyRatio, callback, null, null))
                {
                    callback.BufferStart += (s, e) => b0 = true;
                    callback.BufferEnd   += (s, e) => b1 = true;

                    byte[] rawBuffer = new byte[_source.WaveFormat.BytesPerSecond * lengthInSeconds];
                    int    read      = _source.Read(rawBuffer, 0, rawBuffer.Length);

                    var buffer = new XAudio2Buffer(read);
                    using (var stream = buffer.GetStream())
                    {
                        stream.Write(rawBuffer, 0, read);
                    }

                    sourceVoice.SubmitSourceBuffer(buffer);
                    sourceVoice.Start();

                    Thread.Sleep(lengthInSeconds * 1000 + 2000);

                    Assert.IsTrue(b0, "No BufferStart.");
                    Assert.IsTrue(b1, "No BufferEnd.");
                }
        }
Example #2
0
        private static void PlayWithoutStreaming(IWaveSource waveSource)
        {
            using (var xaudio2 = XAudio2.CreateXAudio2())
                using (var masteringVoice = xaudio2.CreateMasteringVoice()) //ALWAYS create at least one masteringVoice.
                    using (var sourceVoice = xaudio2.CreateSourceVoice(waveSource.WaveFormat))
                    {
                        var buffer = waveSource.ToByteArray();
                        using (var sourceBuffer = new XAudio2Buffer(buffer.Length))
                        {
                            using (var stream = sourceBuffer.GetStream())
                            {
                                stream.Write(buffer, 0, buffer.Length);
                            }

                            sourceVoice.SubmitSourceBuffer(sourceBuffer);
                        }

                        sourceVoice.Start();

                        Console.WriteLine("Press any key to exit.");
                        Console.ReadKey();

                        sourceVoice.Stop();
                    }
        }
Example #3
0
        private void voice_VoiceProcessingPassStart(uint bufferSize)
        {
            var bufferSamples = bufferSize / sizeof(float);
            var buffer        = new XAudio2Buffer(bufferSamples);

            for (uint i = 0; i < bufferSamples; ++i)
            {
                buffer.SetSample(i, (float)Math.Sin(phase));
                phase = (phase + (Delta * frequency)) % TwoPi;
            }

            voice.SubmitSourceBuffer(buffer);
        }
Example #4
0
        public void CanRegisterEngineCallback()
        {
            const int lengthInSeconds = 2;
            bool      b0 = false, b1 = false;

            XAudio2EngineCallback engineCallback = new XAudio2EngineCallback();

            engineCallback.ProcessingPassStart           += (s, e) =>
                                                       b0 = true;
            engineCallback.ProcessingPassEnd             += (s, e) =>
                                                       b1 = true;

            _xaudio2.RegisterForCallbacks(engineCallback);

            using (var masteringVoice = _xaudio2.CreateMasteringVoice())
                using (var sourceVoice = _xaudio2.CreateSourceVoice(_source.WaveFormat))
                {
                    byte[] rawBuffer = new byte[_source.WaveFormat.BytesPerSecond * lengthInSeconds];
                    int    read      = _source.Read(rawBuffer, 0, rawBuffer.Length);

                    var buffer = new XAudio2Buffer(read);
                    using (var stream = buffer.GetStream())
                    {
                        stream.Write(rawBuffer, 0, read);
                    }

                    sourceVoice.SubmitSourceBuffer(buffer);
                    sourceVoice.Start();

                    Thread.Sleep((lengthInSeconds * 1000 + 500) / 2);

                    Assert.IsTrue(b0 || b1);

                    Console.WriteLine("Unregistered");
                    _xaudio2.UnregisterForCallbacks(engineCallback);
                    b0 = b1 = false;

                    Thread.Sleep((lengthInSeconds * 1000 + 500) / 4);

                    Assert.IsFalse(b0 && b1);

                    Console.WriteLine("Register");
                    _xaudio2.RegisterForCallbacks(engineCallback);

                    Thread.Sleep((lengthInSeconds * 1000 + 500) / 4);

                    Assert.IsTrue(b0 || b1);
                }

            _xaudio2.UnregisterForCallbacks(engineCallback);
        }
Example #5
0
        private void OnSoundLoaded(string soundId, AudioData data)
        {
            if (data == null)
            {
                Logger.Error($"Sound failed to load {GetFullName()}: {soundId}");
                return;
            }

            _callback?.Dispose();
            _callback          = new VoiceCallback();
            _callback.LoopEnd += CallbackOnLoopEnd;

            var source = data.AudioSource;

            _voice = SoundService.XAudio2.CreateSourceVoice(source.WaveFormat, VoiceFlags.None,
                                                            XAudio2.DefaultFrequencyRatio, null, null, null);

            var length = (TimeSpan)source.GetLength();

            var buffer = source.ToByteArray();
            var stream = new DataStream(buffer.Length, true, true);

            stream.Write(buffer, 0, buffer.Length);

            _audioBuffer = new XAudio2Buffer
            {
                AudioDataPtr = stream.DataPointer,
                AudioBytes   = buffer.Length,
                Flags        = XAudio2BufferFlags.EndOfStream
            };

            _loopedAudioBuffer = new XAudio2Buffer
            {
                AudioDataPtr = stream.DataPointer,
                AudioBytes   = buffer.Length,
                Flags        = XAudio2BufferFlags.EndOfStream,
                LoopCount    = XAudio2Buffer.LoopInfinite
            };

            data.AudioSource.SetPosition((System.TimeSpan)StartingPosition);
            _voice.Volume = _volume;
            _voice.SetFrequencyRatio(_pitch);

            TrackLength = length;
            IsLoaded    = true;
            Loaded.Fire(soundId);
        }
Example #6
0
        public void CanSubmitSourceBuffer()
        {
            const int lengthInSeconds = 2;

            using (var masteringVoice = _xaudio2.CreateMasteringVoice())
                using (var sourceVoice = _xaudio2.CreateSourceVoice(_source.WaveFormat))
                {
                    byte[] rawBuffer = new byte[_source.WaveFormat.BytesPerSecond * lengthInSeconds];
                    int    read      = _source.Read(rawBuffer, 0, rawBuffer.Length);

                    var buffer = new XAudio2Buffer(read);
                    using (var stream = buffer.GetStream())
                    {
                        stream.Write(rawBuffer, 0, read);
                    }

                    sourceVoice.SubmitSourceBuffer(buffer);
                    sourceVoice.Start();

                    Thread.Sleep(lengthInSeconds * 1000 + 500);
                }
        }