Source/OpenTK/Audio/OpenAL/AL/XRamExtension.cs

#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.OpenAL
{

    [CLSCompliant(true)]
    public sealed class XRamExtension
    {
        #region Instance state

        private bool _valid = false;

        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)
            {
                Debug.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)
            {
                Debug.WriteLine("X-Ram: Attempt to marshal function pointers with AL.GetProcAddress failed. " + e.ToString());
                return;
            }

            _valid = true;
        }

        #endregion Constructor / Extension Loading

        #region Public Methods

        public int GetRamSize
        {
            get
            {
                return AL.Get((ALGetInteger)AL_EAX_RAM_SIZE);
            }
        }

        public int GetRamFree
        {
            get
            {
                return AL.Get((ALGetInteger)AL_EAX_RAM_FREE);
            }
        }

        public enum XRamStorage : byte
        {
            Automatic = 0,
            Hardware = 1,
            Accessible = 2,
        }

        [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);
            }
        }

        [CLSCompliant(true)]
        public bool SetBufferMode(int n, ref int buffer, XRamStorage mode)
        {
            uint temp = (uint)buffer;
            return SetBufferMode(n, ref temp, mode);
        }

        [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;
        }

        [CLSCompliant(true)]
        public XRamStorage GetBufferMode(ref int buffer)
        {
            uint temp = (uint)buffer;
            return GetBufferMode(ref temp);
        }

        #endregion Public Methods
    }

}

---