// is playing internal static bool IsPlaying(int SoundSourceIndex) { if (OpenAlContext != IntPtr.Zero) { if (SoundSourceIndex >= 0 && SoundSourceIndex < SoundSources.Length && SoundSources[SoundSourceIndex] != null) { if (SoundSources[SoundSourceIndex].Suppressed) { return(true); } else { if (SoundSources[SoundSourceIndex].OpenAlSourceIndex.Valid) { int i = SoundSources[SoundSourceIndex].OpenAlSourceIndex.Index; int state; Al.alGetSourcei(i, Al.AL_SOURCE_STATE, out state); return(state == Al.AL_PLAYING); } else { return(false); } } } else { return(false); } } else { return(false); } }
private bool IsChannelPlaying(int channel) { int value = 0; Al.alGetSourcei(channel, Al.AL_SOURCE_STATE, out value); return(value == Al.AL_PLAYING); }
protected override void OnSetListener(Vector3 position, Vector3 velocity, Quaternion rotation) { criticalSection.Enter(); //!!!!double Al.alListener3f(Al.AL_POSITION, (float)position.X, (float)position.Y, (float)position.Z); Al.alListener3f(Al.AL_VELOCITY, (float)velocity.X, (float)velocity.Y, (float)velocity.Z); var forward = rotation.GetForward(); var up = rotation.GetUp(); unsafe { fixed(float *orientation = tempFloatArray6) { orientation[0] = (float)forward.X; orientation[1] = (float)forward.Y; orientation[2] = (float)forward.Z; orientation[3] = (float)up.X; orientation[4] = (float)up.Y; orientation[5] = (float)up.Z; Al.alListenerfv(Al.AL_ORIENTATION, orientation); } } CheckError(); criticalSection.Leave(); }
public bool Playback() { int queue = 0; Al.alGetSourcei(source, Al.AL_BUFFERS_QUEUED, out queue); if (queue > 0) { Al.alSourcePlay(source); } if (Playing()) { return(true); } for (int i = 0; i < MAX_BUFFERS; ++i) { if (!Stream(buffers[i])) { return(false); } } Al.alSourceQueueBuffers(source, MAX_BUFFERS, buffers); return(true); }
public AudioEngine(string settingsFile, TimeSpan lookAheadTime, string rendererId) { Alut.alutInit(); // Generate an OpenAL source. Al.alGenSources(1, out source); if (Al.alGetError() != Al.AL_NO_ERROR) { //ERROR } Al.alSourcef(source, Al.AL_PITCH, 1.0f); Al.alSourcef(source, Al.AL_GAIN, 1.0f); //Al.alSourcefv(source, Al.AL_POSITION, sourcePosition); //Al.alSourcefv(source, Al.AL_VELOCITY, sourceVelocity); Al.alSourcei(source, Al.AL_LOOPING, 0); // Do a final error check and then return. if (Al.alGetError() == Al.AL_NO_ERROR) { //ERROR } float[] listenerPosition = { 0, 0, 0 }; float[] listenerVelocity = { 0, 0, 0 }; float[] listenerOrientation = { 0, 0, -1, 0, 1, 0 }; Al.alListenerfv(Al.AL_POSITION, listenerPosition); Al.alListenerfv(Al.AL_VELOCITY, listenerVelocity); Al.alListenerfv(Al.AL_ORIENTATION, listenerOrientation); }
public OpenAlSoundEngine() { //var str = Alc.alcGetString(IntPtr.Zero, Alc.ALC_DEFAULT_DEVICE_SPECIFIER); var dev = Alc.alcOpenDevice(null); if (dev == IntPtr.Zero) { throw new InvalidOperationException("Can't create OpenAL device"); } var ctx = Alc.alcCreateContext(dev, IntPtr.Zero); if (ctx == IntPtr.Zero) { throw new InvalidOperationException("Can't create OpenAL context"); } Alc.alcMakeContextCurrent(ctx); for (var i = 0; i < POOL_SIZE; i++) { var source = 0; Al.alGenSources(1, out source); if (0 != Al.alGetError()) { Log.Write("debug", "Failed generating OpenAL source {0}", i); return; } sourcePool.Add(source, new PoolSlot() { isActive = false }); } }
public OpenALAudioLayer(string name, OpenALAudioAdapter parent) : base(name) { if (_openALFormatId == 0) { _openALFormatId = _openALAudioFormat.BitsPerSample switch { 32 => Al.FORMAT_STEREO32F, 16 => _openALAudioFormat.Channels == 2 ? Al.FORMAT_STEREO16 : Al.FORMAT_MONO16, 8 => _openALAudioFormat.Channels == 2 ? Al.FORMAT_STEREO8 : Al.FORMAT_MONO8, _ => _openALFormatId } } ; if (_frameRequestSize == 0) { _frameRequestSize = _openALAudioFormat.GetFrameCount(BackendBufferExpectedAhead / 1000f); _frameRequestSize /= BUFFER_COUNT; } _parent = parent; Al.GenSource(out _source); _buffers = new uint[BUFFER_COUNT]; _bufferBusy = new bool[BUFFER_COUNT]; for (var i = 0; i < _buffers.Length; i++) { Al.GenBuffer(out _buffers[i]); } _uploadBuffer = new byte[_frameRequestSize * _openALAudioFormat.FrameSize]; }
public virtual void DeleteALBuffers() { Owner.KillChannels(this); if (alBuffer != 0) { if (!Al.IsBuffer(alBuffer)) { throw new Exception("Buffer to delete is invalid!"); } Al.DeleteBuffer(alBuffer); alBuffer = 0; int alError = Al.GetError(); if (alError != Al.NoError) { throw new Exception("Failed to delete OpenAL buffer for non-streamed sound: " + Al.GetErrorString(alError)); } } if (alMuffledBuffer != 0) { if (!Al.IsBuffer(alMuffledBuffer)) { throw new Exception("Buffer to delete is invalid!"); } Al.DeleteBuffer(alMuffledBuffer); alMuffledBuffer = 0; int alError = Al.GetError(); if (alError != Al.NoError) { throw new Exception("Failed to delete OpenAL buffer for non-streamed sound: " + Al.GetErrorString(alError)); } } }
public bool BufferFinished() { // Get number of finished buffers int processed; Al.alGetSourcei(source, Al.AL_BUFFERS_PROCESSED, out processed); if (processed > 0) { // Remove finished buffers from queue int[] finished = new int[processed]; Al.alSourceUnqueueBuffers(source, processed, finished); // Add finished buffers to free queue lock (buffers) { foreach (int i in finished) { buffers.Enqueue(i); Monitor.Pulse(buffers); } } } // Return if we have finished buffers lock (buffers) { return(buffers.Count > 0); } }
public void stopSound() { if (Assets.Instance.Sounds.ContainsKey(this.SoundName)) { Al.alSourceStop(Assets.Instance.Sounds[this.SoundName].SoundID); } }
public virtual void InitializeALBuffers() { if (!Stream) { Al.GenBuffer(out alBuffer); int alError = Al.GetError(); if (alError != Al.NoError) { throw new Exception("Failed to create OpenAL buffer for non-streamed sound: " + Al.GetErrorString(alError)); } if (!Al.IsBuffer(alBuffer)) { throw new Exception("Generated OpenAL buffer is invalid!"); } Al.GenBuffer(out alMuffledBuffer); alError = Al.GetError(); if (alError != Al.NoError) { throw new Exception("Failed to create OpenAL buffer for non-streamed sound: " + Al.GetErrorString(alError)); } if (!Al.IsBuffer(alMuffledBuffer)) { throw new Exception("Generated OpenAL buffer is invalid!"); } } else { alBuffer = 0; } }
public void playSound() { if (Assets.Instance.Sounds.ContainsKey(this.SoundName)) { Al.alSourcePlay(Assets.Instance.Sounds[this.SoundName].SoundID); } }
public void setSoundPosition(Vector3D p) { if (Assets.Instance.Sounds.ContainsKey(this.SoundName)) { Al.alSource3f(Assets.Instance.Sounds[this.SoundName].SoundID, Al.AL_POSITION, (float)p.Px, (float)p.Py, (float)p.Pz); } }
internal unsafe AudioClip(IResource resource) { Al.GenBuffer(out Buffer); using var reader = new VorbisReader(resource.OpenStream()); var channels = reader.Channels; var sampleRate = reader.SampleRate; var seconds = reader.TotalTime.TotalSeconds; var samples = (int)Math.Ceiling(seconds * sampleRate * channels); var floats = new Span <float>(new float[samples]); if (reader.ReadSamples(floats) <= 0) { throw new Exception("Failed to read OGG stream."); } var shorts = new Span <short>(new short[samples]); // 16 bit for (var i = 0; i < floats.Length; i++) shorts[i] = (short)(short.MaxValue * floats[i]); fixed(void *p = &shorts.GetPinnableReference()) { Al.BufferData(Buffer, channels == 2 ? Al.FormatStereo16 : Al.FormatMono16, p, shorts.Length * sizeof(short), sampleRate); } }
public bool BindToBuffer(Sound bufferToBindTo) { if (m_SourceHandle == -1) { return(false); } // Bind the buffer with the source. #if USE_OPENAL Al.alSourcei(m_SourceHandle, Al.AL_BUFFER, bufferToBindTo.m_BufferHandle); Al.alSourcef(m_SourceHandle, Al.AL_PITCH, 1.0f); Al.alSourcef(m_SourceHandle, Al.AL_GAIN, 1.0f); Al.alSourcefv(m_SourceHandle, Al.AL_POSITION, m_SourcePosition); Al.alSourcefv(m_SourceHandle, Al.AL_VELOCITY, m_SourceVelocity); Al.alSourcei(m_SourceHandle, Al.AL_LOOPING, bufferToBindTo.m_Loop); // Do a final error check and then return. if (Al.alGetError() == Al.AL_NO_ERROR) { return(true); } #endif return(false); }
public AudioSource() { // Open default device device = Alc.alcOpenDevice(null); if (device == IntPtr.Zero) { throw new Exception("Unable to open OpenAL device"); } // Create context context = Alc.alcCreateContext(device, IntPtr.Zero); if (context == IntPtr.Zero) { throw new Exception("Unable to create OpenAL context"); } int rv = Alc.alcMakeContextCurrent(context); // Create buffers for (int i = 0; i < 8; ++i) { int b; Al.alGenBuffers(1, out b); buffers.Enqueue(b); } // Create source Al.alGenSources(1, out source); }
public override void end() { if (this.Type == SnowType.Normal) { if (Assets.Instance.Sounds.ContainsKey("Vento")) { Al.alSourceStop(Assets.Instance.Sounds["Vento"].SoundID); } } else if (this.Type == SnowType.Light) { if (Assets.Instance.Sounds.ContainsKey("Vento")) { Al.alSourceStop(Assets.Instance.Sounds["Vento"].SoundID); } } else if (this.Type == SnowType.Strong) { if (Assets.Instance.Sounds.ContainsKey("Vento")) { Al.alSourceStop(Assets.Instance.Sounds["Vento"].SoundID); } } this.engine.ParticleList.Clear(); Gl.glDisable(Gl.GL_FOG); }
protected override void OnSetListener(Vec3 position, Vec3 velocity, Vec3 forward, Vec3 up) { criticalSection.Enter(); Al.alListener3f(Al.AL_POSITION, position.X, position.Y, position.Z); Al.alListener3f(Al.AL_VELOCITY, velocity.X, velocity.Y, velocity.Z); unsafe { fixed(float *orientation = tempFloatArray6) { orientation[0] = forward.X; orientation[1] = forward.Y; orientation[2] = forward.Z; orientation[3] = up.X; orientation[4] = up.Y; orientation[5] = up.Z; Al.alListenerfv(Al.AL_ORIENTATION, orientation); } } CheckError(); criticalSection.Leave(); }
private void DequeueBusyBuffers() { // Check if any are done. Al.GetSourcei(_source, Al.BUFFERS_PROCESSED, out int buffersProcessed); if (buffersProcessed == 0) { return; } // Dequeue and mark as free. var removed = new uint[buffersProcessed]; Al.SourceUnqueueBuffers(_source, buffersProcessed, removed); for (var i = 0; i < buffersProcessed; i++) { uint bufferId = removed[i]; for (var bIdx = 0; bIdx < _buffers.Length; bIdx++) { if (_buffers[bIdx] == bufferId) { _bufferBusy[bIdx] = false; } } } }
public override void InitializeALBuffers() { base.InitializeALBuffers(); reader ??= new VorbisReader(Filename); ALFormat = reader.Channels == 1 ? Al.FormatMono16 : Al.FormatStereo16; SampleRate = reader.SampleRate; if (!Stream) { int bufferSize = (int)reader.TotalSamples * reader.Channels; float[] floatBuffer = new float[bufferSize]; short[] shortBuffer = new short[bufferSize]; int readSamples = reader.ReadSamples(floatBuffer, 0, bufferSize); playbackAmplitude = new List <float>(); for (int i = 0; i < bufferSize; i += reader.Channels * AMPLITUDE_SAMPLE_COUNT) { float maxAmplitude = 0.0f; for (int j = i; j < i + reader.Channels * AMPLITUDE_SAMPLE_COUNT; j++) { if (j >= bufferSize) { break; } maxAmplitude = Math.Max(maxAmplitude, Math.Abs(floatBuffer[j])); } playbackAmplitude.Add(maxAmplitude); } CastBuffer(floatBuffer, shortBuffer, readSamples); Al.BufferData(ALBuffer, ALFormat, shortBuffer, readSamples * sizeof(short), SampleRate); int alError = Al.GetError(); if (alError != Al.NoError) { throw new Exception("Failed to set buffer data for non-streamed audio! " + Al.GetErrorString(alError)); } MuffleBuffer(floatBuffer, SampleRate, reader.Channels); CastBuffer(floatBuffer, shortBuffer, readSamples); Al.BufferData(ALMuffledBuffer, ALFormat, shortBuffer, readSamples * sizeof(short), SampleRate); alError = Al.GetError(); if (alError != Al.NoError) { throw new Exception("Failed to set buffer data for non-streamed audio! " + Al.GetErrorString(alError)); } reader.Dispose(); reader = null; } }
public bool Playing() { int state; Al.alGetSourcei(source, Al.AL_SOURCE_STATE, out state); return(state == Al.AL_PLAYING); }
unsafe protected override void PreDetachVirtualChannel() { OpenALSoundWorld.criticalSection.Enter(); Al.alSourceStop(alSource); OpenALSoundWorld.CheckError(); if (currentSound is OpenALDataBufferSound) { if (currentSound is OpenALFileStreamSound) { OpenALSoundWorld.Instance.fileStreamRealChannels.Remove(this); } if (streamBuffer != null) { NativeUtils.Free((IntPtr)streamBuffer); streamBuffer = null; streamBufferSize = 0; } } Al.alSourcei(alSource, Al.AL_BUFFER, 0); OpenALSoundWorld.CheckError(); currentSound = null; OpenALSoundWorld.criticalSection.Leave(); }
private bool Update() { int processed; bool active = true; Al.alGetSourcei(source, Al.AL_BUFFERS_PROCESSED, out processed); while (processed-- > 0) { int buffer = -1; Al.alSourceUnqueueBuffers(source, 1, ref buffer); Check(); active = Stream(buffer); if (active) { Al.alSourceQueueBuffers(source, 1, ref buffer); Check(); } } return(active); }
void UpdatePosition2() { Vec3 value = CurrentVirtualChannel.Position; Al.alSource3f(alSource, Al.AL_POSITION, value.X, value.Y, value.Z); OpenALSoundWorld.CheckError(); }
public Sound PlaySound(string soundId, bool loop) { int channel = FindNextFreeChannel(); if (channel != -1) { Al.alSourceStop(channel); Al.alSourcei(channel, Al.AL_BUFFER, _soundIdentifier[soundId]._bufferId); Al.alSourcef(channel, Al.AL_PITCH, 1.0f); Al.alSourcef(channel, Al.AL_GAIN, 1.0f); if (loop) { Al.alSourcei(channel, Al.AL_LOOPING, 1); } else { Al.alSourcei(channel, Al.AL_LOOPING, 0); } Al.alSourcef(channel, Al.AL_GAIN, _masterVolume); Al.alSourcePlay(channel); return(new Sound(channel)); } else { // Error sound return(new Sound(-1)); } }
void UpdateVelocity2() { Vec3 value = CurrentVirtualChannel.Velocity; Al.alSource3f(alSource, Al.AL_VELOCITY, value.X, value.Y, value.Z); OpenALSoundWorld.CheckError(); }
// internal static bool CheckError() { int error = Al.alGetError(); if (error == Al.AL_NO_ERROR) { return(false); } string text; switch (error) { case Al.AL_INVALID_ENUM: text = "Invalid enum"; break; case Al.AL_INVALID_VALUE: text = "Invalid value"; break; case Al.AL_INVALID_OPERATION: text = "Invalid operation"; break; case Al.AL_OUT_OF_MEMORY: text = "Out of memory"; break; case Al.AL_INVALID_NAME: text = "Invalid name"; break; default: text = string.Format("Unknown error ({0})", error); break; } Log.Warning("OpenALSoundSystem: Internal error: {0}.", text); return(true); }
void UpdateVolume2() { float value = CurrentVirtualChannel.GetTotalVolume() * CurrentVirtualChannel.GetRolloffFactor(); Al.alSourcef(alSource, Al.AL_GAIN, value); OpenALSoundWorld.CheckError(); }
// --- Event Handlers --- #region Timer_Elapsed(object source, ElapsedEventArgs e) private static void Timer_Elapsed(object s, ElapsedEventArgs e) { sourcePosition[0] += sourceVelocity[0]; sourcePosition[1] += sourceVelocity[1]; sourcePosition[2] += sourceVelocity[2]; Al.alSourcefv(source, Al.AL_POSITION, sourcePosition); }
public void PlayAnAvailableCopy() { SoundSource <T> soundToBindAndPlay = null; if (s_AvailableSoundSources.Count < s_MaxSimultaneousSounds) { soundToBindAndPlay = new SoundSource <T>(); s_AvailableSoundSources.Add(soundToBindAndPlay); } else { // Find the first sound not playing. foreach (SoundSource <T> notPlayingSound in s_AvailableSoundSources) { int playingValue; Al.alGetSourcei(notPlayingSound.m_SourceHandle, (int)Al.AL_SOURCE_STATE, out playingValue); if (playingValue == (int)Al.AL_STOPPED) { soundToBindAndPlay = notPlayingSound; break; } } // TODO: No sound is available that is not playing. Find the quietest sound and if it is quieter than // the sound we are about to play than play it. } if (soundToBindAndPlay != null) { soundToBindAndPlay.BindToBuffer(this); soundToBindAndPlay.Play(); } }