public static IAudio LoadWave(string filePath) { if (_disposables.ContainsKey(filePath)) { return((IAudio)_disposables[filePath]); } IntPtr device = Alc.OpenDevice(null); ContextHandle handle = Alc.CreateContext(device, (int[])null); Alc.MakeContextCurrent(handle); int buffer = AL.GenBuffer(); int source = AL.GenSource(); WaveFileReader reader = new WaveFileReader(filePath); byte[] data = new byte[reader.Length]; reader.Read(data, 0, data.Length); AL.BufferData(buffer, GetSoundFormat(reader.WaveFormat.Channels, reader.WaveFormat.BitsPerSample), data, data.Length, reader.WaveFormat.SampleRate); AL.Source(source, ALSourcei.Buffer, buffer); IAudio audio = new WaveAudio(filePath, source, buffer, handle); _disposables.TryAdd(filePath, audio); return(audio); }
private OpenALSoundController() { alcMacOSXMixerOutputRate(PREFERRED_MIX_RATE); _device = Alc.OpenDevice(string.Empty); CheckALError("Could not open AL device"); if (_device != IntPtr.Zero) { int[] attribute = new int[0]; _context = Alc.CreateContext(_device, attribute); CheckALError("Could not open AL context"); if (_context != ContextHandle.Zero) { Alc.MakeContextCurrent(_context); CheckALError("Could not make AL context current"); } } else { return; } allSourcesArray = new int[MAX_NUMBER_OF_SOURCES]; AL.GenSources(allSourcesArray); availableSourcesCollection = new HashSet <int> (); inUseSourcesCollection = new HashSet <OALSoundBuffer> (); playingSourcesCollection = new HashSet <OALSoundBuffer> (); for (int x = 0; x < MAX_NUMBER_OF_SOURCES; x++) { availableSourcesCollection.Add(allSourcesArray [x]); } }
public ALOutput(DataSource data) { this._source = data; this._dev = Alc.OpenDevice((string)null); if (this._dev.Equals((object)IntPtr.Zero)) { throw new AudioException("Failed to init OpenAL"); } Alc.MakeContextCurrent(Alc.CreateContext(this._dev, new int[2] { 4103, 44100 })); float[] values = new float[6] { 0.0f, 0.0f, 1f, 0.0f, 1f, 0.0f }; AL.Listener(ALListener3f.Position, 0.0f, 0.0f, 0.0f); AL.Listener(ALListener3f.Velocity, 0.0f, 0.0f, 0.0f); AL.Listener(ALListenerfv.Orientation, ref values); AL.DistanceModel(ALDistanceModel.None); this._sChannels = new ALOutput.Channel[16]; for (int index = 0; index < this._sChannels.Length; ++index) { this._sChannels[index].Handle = AL.GenSource(); } ALOutput.Check(); new Thread(new ThreadStart(this.ThreadProc)).Start(); }
public AudioContext([NotNull] AudioDevice device, [CanBeNull] int[] attribList) { _context = Alc.CreateContext(device.NativeDevice, attribList); Device = device; _watchThread = new WatchThread(this); _watchThread.Start(); }
public static void Main(string[] args) { var device = Alc.OpenDevice(null); var context = Alc.CreateContext(device, null); Console.WriteLine(Alc.MakeContextCurrent(context)); }
/// <summary> /// Open the sound device, sets up an audio context, and makes the new context /// the current context. Note that this method will stop the playback of /// music that was running prior to the game start. If any error occurs, then /// the state of the controller is reset. /// </summary> /// <returns>True if the sound controller was setup, and false if not.</returns> private bool OpenSoundController() { #if MACOSX || IOS alcMacOSXMixerOutputRate(PREFERRED_MIX_RATE); #endif _device = Alc.OpenDevice(string.Empty); if (CheckALError("Could not open AL device")) { return(false); } if (_device != IntPtr.Zero) { int[] attribute = new int[0]; _context = Alc.CreateContext(_device, attribute); if (CheckALError("Could not open AL context")) { CleanUpOpenAL(); return(false); } if (_context != ContextHandle.Zero) { Alc.MakeContextCurrent(_context); if (CheckALError("Could not make AL context current")) { CleanUpOpenAL(); return(false); } return(true); } } return(false); }
public static OpenALAudioAdapter TryCreate(PlatformBase _) { var newCtx = new OpenALAudioAdapter(); newCtx.AudioDevice = Alc.OpenDevice(null); if (newCtx.AudioDevice == IntPtr.Zero) { Engine.Log.Error("Couldn't find an OpenAL device.", MessageSource.OpenAL); return(null); } var attr = new int[0]; newCtx.AudioContext = Alc.CreateContext(newCtx.AudioDevice, attr); if (newCtx.AudioContext == IntPtr.Zero) { Engine.Log.Error("Couldn't create OpenAL context.", MessageSource.OpenAL); return(null); } bool success = Alc.MakeContextCurrent(newCtx.AudioContext); if (!success) { Engine.Log.Error("Couldn't make OpenAL context current.", MessageSource.OpenAL); return(null); } return(newCtx); }
public SID_OpenAL() : base() { ALDevice = Alc.OpenDevice(null); int[] attribs = null; context = Alc.CreateContext(ALDevice, attribs); Alc.MakeContextCurrent(context); }
public static void InitialSetup() { // FOR THE LOVE OF GOD PLEASE LET THIS WORK AudioDevice = Alc.OpenDevice(null); // Default device if (AudioDevice != null) { AudioCtx = Alc.CreateContext(AudioDevice, (int[])null); if (AudioCtx != ContextHandle.Zero) { Alc.GetError(AudioDevice); if (Alc.MakeContextCurrent(AudioCtx)) { //LoadWaveFile ("camprespite_loop", "camprespite_loop.wav"); LoadWaveFile("last_human_loop", "last_human_loop_limited.wav"); //.DurationAdjust(0.01); LoadWaveFile("induction_loop", "induction_loop.wav"); LoadWaveFile("sfx_bullet_impact", "sfx_bullet_impact.wav"); LoadWaveFile("sfx_player_land_two_feet", "sfx_player_land_two_feet.wav"); LoadWaveFile("sfx_shoot_gun", "sfx_shoot_gun.wav"); LoadWaveFile("win", "win.wav"); } else { throw new Exception("Failed to set current audio context"); } } else { throw new Exception("Failed to create audio context."); } } else { throw new Exception("Failed to open default audio device."); } }
private bool INTERNAL_initSoundController() { #if IOS alcMacOSXMixerOutputRate(44100); #endif try { _device = Alc.OpenDevice(string.Empty); } catch { return(false); } if (CheckALCError("Could not open AL device") || _device == IntPtr.Zero) { return(false); } int[] attribute = new int[0]; _context = Alc.CreateContext(_device, attribute); if (CheckALCError("Could not create OpenAL context") || _context == ContextHandle.Zero) { Dispose(true); return(false); } Alc.MakeContextCurrent(_context); if (CheckALCError("Could not make OpenAL context current")) { Dispose(true); return(false); } return(true); }
public AccelerometerMusicBuffer() { _sampleRate = 44100; _device = Alc.OpenDevice(null); _context = Alc.CreateContext(_device, (int *)null); Alc.MakeContextCurrent(_context); //AL.GenBuffers(1, out uint buffers); _buffers = AL.GenBuffers(8); AL.GenBuffer(out uint bassABuffer); //_buffers = buffers; AL.GenSource(out _sourceOne); AL.GenSource(out _sourceTwo); AL.GenSource(out _sourceThree); AL.GenSource(out _sourceFour); AL.GenSource(out _sourceFive); var bassWave = ResolveSineWave(0.25 * short.MaxValue, 110); AL.BufferData((int)bassABuffer, ALFormat.Mono16, bassWave, bassWave.Length, _sampleRate); AL.Source(_sourceFive, ALSourceb.Looping, true); AL.SourceQueueBuffer((int)_sourceFive, (int)bassABuffer); AL.SourcePlay(_sourceFive); _leftHandData = new List <int>(); _rightHandData = new List <int>(); }
private static void TryInitAudio() { int tries = 0; while (mAudioOn == false && tries < 10) { try { mDeviceID = Alc.OpenDevice(null); KWLogger.Log("Initializing OpenAL (Attempt #" + tries + ")", "GLAudioEngine::TryInitAudio"); Console.WriteLine("Initializing audio engine OpenAL (Attempt #" + tries + ")... "); int[] attributes = new int[0]; mContext = Alc.CreateContext(mDeviceID, attributes); Alc.MakeContextCurrent(mContext); var version = AL.Get(ALGetString.Version); var vendor = AL.Get(ALGetString.Vendor); if (version == null) { KWLogger.Log("No Audio devices found.", "GLAudioEngine::TryInitAudio", LogLevel.Error); throw new Exception("No Audio devices found."); } Console.Write('\t' + version + " " + vendor); Console.WriteLine(" Init complete."); KWLogger.Log("Audio initialized: " + version + " " + vendor, "GLAudioEngine::TryInitAudio"); mAudioOn = true; } catch (Exception) { mAudioOn = false; } if (mAudioOn == false) { tries++; Thread.Sleep(500); } } IsInitializing = false; if (mAudioOn) { for (int i = 0; i < mChannels; i++) { GLAudioSource s = new GLAudioSource(); mSources.Add(s); } } else { Console.WriteLine("\t\t(Giving up on initializing the audio engine. Sorry.)"); KWLogger.Log("Giving up on initializing the audio engine. Sorry.", "GLAudioEngine::TryInitAudio", LogLevel.Error); } }
static ContextManager() { var device = Alc.OpenDevice(null); if (device != IntPtr.Zero) { AudioContext = Alc.CreateContext(device, null); Alc.MakeContextCurrent(AudioContext); } }
public static void Init() { var deviceName = Alc.GetString(IntPtr.Zero, AlcGetString.DefaultAllDevicesSpecifier); Console.WriteLine(deviceName); _device = Alc.OpenDevice(deviceName); _context = Alc.CreateContext(_device, (int[])null); Alc.MakeContextCurrent(_context); CheckError(); }
public AudioDevice(string device = null) { if (device == null) { device = Alc.GetString(IntPtr.Zero, AlcGetString.DefaultDeviceSpecifier); } deviceId = Alc.OpenDevice(device); contextHandle = Alc.CreateContext(deviceId, new int[] { }); this.Use(); }
public AlPlayer(IMusicPlayer player, int rate) { _player = player; _rate = rate; _device = Alc.OpenDevice(null); _context = Alc.CreateContext(_device, null); Console.WriteLine(Alc.GetString(IntPtr.Zero, Alc.AllDevicesSpecifier)); Alc.MakeContextCurrent(_context); }
static int[] Initialize(out IntPtr device, out ContextHandle context, out int source) { device = Alc.OpenDevice(null); context = Alc.CreateContext(device, (int[])null); Alc.MakeContextCurrent(context); var buffers = AL.GenBuffers(BuffersCount); AL.GenSources(1, out source); return(buffers); }
private static void _CreateAudioContext() { IntPtr d = Alc.OpenDevice(OpenTK.Audio.AudioContext.DefaultDevice); OpenTK.ContextHandle c = Alc.CreateContext(d, new int[0]); Alc.MakeContextCurrent(c); AL.Listener(ALListener3f.Position, 0, 0, 0); AL.Listener(ALListener3f.Velocity, 0, 0, 0); float[] vs = new float[] { 0, 0, -1, 0, 1, 0 }; AL.Listener(ALListenerfv.Orientation, ref vs); }
// --- initialization and deinitialization --- /// <summary>Initializes audio. A call to Deinitialize must be made when terminating the program.</summary> /// <returns>Whether initializing audio was successful.</returns> internal static bool Initialize() { Deinitialize(); switch (Options.Current.SoundRange) { case SoundRange.Low: OuterRadiusFactorMinimum = 2.0; OuterRadiusFactorMaximum = 8.0; OuterRadiusFactorMaximumSpeed = 1.0; break; case SoundRange.Medium: OuterRadiusFactorMinimum = 4.0; OuterRadiusFactorMaximum = 16.0; OuterRadiusFactorMaximumSpeed = 2.0; break; case SoundRange.High: OuterRadiusFactorMinimum = 6.0; OuterRadiusFactorMaximum = 24.0; OuterRadiusFactorMaximumSpeed = 3.0; break; } OuterRadiusFactor = Math.Sqrt(OuterRadiusFactorMinimum * OuterRadiusFactorMaximum); OuterRadiusFactorSpeed = 0.0; OpenAlDevice = Alc.OpenDevice(null); if (OpenAlDevice != IntPtr.Zero) { OpenAlContext = Alc.CreateContext(OpenAlDevice, new int[0]); if (OpenAlContext != ContextHandle.Zero) { Alc.MakeContextCurrent(OpenAlContext); try { AL.SpeedOfSound(343.0f); } catch { Debug.AddMessage(Debug.MessageType.Error, false, "OpenAL 1.1 is required. You seem to have OpenAL 1.0."); } AL.DistanceModel(ALDistanceModel.None); return(true); } AlcError error = Alc.GetError(OpenAlDevice); Alc.CloseDevice(OpenAlDevice); OpenAlDevice = IntPtr.Zero; Debug.AddMessage(Debug.MessageType.Error, false, "The OpenAL context could not be created: " + error); return(false); } ALError devError = AL.GetError(); OpenAlContext = ContextHandle.Zero; Debug.AddMessage(Debug.MessageType.Error, false, "The OpenAL sound device could not be opened: " + AL.GetErrorString(devError)); return(false); }
static void Main() { Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); var device = Alc.OpenDevice(null); var context = Alc.CreateContext(device, (int[])null); Alc.MakeContextCurrent(context); Application.Run(new MainWindow()); Alc.MakeContextCurrent(OpenTK.ContextHandle.Zero); Alc.DestroyContext(context); Alc.CloseDevice(device); }
public static void Init() { _device = Alc.OpenDevice(null); _context = Alc.CreateContext(_device, (int[])null); Alc.MakeContextCurrent(_context); AL.DistanceModel(ALDistanceModel.InverseDistanceClamped); for (int i = 0; i < _maxSources; i++) { _sources[i].Source = new AudioSource(); _sources[i].Owner = null; } }
// --- initialization and deinitialization --- /// <summary>Initializes audio. A call to Deinitialize must be made when terminating the program.</summary> /// <returns>Whether initializing audio was successful.</returns> internal static void Initialize() { Deinitialize(); switch (Interface.CurrentOptions.SoundRange) { case Interface.SoundRange.Low: OuterRadiusFactorMinimum = 2.0; OuterRadiusFactorMaximum = 8.0; OuterRadiusFactorMaximumSpeed = 1.0; break; case Interface.SoundRange.Medium: OuterRadiusFactorMinimum = 4.0; OuterRadiusFactorMaximum = 16.0; OuterRadiusFactorMaximumSpeed = 2.0; break; case Interface.SoundRange.High: OuterRadiusFactorMinimum = 6.0; OuterRadiusFactorMaximum = 24.0; OuterRadiusFactorMaximumSpeed = 3.0; break; } OuterRadiusFactor = Math.Sqrt(OuterRadiusFactorMinimum * OuterRadiusFactorMaximum); OuterRadiusFactorSpeed = 0.0; OpenAlDevice = Alc.OpenDevice(null); if (OpenAlDevice != IntPtr.Zero) { OpenAlContext = Alc.CreateContext(OpenAlDevice, (int[])null); if (OpenAlContext != ContextHandle.Zero) { Alc.MakeContextCurrent(OpenAlContext); try { AL.SpeedOfSound(343.0f); } catch { //MessageBox.Show(Interface.GetInterfaceString("errors_sound_openal_version"), Interface.GetInterfaceString("program_title"), MessageBoxButtons.OK, MessageBoxIcon.Hand); } AL.DistanceModel(ALDistanceModel.None); return; } Alc.CloseDevice(OpenAlDevice); OpenAlDevice = IntPtr.Zero; //MessageBox.Show(Interface.GetInterfaceString("errors_sound_openal_context"), Interface.GetInterfaceString("program_title"), MessageBoxButtons.OK, MessageBoxIcon.Hand); return; } OpenAlContext = ContextHandle.Zero; //MessageBox.Show(Interface.GetInterfaceString("errors_sound_openal_device"), Interface.GetInterfaceString("program_title"), MessageBoxButtons.OK, MessageBoxIcon.Hand); }
public void ChangeAudioDevice(string DeviceName) { this.Device = Alc.OpenDevice(DeviceName); this.AudioContext = Alc.CreateContext(Device, (int[])null); Alc.MakeContextCurrent(AudioContext); Alc.GetInteger(Device, AlcGetInteger.AttributesSize, 1, out int size); int[] data = new int[size]; Alc.GetInteger(Device, AlcGetInteger.AllAttributes, size, data); this.MaxSourceCount = data[Alc.GetEnumValue(Device, "ALC_MONO_SOURCES")];//ここあやしい Sources = AL.GenSources(MaxSourceCount); }
public static void Initialize() { IntPtr device = Alc.OpenDevice(""); ContextHandle context = Alc.CreateContext(device, new int[0]); Alc.MakeContextCurrent(context); #if DEBUG GlobalEvent.EndStep += () => { _Audio.ErrorCheck(); }; #endif }
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 }); } }
public AudioDevice(string device = null) { if (device == null) { device = Alc.GetString(IntPtr.Zero, AlcGetString.DefaultDeviceSpecifier); } deviceId = Alc.OpenDevice(device); if (deviceId == IntPtr.Zero) { throw new Exception("unable to open the specified audio device"); } contextHandle = Alc.CreateContext(deviceId, new int[] { }); this.Use(); }
public OpenALDevice() { if (Instance != null) { throw new Exception("OpenALDevice already created!"); } alDevice = Alc.OpenDevice(string.Empty); if (CheckALCError("Could not open AL device") || alDevice == IntPtr.Zero) { throw new Exception("Could not open AL device!"); } int[] attribute = new int[0]; alContext = Alc.CreateContext(alDevice, attribute); if (CheckALCError("Could not create OpenAL context") || alContext == ContextHandle.Zero) { Dispose(); throw new Exception("Could not create OpenAL context"); } Alc.MakeContextCurrent(alContext); if (CheckALCError("Could not make OpenAL context current")) { Dispose(); throw new Exception("Could not make OpenAL context current"); } EFX = new EffectsExtension(); float[] ori = new float[] { 0.0f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f }; AL.Listener(ALListenerfv.Orientation, ref ori); AL.Listener(ALListener3f.Position, 0.0f, 0.0f, 0.0f); AL.Listener(ALListener3f.Velocity, 0.0f, 0.0f, 0.0f); AL.Listener(ALListenerf.Gain, 1.0f); // We do NOT use automatic attenuation! XNA does not do this! AL.DistanceModel(ALDistanceModel.None); instancePool = new List <SoundEffectInstance>(); dynamicInstancePool = new List <DynamicSoundEffectInstance>(); Instance = this; }
public MAudioListener2(string inname) : base(EType.AudioListener, inname) { _instance = this; transform = new MTransform(); device = Alc.OpenDevice(null); unsafe { context = Alc.CreateContext(device, (int *)null); } Alc.MakeContextCurrent(context); //Console.ReadKey(); }
// initialize internal static void Initialize() { // openal OpenAlDevice = Alc.OpenDevice(null); if (OpenAlDevice != IntPtr.Zero) { OpenAlContext = Alc.CreateContext(OpenAlDevice, (int[])null); if (OpenAlContext != ContextHandle.Zero) { Alc.MakeContextCurrent(OpenAlContext); AL.SpeedOfSound(343.0f); AL.DistanceModel(ALDistanceModel.None); } else { Alc.CloseDevice(OpenAlDevice); OpenAlDevice = IntPtr.Zero; System.Windows.Forms.MessageBox.Show("The sound device could be opened, but the sound context could not be created.", "openBVE", System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Hand); } } else { OpenAlContext = ContextHandle.Zero; System.Windows.Forms.MessageBox.Show("The sound device could not be opened.", "openBVE", System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Hand); } // outer radius switch (Interface.CurrentOptions.SoundRange) { case Interface.SoundRange.Low: OuterRadiusFactorMinimum = 2.0; OuterRadiusFactorMaximum = 8.0; break; case Interface.SoundRange.Medium: OuterRadiusFactorMinimum = 4.0; OuterRadiusFactorMaximum = 16.0; break; case Interface.SoundRange.High: OuterRadiusFactorMinimum = 8.0; OuterRadiusFactorMaximum = 32.0; break; } OuterRadiusFactor = OuterRadiusFactorMaximum; }
private void _audioCreateContext() { unsafe { _openALContext = Alc.CreateContext(_openALDevice, (int *)0); } Alc.MakeContextCurrent(_openALContext); _checkAlcError(_openALDevice); _checkAlError(); // Load up AL context extensions. foreach (var extension in AL.Get(ALGetString.Extensions).Split(' ')) { _alContextExtensions.Add(extension); } Logger.DebugS("oal", "OpenAL Vendor: {0}", AL.Get(ALGetString.Vendor)); Logger.DebugS("oal", "OpenAL Renderer: {0}", AL.Get(ALGetString.Renderer)); Logger.DebugS("oal", "OpenAL Version: {0}", AL.Get(ALGetString.Version)); }