internal SoundInstance(Sound staticSound, AudioListener listener, bool forceLoadInMemory) { Listener = listener; engine = staticSound.AudioEngine; sound = staticSound; spatialized = staticSound.Spatialized; var streamed = staticSound.StreamFromDisk && !forceLoadInMemory; if (engine.State == AudioEngineState.Invalidated) return; Source = AudioLayer.SourceCreate(listener.Listener, staticSound.SampleRate, streamed ? CompressedSoundSource.NumberOfBuffers : 1, staticSound.Channels == 1, spatialized, streamed); if (Source.Ptr == IntPtr.Zero) { throw new Exception("Failed to create an AudioLayer Source"); } if (streamed) { soundSource = new CompressedSoundSource(this, staticSound.CompressedDataUrl, staticSound.NumberOfPackets, staticSound.SampleRate, staticSound.Channels, staticSound.MaxPacketLength); } else { if (sound.PreloadedBuffer.Ptr == IntPtr.Zero) { staticSound.LoadSoundInMemory(); //this should be already loaded by the serializer, but in the case of forceLoadInMemory might not be the case yet. } AudioLayer.SourceSetBuffer(Source, staticSound.PreloadedBuffer); } ResetStateToDefault(); }
/// <summary> /// Initialize audio engine /// </summary> internal virtual void InitializeAudioEngine() { AudioDevice = AudioLayer.Create(audioDevice.Name == "default" ? null : audioDevice.Name); if (AudioDevice.Ptr == IntPtr.Zero) { State = AudioEngineState.Invalidated; } DefaultListener = new AudioListener(this); }
private void Apply3DImpl(AudioListener listener, AudioEmitter emitter) { var vectDirWorldBase = emitter.Position - listener.Position; var baseChangeMat = Matrix.Identity; baseChangeMat.Row2 = new Vector4(listener.Up, 0); baseChangeMat.Row3 = new Vector4(listener.Forward, 0); baseChangeMat.Row1 = new Vector4(Vector3.Cross(listener.Up, listener.Forward), 0); var vectDirListBase = Vector3.TransformNormal(vectDirWorldBase, baseChangeMat); var azimut = 180f * (float)(Math.Atan2(vectDirListBase.X, vectDirListBase.Z)/Math.PI); var elevation = 180f * (float)(Math.Atan2(vectDirListBase.Y, new Vector2(vectDirListBase.X, vectDirListBase.Z).Length())/Math.PI); var distance = vectDirListBase.Length(); ComputeDopplerFactor(listener,emitter); AudioVoice.Apply3D(azimut, elevation, distance / emitter.DistanceScale, MathUtil.Clamp((float)Math.Pow(2, Pitch) * dopplerPitchFactor, 0.5f, 2f)); }
/// <summary> /// Create a new sound effect instance of the sound effect. /// The audio data are shared between the instances so that useless memory copies is avoided. /// Each instance that can be played and localized independently from others. /// </summary> /// <returns>A new sound instance</returns> /// <exception cref="ObjectDisposedException">The sound has already been disposed</exception> public SoundInstance CreateInstance(AudioListener listener = null, bool forceLoadInMemory = false) { if (listener == null) { listener = AudioEngine.DefaultListener; } CheckNotDisposed(); var newInstance = new SoundInstance(this, listener, forceLoadInMemory) { Name = Name + " - Instance " + intancesCreationCount }; RegisterInstance(newInstance); ++intancesCreationCount; return newInstance; }
/// <summary> /// Initializes a new instance of the <see cref="SoundInstance"/> class using a dynamic sound source. /// </summary> /// <param name="engine">The audio engine that will be used to play this instance</param> /// <param name="listener">The listener of this instance</param> /// <param name="dynamicSoundSource">The source from where the PCM data will be fetched</param> /// <param name="sampleRate">The sample rate of this audio stream</param> /// <param name="mono">Set to true if the souce is mono, false if stereo</param> /// <param name="spatialized">If the SoundInstance will be used for spatialized audio set to true, if not false, if true mono must also be true</param> public SoundInstance(AudioEngine engine, AudioListener listener, DynamicSoundSource dynamicSoundSource, int sampleRate, bool mono, bool spatialized = false) { Listener = listener; this.engine = engine; this.spatialized = spatialized; soundSource = dynamicSoundSource; if (engine.State == AudioEngineState.Invalidated) return; Source = AudioLayer.SourceCreate(listener.Listener, sampleRate, dynamicSoundSource.MaxNumberOfBuffers, mono, spatialized, true); if (Source.Ptr == IntPtr.Zero) { throw new Exception("Failed to create an AudioLayer Source"); } ResetStateToDefault(); }
internal void Apply3DImpl(AudioListener listener, AudioEmitter emitter) { ////////////////////////////////////////////////////////////// // 1. First let's calculate the parameters to set to the voice var inputChannels = soundEffect.WaveFormat.Channels; var outputChannels = MasterVoice.VoiceDetails.InputChannelCount; if (inputChannels != 1 || outputChannels != 2) throw new AudioSystemInternalException("Error in Apply3DImpl only mono sounds are supposed to be localizable"); var list = new Listener { Position = listener.Position.ToSharpDX(), Velocity = listener.Velocity.ToSharpDX(), OrientFront = listener.Forward.ToSharpDX(), OrientTop = listener.Up.ToSharpDX() }; var emit = new Emitter { Position = emitter.Position.ToSharpDX(), Velocity = emitter.Velocity.ToSharpDX(), DopplerScaler = emitter.DopplerScale, CurveDistanceScaler = emitter.DistanceScale, ChannelRadius = 0f, // Multi-channels localizable sound are considered as source of multiple sounds coming from the same location. ChannelCount = inputChannels }; var dspSettings = new DspSettings(inputChannels, outputChannels); AudioEngine.X3DAudio.Calculate(list, emit, CalculateFlags.Matrix | CalculateFlags.LpfDirect, dspSettings); ///////////////////////////////////////////////////////////// // 2. Now let's set the voice parameters to simulate a 3D voice. // 2.1 The Doppler effect due to the difference of speed between the emitter and listener ComputeDopplerFactor(listener, emitter); UpdatePitch(); // 2.2 The channel attenuations due to the source localization. localizationChannelVolumes = new[] { dspSettings.MatrixCoefficients[0], dspSettings.MatrixCoefficients[1] }; // only mono sound can be localized so matrix should be 2*1 UpdateStereoVolumes(); }
private void Apply3DImpl(AudioListener listener, AudioEmitter emitter) { // Since android has no function available to perform sound 3D localization by default, here we try to mimic the behaviour of XAudio2 // After an analysis of the XAudio2 left/right stereo balance with respect to 3D world position, // it could be found the volume repartition is symmetric to the Up/Down and Front/Back planes. // Moreover the left/right repartition seems to follow a third degree polynomial function: // Volume_left(a) = 2(c-1)*a^3 - 3(c-1)*a^2 + c*a , where c is a constant close to c = 1.45f and a is the angle normalized bwt [0,1] // Volume_right(a) = 1-Volume_left(a) // As for signal attenuation wrt distance the model follows a simple inverse square law function as explained in XAudio2 documentation // ( http://msdn.microsoft.com/en-us/library/windows/desktop/microsoft.directx_sdk.x3daudio.x3daudio_emitter(v=vs.85).aspx ) // Volume(d) = 1 , if d <= ScaleDistance where d is the distance to the listener // Volume(d) = ScaleDistance / d , if d >= ScaleDistance where d is the distance to the listener // 1. Attenuation due to distance. var vecListEmit = emitter.Position - listener.Position; var distListEmit = vecListEmit.Length(); var attenuationFactor = distListEmit <= emitter.DistanceScale ? 1f : emitter.DistanceScale / distListEmit; // 2. Left/Right balance. var repartRight = 0.5f; var worldToList = Matrix.Identity; var rightVec = Vector3.Cross(listener.Forward, listener.Up); worldToList.Column1 = new Vector4(rightVec, 0); worldToList.Column2 = new Vector4(listener.Forward, 0); worldToList.Column3 = new Vector4(listener.Up, 0); var vecListEmitListBase = Vector3.TransformNormal(vecListEmit, worldToList); var vecListEmitListBase2 = (Vector2)vecListEmitListBase; if (vecListEmitListBase2.Length() > 0) { const float c = 1.45f; var absAlpha = Math.Abs(Math.Atan2(vecListEmitListBase2.Y, vecListEmitListBase2.X)); var normAlpha = (float)(absAlpha / (Math.PI / 2)); if (absAlpha > Math.PI / 2) normAlpha = 2 - normAlpha; repartRight = 0.5f * (2 * (c - 1) * normAlpha * normAlpha * normAlpha - 3 * (c - 1) * normAlpha * normAlpha * normAlpha + c * normAlpha); if (absAlpha > Math.PI / 2) repartRight = 1 - repartRight; } // Set the volumes. localizationChannelVolumes = new[] { attenuationFactor * (1f - repartRight), attenuationFactor * repartRight }; UpdateStereoVolumes(); // 3. Calculation of the Doppler effect ComputeDopplerFactor(listener, emitter); UpdatePitch(); }
public void Apply3D(AudioListener listener, AudioEmitter emitter) { DefaultInstance.Apply3D(listener, emitter); }
private void ComputeDopplerFactor(AudioListener listener, AudioEmitter emitter) { // To evaluate the Doppler effect we calculate the distance to the listener from one wave to the next one and divide it by the sound speed // we use 343m/s for the sound speed which correspond to the sound speed in the air. // we use 600Hz for the sound frequency which correspond to the middle of the human hearable sounds frequencies. const float SoundSpeed = 343f; const float SoundFreq = 600f; const float SoundPeriod = 1 / SoundFreq; // avoid useless calculations. if (emitter.DopplerScale <= float.Epsilon || (emitter.Velocity == Vector3.Zero && listener.Velocity == Vector3.Zero)) { dopplerPitchFactor = 1f; return; } var vecListEmit = emitter.Position - listener.Position; var distListEmit = vecListEmit.Length(); var vecListEmitSpeed = emitter.Velocity - listener.Velocity; if (Vector3.Dot(vecListEmitSpeed, Vector3.Normalize(vecListEmit)) < -SoundSpeed) // emitter and listener are getting closer more quickly than the speed of the sound. { dopplerPitchFactor = float.PositiveInfinity; // will be clamped later return; } var timeSinceLastWaveArrived = 0f; // time elapsed since the previous wave arrived to the listener. var lastWaveDistToListener = 0f; // the distance that the last wave still have to travel to arrive to the listener. const float DistLastWave = SoundPeriod * SoundSpeed; // distance traveled by the previous wave. if (DistLastWave > distListEmit) timeSinceLastWaveArrived = (DistLastWave - distListEmit) / SoundSpeed; else lastWaveDistToListener = distListEmit - DistLastWave; var nextVecListEmit = vecListEmit + SoundPeriod * vecListEmitSpeed; var nextWaveDistToListener = nextVecListEmit.Length(); var timeBetweenTwoWaves = timeSinceLastWaveArrived + (nextWaveDistToListener - lastWaveDistToListener) / SoundSpeed; var apparentFrequency = 1 / timeBetweenTwoWaves; dopplerPitchFactor = (float) Math.Pow(apparentFrequency / SoundFreq, emitter.DopplerScale); }
public void Apply3D(AudioListener listener, AudioEmitter emitter) { CheckNotDisposed(); if (listener == null) throw new ArgumentNullException("listener"); if(emitter == null) throw new ArgumentNullException("emitter"); if(soundEffect.WaveFormat.Channels > 1) throw new InvalidOperationException("Apply3D cannot be used on multi-channels sounds."); // reset Pan its default values. if (Pan != 0) Pan = 0; if (EngineState != AudioEngineState.Invalidated) Apply3DImpl(listener, emitter); }
internal void Apply3DImpl(AudioListener listener, AudioEmitter emitter) { throw new NotImplementedException(); }