From f5c7a6ff5e31f9ffcbd7ed1163952938342958d2 Mon Sep 17 00:00:00 2001 From: the_fiddler Date: Sun, 6 Apr 2008 15:35:12 +0000 Subject: [PATCH] Renamed XRam to XRamExtension. --- .../OpenTK/Audio/OpenAL/AL/XRamExtension.cs | 185 ++++++++++++++++++ 1 file changed, 185 insertions(+) create mode 100644 Source/OpenTK/Audio/OpenAL/AL/XRamExtension.cs diff --git a/Source/OpenTK/Audio/OpenAL/AL/XRamExtension.cs b/Source/OpenTK/Audio/OpenAL/AL/XRamExtension.cs new file mode 100644 index 00000000..6d43f18c --- /dev/null +++ b/Source/OpenTK/Audio/OpenAL/AL/XRamExtension.cs @@ -0,0 +1,185 @@ +#region --- OpenTK.OpenAL License --- +/* XRamExtension.cs + * C header: \OpenAL 1.1 SDK\include\xram.h + * Spec: ? + * Copyright (c) 2008 Christoph Brandtner and Stefanos Apostolopoulos + * See license.txt for license details (MIT) + * http://www.OpenTK.net */ +#endregion + +using System; +using System.Diagnostics; +using System.Runtime.InteropServices; + +namespace OpenTK.Audio +{ + + ///The X-Ram Extension is provided on the top-end Sound Blaster X-Fi solutions (Sound Blaster X-Fi Fatal1ty, Sound Blaster X-Fi Elite Pro, or later). These products feature 64MB of X-Ram that can only be used for audio purposes, which can be controlled by this Extension. + [CLSCompliant( true )] + public sealed class XRamExtension + { + #region Instance state + + private bool _valid = false; + + /// Returns True if the X-Ram Extension has been found and could be initialized. + public bool IsInitialized + { + get { return _valid; } + } + + #endregion Instance state + + #region X-RAM Function pointer definitions + + // [CLSCompliant(false)] + private delegate bool Delegate_SetBufferMode( int n, ref uint buffers, int value ); + //typedef ALboolean (__cdecl *EAXSetBufferMode)(ALsizei n, ALuint *buffers, ALint value); + + // [CLSCompliant( false )] + private delegate int Delegate_GetBufferMode( uint buffer, IntPtr value ); + //typedef ALenum (__cdecl *EAXGetBufferMode)(ALuint buffer, ALint *value); + + //[CLSCompliant(false)] + private Delegate_SetBufferMode Imported_SetBufferMode; + //[CLSCompliant(false)] + private Delegate_GetBufferMode Imported_GetBufferMode; + + #endregion X-RAM Function pointer definitions + + #region X-RAM Tokens + + private int AL_EAX_RAM_SIZE, AL_EAX_RAM_FREE, + AL_STORAGE_AUTOMATIC, AL_STORAGE_HARDWARE, AL_STORAGE_ACCESSIBLE; + + #endregion X-RAM Tokens + + #region Constructor / Extension Loading + + public XRamExtension( ) + { // Query if Extension supported and retrieve Tokens/Pointers if it is. + _valid = false; + if ( AL.IsExtensionPresent( "EAX-RAM" ) == false ) + return; + + AL_EAX_RAM_SIZE = AL.GetEnumValue( "AL_EAX_RAM_SIZE" ); + AL_EAX_RAM_FREE = AL.GetEnumValue( "AL_EAX_RAM_FREE" ); + AL_STORAGE_AUTOMATIC = AL.GetEnumValue( "AL_STORAGE_AUTOMATIC" ); + AL_STORAGE_HARDWARE = AL.GetEnumValue( "AL_STORAGE_HARDWARE" ); + AL_STORAGE_ACCESSIBLE = AL.GetEnumValue( "AL_STORAGE_ACCESSIBLE" ); + + // Console.WriteLine("RamSize: {0} RamFree: {1} StorageAuto: {2} StorageHW: {3} StorageAccess: {4}",AL_EAX_RAM_SIZE,AL_EAX_RAM_FREE,AL_STORAGE_AUTOMATIC,AL_STORAGE_HARDWARE,AL_STORAGE_ACCESSIBLE); + + if ( AL_EAX_RAM_SIZE == 0 || + AL_EAX_RAM_FREE == 0 || + AL_STORAGE_AUTOMATIC == 0 || + AL_STORAGE_HARDWARE == 0 || + AL_STORAGE_ACCESSIBLE == 0 ) + { + Trace.WriteLine( "X-Ram: Token values could not be retrieved." ); + return; + } + + // Console.WriteLine("Free Ram: {0} / {1}",GetRamFree( ),GetRamSize( )); + + try + { + Imported_GetBufferMode = (Delegate_GetBufferMode) Marshal.GetDelegateForFunctionPointer( AL.GetProcAddress( "EAXGetBufferMode" ), typeof( Delegate_GetBufferMode ) ); + Imported_SetBufferMode = (Delegate_SetBufferMode) Marshal.GetDelegateForFunctionPointer( AL.GetProcAddress( "EAXSetBufferMode" ), typeof( Delegate_SetBufferMode ) ); + } catch ( Exception e ) + { + Trace.WriteLine( "X-Ram: Attempt to marshal function pointers with AL.GetProcAddress failed. " + e.ToString( ) ); + return; + } + + _valid = true; + } + + #endregion Constructor / Extension Loading + + #region Public Methods + + /// Query total amount of X-RAM in bytes. + public int GetRamSize( ) + { + return AL.Get( (ALGetInteger) AL_EAX_RAM_SIZE ); + } + + /// Query free X-RAM available in bytes. + public int GetRamFree( ) + { + return AL.Get( (ALGetInteger) AL_EAX_RAM_FREE ); + } + + /// This enum is used to abstract the need of using AL.GetEnumValue() with the Extension. The values do NOT correspond to AL_STORAGE_* tokens! + public enum XRamStorage : byte + { + /// Put an Open AL Buffer into X-RAM if memory is available, otherwise use host RAM. This is the default mode. + Automatic = 0, + /// Force an Open AL Buffer into X-RAM, good for non-streaming buffers. + Hardware = 1, + /// Force an Open AL Buffer into 'accessible' (currently host) RAM, good for streaming buffers. + Accessible = 2, + } + + /// This function is used to set the storage Mode of an array of OpenAL Buffers. + /// The number of OpenAL Buffers pointed to by buffer. + /// An array of OpenAL Buffer handles. + /// The storage mode that should be used for all the given buffers. Should be the value of one of the following enum names: XRamStorage.Automatic, XRamStorage.Hardware, XRamStorage.Accessible + /// True if all the Buffers were successfully set to the requested storage mode, False otherwise. + [CLSCompliant( false )] + public bool SetBufferMode( int n, ref uint buffer, XRamStorage mode ) + { + switch ( mode ) + { + case XRamStorage.Accessible: + return Imported_SetBufferMode( n, ref buffer, AL_STORAGE_ACCESSIBLE ); + case XRamStorage.Hardware: + return Imported_SetBufferMode( n, ref buffer, AL_STORAGE_HARDWARE ); + default: + return Imported_SetBufferMode( n, ref buffer, AL_STORAGE_AUTOMATIC ); + } + } + + /// This function is used to set the storage Mode of an array of OpenAL Buffers. + /// The number of OpenAL Buffers pointed to by buffer. + /// An array of OpenAL Buffer handles. + /// The storage mode that should be used for all the given buffers. Should be the value of one of the following enum names: XRamStorage.Automatic, XRamStorage.Hardware, XRamStorage.Accessible + /// True if all the Buffers were successfully set to the requested storage mode, False otherwise. + [CLSCompliant( true )] + public bool SetBufferMode( int n, ref int buffer, XRamStorage mode ) + { + uint temp = (uint) buffer; + return SetBufferMode( n, ref temp, mode ); + } + + /// This function is used to retrieve the storage Mode of a single OpenAL Buffer. + /// The handle of an OpenAL Buffer. + /// The current Mode of the Buffer. + [CLSCompliant( false )] + public XRamStorage GetBufferMode( ref uint buffer ) + { + int tempresult = Imported_GetBufferMode( buffer, IntPtr.Zero ); // IntPtr.Zero due to the parameter being unused/reserved atm + + if ( tempresult == AL_STORAGE_ACCESSIBLE ) + return XRamStorage.Accessible; + if ( tempresult == AL_STORAGE_HARDWARE ) + return XRamStorage.Hardware; + // default: + return XRamStorage.Automatic; + } + + /// This function is used to retrieve the storage Mode of a single OpenAL Buffer. + /// The handle of an OpenAL Buffer. + /// The current Mode of the Buffer. + [CLSCompliant( true )] + public XRamStorage GetBufferMode( ref int buffer ) + { + uint temp = (uint) buffer; + return GetBufferMode( ref temp ); + } + + #endregion Public Methods + } + +}