370 lines
9.4 KiB
C#
370 lines
9.4 KiB
C#
#region Copyright & License Information
|
|
/*
|
|
* Copyright 2007-2015 The OpenRA Developers (see AUTHORS)
|
|
* This file is part of OpenRA, which is free software. It is made
|
|
* available to you under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation. For more information,
|
|
* see COPYING.
|
|
*/
|
|
#endregion
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using OpenRA.FileFormats;
|
|
using OpenRA.FileSystem;
|
|
using OpenRA.GameRules;
|
|
using OpenRA.Primitives;
|
|
using OpenRA.Traits;
|
|
using OpenTK;
|
|
using OpenTK.Audio.OpenAL;
|
|
|
|
namespace OpenRA.Platforms.Default
|
|
{
|
|
class OpenAlSoundEngine : ISoundEngine
|
|
{
|
|
public SoundDevice[] AvailableDevices()
|
|
{
|
|
var defaultDevices = new[]
|
|
{
|
|
new SoundDevice("Default", null, "Default Output"),
|
|
new SoundDevice("Null", null, "Output Disabled")
|
|
};
|
|
|
|
var physicalDevices = PhysicalDevices().Select(d => new SoundDevice("Default", d, d));
|
|
return defaultDevices.Concat(physicalDevices).ToArray();
|
|
}
|
|
|
|
class PoolSlot
|
|
{
|
|
public bool IsActive;
|
|
public int FrameStarted;
|
|
public WPos Pos;
|
|
public bool IsRelative;
|
|
public ISoundSource Sound;
|
|
}
|
|
|
|
const int MaxInstancesPerFrame = 3;
|
|
const int GroupDistance = 2730;
|
|
const int GroupDistanceSqr = GroupDistance * GroupDistance;
|
|
const int PoolSize = 32;
|
|
|
|
float volume = 1f;
|
|
Dictionary<int, PoolSlot> sourcePool = new Dictionary<int, PoolSlot>();
|
|
|
|
static string[] QueryDevices(string label, AlcGetStringList type)
|
|
{
|
|
// Clear error bit
|
|
AL.GetError();
|
|
|
|
var devices = Alc.GetString(IntPtr.Zero, type).ToArray();
|
|
if (AL.GetError() != ALError.NoError)
|
|
{
|
|
Log.Write("sound", "Failed to query OpenAL device list using {0}", label);
|
|
return new string[] { };
|
|
}
|
|
|
|
return devices;
|
|
}
|
|
|
|
static string[] PhysicalDevices()
|
|
{
|
|
// Returns all devices under Windows Vista and newer
|
|
if (Alc.IsExtensionPresent(IntPtr.Zero, "ALC_ENUMERATE_ALL_EXT"))
|
|
return QueryDevices("ALC_ENUMERATE_ALL_EXT", AlcGetStringList.AllDevicesSpecifier);
|
|
|
|
if (Alc.IsExtensionPresent(IntPtr.Zero, "ALC_ENUMERATION_EXT"))
|
|
return QueryDevices("ALC_ENUMERATION_EXT", AlcGetStringList.DeviceSpecifier);
|
|
|
|
return new string[] { };
|
|
}
|
|
|
|
public OpenAlSoundEngine()
|
|
{
|
|
Console.WriteLine("Using OpenAL sound engine");
|
|
|
|
if (Game.Settings.Sound.Device != null)
|
|
Console.WriteLine("Using device `{0}`", Game.Settings.Sound.Device);
|
|
else
|
|
Console.WriteLine("Using default device");
|
|
|
|
var dev = Alc.OpenDevice(Game.Settings.Sound.Device);
|
|
if (dev == IntPtr.Zero)
|
|
{
|
|
Console.WriteLine("Failed to open device. Falling back to default");
|
|
dev = Alc.OpenDevice(null);
|
|
if (dev == IntPtr.Zero)
|
|
throw new InvalidOperationException("Can't create OpenAL device");
|
|
}
|
|
|
|
var ctx = Alc.CreateContext(dev, (int[])null);
|
|
if (ctx == ContextHandle.Zero)
|
|
throw new InvalidOperationException("Can't create OpenAL context");
|
|
Alc.MakeContextCurrent(ctx);
|
|
|
|
for (var i = 0; i < PoolSize; i++)
|
|
{
|
|
var source = 0;
|
|
AL.GenSources(1, out source);
|
|
if (0 != AL.GetError())
|
|
{
|
|
Log.Write("sound", "Failed generating OpenAL source {0}", i);
|
|
return;
|
|
}
|
|
|
|
sourcePool.Add(source, new PoolSlot() { IsActive = false });
|
|
}
|
|
}
|
|
|
|
int GetSourceFromPool()
|
|
{
|
|
foreach (var kvp in sourcePool)
|
|
{
|
|
if (!kvp.Value.IsActive)
|
|
{
|
|
sourcePool[kvp.Key].IsActive = true;
|
|
return kvp.Key;
|
|
}
|
|
}
|
|
|
|
var freeSources = new List<int>();
|
|
foreach (var key in sourcePool.Keys)
|
|
{
|
|
int state;
|
|
AL.GetSource(key, ALGetSourcei.SourceState, out state);
|
|
if (state != (int)ALSourceState.Playing && state != (int)ALSourceState.Paused)
|
|
freeSources.Add(key);
|
|
}
|
|
|
|
if (freeSources.Count == 0)
|
|
return -1;
|
|
|
|
foreach (var i in freeSources)
|
|
sourcePool[i].IsActive = false;
|
|
|
|
sourcePool[freeSources[0]].IsActive = true;
|
|
|
|
return freeSources[0];
|
|
}
|
|
|
|
public ISoundSource AddSoundSourceFromMemory(byte[] data, int channels, int sampleBits, int sampleRate)
|
|
{
|
|
return new OpenAlSoundSource(data, channels, sampleBits, sampleRate);
|
|
}
|
|
|
|
public ISound Play2D(ISoundSource sound, bool loop, bool relative, WPos pos, float volume, bool attenuateVolume)
|
|
{
|
|
if (sound == null)
|
|
{
|
|
Log.Write("sound", "Attempt to Play2D a null `ISoundSource`");
|
|
return null;
|
|
}
|
|
|
|
var currFrame = Game.LocalTick;
|
|
var atten = 1f;
|
|
|
|
// Check if max # of instances-per-location reached:
|
|
if (attenuateVolume)
|
|
{
|
|
int instances = 0, activeCount = 0;
|
|
foreach (var s in sourcePool.Values)
|
|
{
|
|
if (!s.IsActive)
|
|
continue;
|
|
if (s.IsRelative != relative)
|
|
continue;
|
|
|
|
++activeCount;
|
|
if (s.Sound != sound)
|
|
continue;
|
|
if (currFrame - s.FrameStarted >= 5)
|
|
continue;
|
|
|
|
// Too far away to count?
|
|
var lensqr = (s.Pos - pos).LengthSquared;
|
|
if (lensqr >= GroupDistanceSqr)
|
|
continue;
|
|
|
|
// If we are starting too many instances of the same sound within a short time then stop this one:
|
|
if (++instances == MaxInstancesPerFrame)
|
|
return null;
|
|
}
|
|
|
|
// Attenuate a little bit based on number of active sounds:
|
|
atten = 0.66f * ((PoolSize - activeCount * 0.5f) / PoolSize);
|
|
}
|
|
|
|
var source = GetSourceFromPool();
|
|
if (source == -1)
|
|
return null;
|
|
|
|
var slot = sourcePool[source];
|
|
slot.Pos = pos;
|
|
slot.FrameStarted = currFrame;
|
|
slot.Sound = sound;
|
|
slot.IsRelative = relative;
|
|
return new OpenAlSound(source, ((OpenAlSoundSource)sound).Buffer, loop, relative, pos, volume * atten);
|
|
}
|
|
|
|
public float Volume
|
|
{
|
|
get { return volume; }
|
|
set { AL.Listener(ALListenerf.Gain, volume = value); }
|
|
}
|
|
|
|
public void PauseSound(ISound sound, bool paused)
|
|
{
|
|
if (sound == null)
|
|
return;
|
|
|
|
var key = ((OpenAlSound)sound).Source;
|
|
int state;
|
|
AL.GetSource(key, ALGetSourcei.SourceState, out state);
|
|
if (state == (int)ALSourceState.Playing && paused)
|
|
AL.SourcePause(key);
|
|
else if (state == (int)ALSourceState.Paused && !paused)
|
|
AL.SourcePlay(key);
|
|
}
|
|
|
|
public void SetAllSoundsPaused(bool paused)
|
|
{
|
|
foreach (var key in sourcePool.Keys)
|
|
{
|
|
int state;
|
|
AL.GetSource(key, ALGetSourcei.SourceState, out state);
|
|
if (state == (int)ALSourceState.Playing && paused)
|
|
AL.SourcePause(key);
|
|
else if (state == (int)ALSourceState.Paused && !paused)
|
|
AL.SourcePlay(key);
|
|
}
|
|
}
|
|
|
|
public void SetSoundVolume(float volume, ISound music, ISound video)
|
|
{
|
|
var sounds = sourcePool.Select(s => s.Key).Where(b =>
|
|
{
|
|
int state;
|
|
AL.GetSource(b, ALGetSourcei.SourceState, out state);
|
|
return (state == (int)ALSourceState.Playing || state == (int)ALSourceState.Paused) &&
|
|
(music == null || b != ((OpenAlSound)music).Source) &&
|
|
(video == null || b != ((OpenAlSound)video).Source);
|
|
});
|
|
|
|
foreach (var s in sounds)
|
|
AL.Source(s, ALSourcef.Gain, volume);
|
|
}
|
|
|
|
public void StopSound(ISound sound)
|
|
{
|
|
if (sound == null)
|
|
return;
|
|
|
|
var key = ((OpenAlSound)sound).Source;
|
|
int state;
|
|
AL.GetSource(key, ALGetSourcei.SourceState, out state);
|
|
if (state == (int)ALSourceState.Playing || state == (int)ALSourceState.Paused)
|
|
AL.SourceStop(key);
|
|
}
|
|
|
|
public void StopAllSounds()
|
|
{
|
|
foreach (var key in sourcePool.Keys)
|
|
{
|
|
int state;
|
|
AL.GetSource(key, ALGetSourcei.SourceState, out state);
|
|
if (state == (int)ALSourceState.Playing || state == (int)ALSourceState.Paused)
|
|
AL.SourceStop(key);
|
|
}
|
|
}
|
|
|
|
public void SetListenerPosition(WPos position)
|
|
{
|
|
// Move the listener out of the plane so that sounds near the middle of the screen aren't too positional
|
|
AL.Listener(ALListener3f.Position, position.X, position.Y, position.Z + 2133);
|
|
|
|
var orientation = new[] { 0f, 0f, 1f, 0f, -1f, 0f };
|
|
AL.Listener(ALListenerfv.Orientation, ref orientation);
|
|
AL.Listener(ALListenerf.EfxMetersPerUnit, .01f);
|
|
}
|
|
}
|
|
|
|
class OpenAlSoundSource : ISoundSource
|
|
{
|
|
public readonly int Buffer;
|
|
|
|
static ALFormat MakeALFormat(int channels, int bits)
|
|
{
|
|
if (channels == 1)
|
|
return bits == 16 ? ALFormat.Mono16 : ALFormat.Mono8;
|
|
else
|
|
return bits == 16 ? ALFormat.Stereo16 : ALFormat.Stereo8;
|
|
}
|
|
|
|
public OpenAlSoundSource(byte[] data, int channels, int sampleBits, int sampleRate)
|
|
{
|
|
AL.GenBuffers(1, out Buffer);
|
|
AL.BufferData(Buffer, MakeALFormat(channels, sampleBits), data, data.Length, sampleRate);
|
|
}
|
|
}
|
|
|
|
class OpenAlSound : ISound
|
|
{
|
|
public readonly int Source = -1;
|
|
float volume = 1f;
|
|
|
|
public OpenAlSound(int source, int buffer, bool looping, bool relative, WPos pos, float volume)
|
|
{
|
|
if (source == -1)
|
|
return;
|
|
|
|
Source = source;
|
|
Volume = volume;
|
|
|
|
AL.Source(source, ALSourcef.Pitch, 1f);
|
|
AL.Source(source, ALSource3f.Position, pos.X, pos.Y, pos.Z);
|
|
AL.Source(source, ALSource3f.Velocity, 0f, 0f, 0f);
|
|
AL.Source(source, ALSourcei.Buffer, buffer);
|
|
AL.Source(source, ALSourceb.Looping, looping);
|
|
AL.Source(source, ALSourceb.SourceRelative, relative);
|
|
|
|
AL.Source(source, ALSourcef.ReferenceDistance, 6826);
|
|
AL.Source(source, ALSourcef.MaxDistance, 136533);
|
|
AL.SourcePlay(source);
|
|
}
|
|
|
|
public float Volume
|
|
{
|
|
get
|
|
{
|
|
return volume;
|
|
}
|
|
|
|
set
|
|
{
|
|
if (Source != -1)
|
|
AL.Source(Source, ALSourcef.Gain, volume = value);
|
|
}
|
|
}
|
|
|
|
public float SeekPosition
|
|
{
|
|
get
|
|
{
|
|
int pos;
|
|
AL.GetSource(Source, ALGetSourcei.SampleOffset, out pos);
|
|
return pos / 22050f;
|
|
}
|
|
}
|
|
|
|
public bool Playing
|
|
{
|
|
get
|
|
{
|
|
int state;
|
|
AL.GetSource(Source, ALGetSourcei.SourceState, out state);
|
|
return state == (int)ALSourceState.Playing;
|
|
}
|
|
}
|
|
}
|
|
}
|