using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Text;
using System.Timers;
using BoneLib;
using BoneLib.BoneMenu;
using FMOD;
using FMOD.Studio;
using FieldInjector;
using Il2CppSLZ.Marrow;
using Il2CppSLZ.Marrow.Warehouse;
using LabFMOD;
using LabFMOD.FMODEngine;
using LabFMOD.Melon;
using LabFMOD.Menu;
using LabFMOD.SDK;
using MelonLoader;
using MelonLoader.Preferences;
using MelonLoader.Utils;
using Microsoft.CodeAnalysis;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("An implementation of FMOD Studio for BONELAB.")]
[assembly: AssemblyDescription("An implementation of FMOD Studio for BONELAB.")]
[assembly: AssemblyCompany("ArpaRec")]
[assembly: AssemblyProduct("LabFMOD")]
[assembly: AssemblyCopyright("Developed by TechSide")]
[assembly: AssemblyTrademark("ArpaRec")]
[assembly: AssemblyFileVersion("0.0.1")]
[assembly: MelonInfo(typeof(EntryPoint), "LabFMOD", "0.0.1", "ArpaRec", "NOT SET")]
[assembly: MelonColor(255, 255, 239, 0)]
[assembly: MelonGame("Stress Level Zero", "BONELAB")]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyVersion("0.0.1.0")]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace FMOD
{
	public class VERSION
	{
		public const int number = 131846;

		public const string dll = "fmod";
	}
	public class CONSTANTS
	{
		public const int MAX_CHANNEL_WIDTH = 32;

		public const int MAX_LISTENERS = 8;

		public const int REVERB_MAXINSTANCES = 4;

		public const int MAX_SYSTEMS = 8;
	}
	public enum RESULT
	{
		OK,
		ERR_BADCOMMAND,
		ERR_CHANNEL_ALLOC,
		ERR_CHANNEL_STOLEN,
		ERR_DMA,
		ERR_DSP_CONNECTION,
		ERR_DSP_DONTPROCESS,
		ERR_DSP_FORMAT,
		ERR_DSP_INUSE,
		ERR_DSP_NOTFOUND,
		ERR_DSP_RESERVED,
		ERR_DSP_SILENCE,
		ERR_DSP_TYPE,
		ERR_FILE_BAD,
		ERR_FILE_COULDNOTSEEK,
		ERR_FILE_DISKEJECTED,
		ERR_FILE_EOF,
		ERR_FILE_ENDOFDATA,
		ERR_FILE_NOTFOUND,
		ERR_FORMAT,
		ERR_HEADER_MISMATCH,
		ERR_HTTP,
		ERR_HTTP_ACCESS,
		ERR_HTTP_PROXY_AUTH,
		ERR_HTTP_SERVER_ERROR,
		ERR_HTTP_TIMEOUT,
		ERR_INITIALIZATION,
		ERR_INITIALIZED,
		ERR_INTERNAL,
		ERR_INVALID_FLOAT,
		ERR_INVALID_HANDLE,
		ERR_INVALID_PARAM,
		ERR_INVALID_POSITION,
		ERR_INVALID_SPEAKER,
		ERR_INVALID_SYNCPOINT,
		ERR_INVALID_THREAD,
		ERR_INVALID_VECTOR,
		ERR_MAXAUDIBLE,
		ERR_MEMORY,
		ERR_MEMORY_CANTPOINT,
		ERR_NEEDS3D,
		ERR_NEEDSHARDWARE,
		ERR_NET_CONNECT,
		ERR_NET_SOCKET_ERROR,
		ERR_NET_URL,
		ERR_NET_WOULD_BLOCK,
		ERR_NOTREADY,
		ERR_OUTPUT_ALLOCATED,
		ERR_OUTPUT_CREATEBUFFER,
		ERR_OUTPUT_DRIVERCALL,
		ERR_OUTPUT_FORMAT,
		ERR_OUTPUT_INIT,
		ERR_OUTPUT_NODRIVERS,
		ERR_PLUGIN,
		ERR_PLUGIN_MISSING,
		ERR_PLUGIN_RESOURCE,
		ERR_PLUGIN_VERSION,
		ERR_RECORD,
		ERR_REVERB_CHANNELGROUP,
		ERR_REVERB_INSTANCE,
		ERR_SUBSOUNDS,
		ERR_SUBSOUND_ALLOCATED,
		ERR_SUBSOUND_CANTMOVE,
		ERR_TAGNOTFOUND,
		ERR_TOOMANYCHANNELS,
		ERR_TRUNCATED,
		ERR_UNIMPLEMENTED,
		ERR_UNINITIALIZED,
		ERR_UNSUPPORTED,
		ERR_VERSION,
		ERR_EVENT_ALREADY_LOADED,
		ERR_EVENT_LIVEUPDATE_BUSY,
		ERR_EVENT_LIVEUPDATE_MISMATCH,
		ERR_EVENT_LIVEUPDATE_TIMEOUT,
		ERR_EVENT_NOTFOUND,
		ERR_STUDIO_UNINITIALIZED,
		ERR_STUDIO_NOT_LOADED,
		ERR_INVALID_STRING,
		ERR_ALREADY_LOCKED,
		ERR_NOT_LOCKED,
		ERR_RECORD_DISCONNECTED,
		ERR_TOOMANYSAMPLES
	}
	public enum CHANNELCONTROL_TYPE
	{
		CHANNEL,
		CHANNELGROUP,
		MAX
	}
	public struct VECTOR
	{
		public float x;

		public float y;

		public float z;
	}
	public struct ATTRIBUTES_3D
	{
		public VECTOR position;

		public VECTOR velocity;

		public VECTOR forward;

		public VECTOR up;
	}
	public struct GUID
	{
		public int Data1;

		public int Data2;

		public int Data3;

		public int Data4;
	}
	public struct ASYNCREADINFO
	{
		public IntPtr handle;

		public uint offset;

		public uint sizebytes;

		public int priority;

		public IntPtr userdata;

		public IntPtr buffer;

		public uint bytesread;

		public FILE_ASYNCDONE_FUNC done;
	}
	public enum OUTPUTTYPE
	{
		AUTODETECT,
		UNKNOWN,
		NOSOUND,
		WAVWRITER,
		NOSOUND_NRT,
		WAVWRITER_NRT,
		WASAPI,
		ASIO,
		PULSEAUDIO,
		ALSA,
		COREAUDIO,
		AUDIOTRACK,
		OPENSL,
		AUDIOOUT,
		AUDIO3D,
		WEBAUDIO,
		NNAUDIO,
		WINSONIC,
		AAUDIO,
		AUDIOWORKLET,
		PHASE,
		OHAUDIO,
		MAX
	}
	public enum PORT_TYPE
	{
		MUSIC,
		COPYRIGHT_MUSIC,
		VOICE,
		CONTROLLER,
		PERSONAL,
		VIBRATION,
		AUX,
		PASSTHROUGH,
		VR_VIBRATION,
		MAX
	}
	public enum DEBUG_MODE
	{
		TTY,
		FILE,
		CALLBACK
	}
	[Flags]
	public enum DEBUG_FLAGS : uint
	{
		NONE = 0u,
		ERROR = 1u,
		WARNING = 2u,
		LOG = 4u,
		TYPE_MEMORY = 0x100u,
		TYPE_FILE = 0x200u,
		TYPE_CODEC = 0x400u,
		TYPE_TRACE = 0x800u,
		DISPLAY_TIMESTAMPS = 0x10000u,
		DISPLAY_LINENUMBERS = 0x20000u,
		DISPLAY_THREAD = 0x40000u
	}
	[Flags]
	public enum MEMORY_TYPE : uint
	{
		NORMAL = 0u,
		STREAM_FILE = 1u,
		STREAM_DECODE = 2u,
		SAMPLEDATA = 4u,
		DSP_BUFFER = 8u,
		PLUGIN = 0x10u,
		PERSISTENT = 0x200000u,
		ALL = uint.MaxValue
	}
	public enum SPEAKERMODE
	{
		DEFAULT,
		RAW,
		MONO,
		STEREO,
		QUAD,
		SURROUND,
		_5POINT1,
		_7POINT1,
		_7POINT1POINT4,
		MAX
	}
	public enum SPEAKER
	{
		NONE = -1,
		FRONT_LEFT,
		FRONT_RIGHT,
		FRONT_CENTER,
		LOW_FREQUENCY,
		SURROUND_LEFT,
		SURROUND_RIGHT,
		BACK_LEFT,
		BACK_RIGHT,
		TOP_FRONT_LEFT,
		TOP_FRONT_RIGHT,
		TOP_BACK_LEFT,
		TOP_BACK_RIGHT,
		MAX
	}
	[Flags]
	public enum CHANNELMASK : uint
	{
		FRONT_LEFT = 1u,
		FRONT_RIGHT = 2u,
		FRONT_CENTER = 4u,
		LOW_FREQUENCY = 8u,
		SURROUND_LEFT = 0x10u,
		SURROUND_RIGHT = 0x20u,
		BACK_LEFT = 0x40u,
		BACK_RIGHT = 0x80u,
		BACK_CENTER = 0x100u,
		MONO = 1u,
		STEREO = 3u,
		LRC = 7u,
		QUAD = 0x33u,
		SURROUND = 0x37u,
		_5POINT1 = 0x3Fu,
		_5POINT1_REARS = 0xCFu,
		_7POINT0 = 0xF7u,
		_7POINT1 = 0xFFu
	}
	public enum CHANNELORDER
	{
		DEFAULT,
		WAVEFORMAT,
		PROTOOLS,
		ALLMONO,
		ALLSTEREO,
		ALSA,
		MAX
	}
	public enum PLUGINTYPE
	{
		OUTPUT,
		CODEC,
		DSP,
		MAX
	}
	public struct PLUGINLIST
	{
		private PLUGINTYPE type;

		private IntPtr description;
	}
	[Flags]
	public enum INITFLAGS : uint
	{
		NORMAL = 0u,
		STREAM_FROM_UPDATE = 1u,
		MIX_FROM_UPDATE = 2u,
		_3D_RIGHTHANDED = 4u,
		CLIP_OUTPUT = 8u,
		CHANNEL_LOWPASS = 0x100u,
		CHANNEL_DISTANCEFILTER = 0x200u,
		PROFILE_ENABLE = 0x10000u,
		VOL0_BECOMES_VIRTUAL = 0x20000u,
		GEOMETRY_USECLOSEST = 0x40000u,
		PREFER_DOLBY_DOWNMIX = 0x80000u,
		THREAD_UNSAFE = 0x100000u,
		PROFILE_METER_ALL = 0x200000u,
		MEMORY_TRACKING = 0x400000u
	}
	public enum SOUND_TYPE
	{
		UNKNOWN,
		AIFF,
		ASF,
		DLS,
		FLAC,
		FSB,
		IT,
		MIDI,
		MOD,
		MPEG,
		OGGVORBIS,
		PLAYLIST,
		RAW,
		S3M,
		USER,
		WAV,
		XM,
		XMA,
		AUDIOQUEUE,
		AT9,
		VORBIS,
		MEDIA_FOUNDATION,
		MEDIACODEC,
		FADPCM,
		OPUS,
		MAX
	}
	public enum SOUND_FORMAT
	{
		NONE,
		PCM8,
		PCM16,
		PCM24,
		PCM32,
		PCMFLOAT,
		BITSTREAM,
		MAX
	}
	[Flags]
	public enum MODE : uint
	{
		DEFAULT = 0u,
		LOOP_OFF = 1u,
		LOOP_NORMAL = 2u,
		LOOP_BIDI = 4u,
		_2D = 8u,
		_3D = 0x10u,
		CREATESTREAM = 0x80u,
		CREATESAMPLE = 0x100u,
		CREATECOMPRESSEDSAMPLE = 0x200u,
		OPENUSER = 0x400u,
		OPENMEMORY = 0x800u,
		OPENMEMORY_POINT = 0x10000000u,
		OPENRAW = 0x1000u,
		OPENONLY = 0x2000u,
		ACCURATETIME = 0x4000u,
		MPEGSEARCH = 0x8000u,
		NONBLOCKING = 0x10000u,
		UNIQUE = 0x20000u,
		_3D_HEADRELATIVE = 0x40000u,
		_3D_WORLDRELATIVE = 0x80000u,
		_3D_INVERSEROLLOFF = 0x100000u,
		_3D_LINEARROLLOFF = 0x200000u,
		_3D_LINEARSQUAREROLLOFF = 0x400000u,
		_3D_INVERSETAPEREDROLLOFF = 0x800000u,
		_3D_CUSTOMROLLOFF = 0x4000000u,
		_3D_IGNOREGEOMETRY = 0x40000000u,
		IGNORETAGS = 0x2000000u,
		LOWMEM = 0x8000000u,
		VIRTUAL_PLAYFROMSTART = 0x80000000u
	}
	public enum OPENSTATE
	{
		READY,
		LOADING,
		ERROR,
		CONNECTING,
		BUFFERING,
		SEEKING,
		PLAYING,
		SETPOSITION,
		MAX
	}
	public enum SOUNDGROUP_BEHAVIOR
	{
		BEHAVIOR_FAIL,
		BEHAVIOR_MUTE,
		BEHAVIOR_STEALLOWEST,
		MAX
	}
	public enum CHANNELCONTROL_CALLBACK_TYPE
	{
		END,
		VIRTUALVOICE,
		SYNCPOINT,
		OCCLUSION,
		MAX
	}
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	public struct CHANNELCONTROL_DSP_INDEX
	{
		public const int HEAD = -1;

		public const int FADER = -2;

		public const int TAIL = -3;
	}
	public enum ERRORCALLBACK_INSTANCETYPE
	{
		NONE,
		SYSTEM,
		CHANNEL,
		CHANNELGROUP,
		CHANNELCONTROL,
		SOUND,
		SOUNDGROUP,
		DSP,
		DSPCONNECTION,
		GEOMETRY,
		REVERB3D,
		STUDIO_SYSTEM,
		STUDIO_EVENTDESCRIPTION,
		STUDIO_EVENTINSTANCE,
		STUDIO_PARAMETERINSTANCE,
		STUDIO_BUS,
		STUDIO_VCA,
		STUDIO_BANK,
		STUDIO_COMMANDREPLAY
	}
	public struct ERRORCALLBACK_INFO
	{
		public RESULT result;

		public ERRORCALLBACK_INSTANCETYPE instancetype;

		public IntPtr instance;

		public StringWrapper functionname;

		public StringWrapper functionparams;
	}
	public struct CPU_USAGE
	{
		public float dsp;

		public float stream;

		public float geometry;

		public float update;

		public float convolution1;

		public float convolution2;
	}
	public struct DSP_DATA_PARAMETER_INFO
	{
		public IntPtr data;

		public uint length;

		public int index;
	}
	[Flags]
	public enum SYSTEM_CALLBACK_TYPE : uint
	{
		DEVICELISTCHANGED = 1u,
		DEVICELOST = 2u,
		MEMORYALLOCATIONFAILED = 4u,
		THREADCREATED = 8u,
		BADDSPCONNECTION = 0x10u,
		PREMIX = 0x20u,
		POSTMIX = 0x40u,
		ERROR = 0x80u,
		THREADDESTROYED = 0x100u,
		PREUPDATE = 0x200u,
		POSTUPDATE = 0x400u,
		RECORDLISTCHANGED = 0x800u,
		BUFFEREDNOMIX = 0x1000u,
		DEVICEREINITIALIZE = 0x2000u,
		OUTPUTUNDERRUN = 0x4000u,
		RECORDPOSITIONCHANGED = 0x8000u,
		ALL = uint.MaxValue
	}
	public delegate RESULT DEBUG_CALLBACK(DEBUG_FLAGS flags, IntPtr file, int line, IntPtr func, IntPtr message);
	public delegate RESULT SYSTEM_CALLBACK(IntPtr system, SYSTEM_CALLBACK_TYPE type, IntPtr commanddata1, IntPtr commanddata2, IntPtr userdata);
	public delegate RESULT CHANNELCONTROL_CALLBACK(IntPtr channelcontrol, CHANNELCONTROL_TYPE controltype, CHANNELCONTROL_CALLBACK_TYPE callbacktype, IntPtr commanddata1, IntPtr commanddata2);
	public delegate RESULT DSP_CALLBACK(IntPtr dsp, DSP_CALLBACK_TYPE type, IntPtr data);
	public delegate RESULT SOUND_NONBLOCK_CALLBACK(IntPtr sound, RESULT result);
	public delegate RESULT SOUND_PCMREAD_CALLBACK(IntPtr sound, IntPtr data, uint datalen);
	public delegate RESULT SOUND_PCMSETPOS_CALLBACK(IntPtr sound, int subsound, uint position, TIMEUNIT postype);
	public delegate RESULT FILE_OPEN_CALLBACK(IntPtr name, ref uint filesize, ref IntPtr handle, IntPtr userdata);
	public delegate RESULT FILE_CLOSE_CALLBACK(IntPtr handle, IntPtr userdata);
	public delegate RESULT FILE_READ_CALLBACK(IntPtr handle, IntPtr buffer, uint sizebytes, ref uint bytesread, IntPtr userdata);
	public delegate RESULT FILE_SEEK_CALLBACK(IntPtr handle, uint pos, IntPtr userdata);
	public delegate RESULT FILE_ASYNCREAD_CALLBACK(IntPtr info, IntPtr userdata);
	public delegate RESULT FILE_ASYNCCANCEL_CALLBACK(IntPtr info, IntPtr userdata);
	public delegate void FILE_ASYNCDONE_FUNC(IntPtr info, RESULT result);
	public delegate IntPtr MEMORY_ALLOC_CALLBACK(uint size, MEMORY_TYPE type, IntPtr sourcestr);
	public delegate IntPtr MEMORY_REALLOC_CALLBACK(IntPtr ptr, uint size, MEMORY_TYPE type, IntPtr sourcestr);
	public delegate void MEMORY_FREE_CALLBACK(IntPtr ptr, MEMORY_TYPE type, IntPtr sourcestr);
	public delegate float CB_3D_ROLLOFF_CALLBACK(IntPtr channelcontrol, float distance);
	public enum DSP_RESAMPLER
	{
		DEFAULT,
		NOINTERP,
		LINEAR,
		CUBIC,
		SPLINE,
		MAX
	}
	public enum DSP_CALLBACK_TYPE
	{
		DATAPARAMETERRELEASE,
		MAX
	}
	public enum DSPCONNECTION_TYPE
	{
		STANDARD,
		SIDECHAIN,
		SEND,
		SEND_SIDECHAIN,
		MAX
	}
	public enum TAGTYPE
	{
		UNKNOWN,
		ID3V1,
		ID3V2,
		VORBISCOMMENT,
		SHOUTCAST,
		ICECAST,
		ASF,
		MIDI,
		PLAYLIST,
		FMOD,
		USER,
		MAX
	}
	public enum TAGDATATYPE
	{
		BINARY,
		INT,
		FLOAT,
		STRING,
		STRING_UTF16,
		STRING_UTF16BE,
		STRING_UTF8,
		MAX
	}
	public struct TAG
	{
		public TAGTYPE type;

		public TAGDATATYPE datatype;

		public StringWrapper name;

		public IntPtr data;

		public uint datalen;

		public bool updated;
	}
	[Flags]
	public enum TIMEUNIT : uint
	{
		MS = 1u,
		PCM = 2u,
		PCMBYTES = 4u,
		RAWBYTES = 8u,
		PCMFRACTION = 0x10u,
		MODORDER = 0x100u,
		MODROW = 0x200u,
		MODPATTERN = 0x400u
	}
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	public struct PORT_INDEX
	{
		public const ulong NONE = ulong.MaxValue;
	}
	public struct CREATESOUNDEXINFO
	{
		public int cbsize;

		public uint length;

		public uint fileoffset;

		public int numchannels;

		public int defaultfrequency;

		public SOUND_FORMAT format;

		public uint decodebuffersize;

		public int initialsubsound;

		public int numsubsounds;

		public IntPtr inclusionlist;

		public int inclusionlistnum;

		public IntPtr pcmreadcallback_internal;

		public IntPtr pcmsetposcallback_internal;

		public IntPtr nonblockcallback_internal;

		public IntPtr dlsname;

		public IntPtr encryptionkey;

		public int maxpolyphony;

		public IntPtr userdata;

		public SOUND_TYPE suggestedsoundtype;

		public IntPtr fileuseropen_internal;

		public IntPtr fileuserclose_internal;

		public IntPtr fileuserread_internal;

		public IntPtr fileuserseek_internal;

		public IntPtr fileuserasyncread_internal;

		public IntPtr fileuserasynccancel_internal;

		public IntPtr fileuserdata;

		public int filebuffersize;

		public CHANNELORDER channelorder;

		public IntPtr initialsoundgroup;

		public uint initialseekposition;

		public TIMEUNIT initialseekpostype;

		public int ignoresetfilesystem;

		public uint audioqueuepolicy;

		public uint minmidigranularity;

		public int nonblockthreadid;

		public IntPtr fsbguid;

		public SOUND_PCMREAD_CALLBACK pcmreadcallback
		{
			get
			{
				return (pcmreadcallback_internal == IntPtr.Zero) ? null : Marshal.GetDelegateForFunctionPointer<SOUND_PCMREAD_CALLBACK>(pcmreadcallback_internal);
			}
			set
			{
				pcmreadcallback_internal = ((value == null) ? IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(value));
			}
		}

		public SOUND_PCMSETPOS_CALLBACK pcmsetposcallback
		{
			get
			{
				return (pcmsetposcallback_internal == IntPtr.Zero) ? null : Marshal.GetDelegateForFunctionPointer<SOUND_PCMSETPOS_CALLBACK>(pcmsetposcallback_internal);
			}
			set
			{
				pcmsetposcallback_internal = ((value == null) ? IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(value));
			}
		}

		public SOUND_NONBLOCK_CALLBACK nonblockcallback
		{
			get
			{
				return (nonblockcallback_internal == IntPtr.Zero) ? null : Marshal.GetDelegateForFunctionPointer<SOUND_NONBLOCK_CALLBACK>(nonblockcallback_internal);
			}
			set
			{
				nonblockcallback_internal = ((value == null) ? IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(value));
			}
		}

		public FILE_OPEN_CALLBACK fileuseropen
		{
			get
			{
				return (fileuseropen_internal == IntPtr.Zero) ? null : Marshal.GetDelegateForFunctionPointer<FILE_OPEN_CALLBACK>(fileuseropen_internal);
			}
			set
			{
				fileuseropen_internal = ((value == null) ? IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(value));
			}
		}

		public FILE_CLOSE_CALLBACK fileuserclose
		{
			get
			{
				return (fileuserclose_internal == IntPtr.Zero) ? null : Marshal.GetDelegateForFunctionPointer<FILE_CLOSE_CALLBACK>(fileuserclose_internal);
			}
			set
			{
				fileuserclose_internal = ((value == null) ? IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(value));
			}
		}

		public FILE_READ_CALLBACK fileuserread
		{
			get
			{
				return (fileuserread_internal == IntPtr.Zero) ? null : Marshal.GetDelegateForFunctionPointer<FILE_READ_CALLBACK>(fileuserread_internal);
			}
			set
			{
				fileuserread_internal = ((value == null) ? IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(value));
			}
		}

		public FILE_SEEK_CALLBACK fileuserseek
		{
			get
			{
				return (fileuserseek_internal == IntPtr.Zero) ? null : Marshal.GetDelegateForFunctionPointer<FILE_SEEK_CALLBACK>(fileuserseek_internal);
			}
			set
			{
				fileuserseek_internal = ((value == null) ? IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(value));
			}
		}

		public FILE_ASYNCREAD_CALLBACK fileuserasyncread
		{
			get
			{
				return (fileuserasyncread_internal == IntPtr.Zero) ? null : Marshal.GetDelegateForFunctionPointer<FILE_ASYNCREAD_CALLBACK>(fileuserasyncread_internal);
			}
			set
			{
				fileuserasyncread_internal = ((value == null) ? IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(value));
			}
		}

		public FILE_ASYNCCANCEL_CALLBACK fileuserasynccancel
		{
			get
			{
				return (fileuserasynccancel_internal == IntPtr.Zero) ? null : Marshal.GetDelegateForFunctionPointer<FILE_ASYNCCANCEL_CALLBACK>(fileuserasynccancel_internal);
			}
			set
			{
				fileuserasynccancel_internal = ((value == null) ? IntPtr.Zero : Marshal.GetFunctionPointerForDelegate(value));
			}
		}
	}
	public struct REVERB_PROPERTIES
	{
		public float DecayTime;

		public float EarlyDelay;

		public float LateDelay;

		public float HFReference;

		public float HFDecayRatio;

		public float Diffusion;

		public float Density;

		public float LowShelfFrequency;

		public float LowShelfGain;

		public float HighCut;

		public float EarlyLateMix;

		public float WetLevel;

		public REVERB_PROPERTIES(float decayTime, float earlyDelay, float lateDelay, float hfReference, float hfDecayRatio, float diffusion, float density, float lowShelfFrequency, float lowShelfGain, float highCut, float earlyLateMix, float wetLevel)
		{
			DecayTime = decayTime;
			EarlyDelay = earlyDelay;
			LateDelay = lateDelay;
			HFReference = hfReference;
			HFDecayRatio = hfDecayRatio;
			Diffusion = diffusion;
			Density = density;
			LowShelfFrequency = lowShelfFrequency;
			LowShelfGain = lowShelfGain;
			HighCut = highCut;
			EarlyLateMix = earlyLateMix;
			WetLevel = wetLevel;
		}
	}
	public class PRESET
	{
		public static REVERB_PROPERTIES OFF()
		{
			return new REVERB_PROPERTIES(1000f, 7f, 11f, 5000f, 100f, 100f, 100f, 250f, 0f, 20f, 96f, -80f);
		}

		public static REVERB_PROPERTIES GENERIC()
		{
			return new REVERB_PROPERTIES(1500f, 7f, 11f, 5000f, 83f, 100f, 100f, 250f, 0f, 14500f, 96f, -8f);
		}

		public static REVERB_PROPERTIES PADDEDCELL()
		{
			return new REVERB_PROPERTIES(170f, 1f, 2f, 5000f, 10f, 100f, 100f, 250f, 0f, 160f, 84f, -7.8f);
		}

		public static REVERB_PROPERTIES ROOM()
		{
			return new REVERB_PROPERTIES(400f, 2f, 3f, 5000f, 83f, 100f, 100f, 250f, 0f, 6050f, 88f, -9.4f);
		}

		public static REVERB_PROPERTIES BATHROOM()
		{
			return new REVERB_PROPERTIES(1500f, 7f, 11f, 5000f, 54f, 100f, 60f, 250f, 0f, 2900f, 83f, 0.5f);
		}

		public static REVERB_PROPERTIES LIVINGROOM()
		{
			return new REVERB_PROPERTIES(500f, 3f, 4f, 5000f, 10f, 100f, 100f, 250f, 0f, 160f, 58f, -19f);
		}

		public static REVERB_PROPERTIES STONEROOM()
		{
			return new REVERB_PROPERTIES(2300f, 12f, 17f, 5000f, 64f, 100f, 100f, 250f, 0f, 7800f, 71f, -8.5f);
		}

		public static REVERB_PROPERTIES AUDITORIUM()
		{
			return new REVERB_PROPERTIES(4300f, 20f, 30f, 5000f, 59f, 100f, 100f, 250f, 0f, 5850f, 64f, -11.7f);
		}

		public static REVERB_PROPERTIES CONCERTHALL()
		{
			return new REVERB_PROPERTIES(3900f, 20f, 29f, 5000f, 70f, 100f, 100f, 250f, 0f, 5650f, 80f, -9.8f);
		}

		public static REVERB_PROPERTIES CAVE()
		{
			return new REVERB_PROPERTIES(2900f, 15f, 22f, 5000f, 100f, 100f, 100f, 250f, 0f, 20000f, 59f, -11.3f);
		}

		public static REVERB_PROPERTIES ARENA()
		{
			return new REVERB_PROPERTIES(7200f, 20f, 30f, 5000f, 33f, 100f, 100f, 250f, 0f, 4500f, 80f, -9.6f);
		}

		public static REVERB_PROPERTIES HANGAR()
		{
			return new REVERB_PROPERTIES(10000f, 20f, 30f, 5000f, 23f, 100f, 100f, 250f, 0f, 3400f, 72f, -7.4f);
		}

		public static REVERB_PROPERTIES CARPETTEDHALLWAY()
		{
			return new REVERB_PROPERTIES(300f, 2f, 30f, 5000f, 10f, 100f, 100f, 250f, 0f, 500f, 56f, -24f);
		}

		public static REVERB_PROPERTIES HALLWAY()
		{
			return new REVERB_PROPERTIES(1500f, 7f, 11f, 5000f, 59f, 100f, 100f, 250f, 0f, 7800f, 87f, -5.5f);
		}

		public static REVERB_PROPERTIES STONECORRIDOR()
		{
			return new REVERB_PROPERTIES(270f, 13f, 20f, 5000f, 79f, 100f, 100f, 250f, 0f, 9000f, 86f, -6f);
		}

		public static REVERB_PROPERTIES ALLEY()
		{
			return new REVERB_PROPERTIES(1500f, 7f, 11f, 5000f, 86f, 100f, 100f, 250f, 0f, 8300f, 80f, -9.8f);
		}

		public static REVERB_PROPERTIES FOREST()
		{
			return new REVERB_PROPERTIES(1500f, 162f, 88f, 5000f, 54f, 79f, 100f, 250f, 0f, 760f, 94f, -12.3f);
		}

		public static REVERB_PROPERTIES CITY()
		{
			return new REVERB_PROPERTIES(1500f, 7f, 11f, 5000f, 67f, 50f, 100f, 250f, 0f, 4050f, 66f, -26f);
		}

		public static REVERB_PROPERTIES MOUNTAINS()
		{
			return new REVERB_PROPERTIES(1500f, 300f, 100f, 5000f, 21f, 27f, 100f, 250f, 0f, 1220f, 82f, -24f);
		}

		public static REVERB_PROPERTIES QUARRY()
		{
			return new REVERB_PROPERTIES(1500f, 61f, 25f, 5000f, 83f, 100f, 100f, 250f, 0f, 3400f, 100f, -5f);
		}

		public static REVERB_PROPERTIES PLAIN()
		{
			return new REVERB_PROPERTIES(1500f, 179f, 100f, 5000f, 50f, 21f, 100f, 250f, 0f, 1670f, 65f, -28f);
		}

		public static REVERB_PROPERTIES PARKINGLOT()
		{
			return new REVERB_PROPERTIES(1700f, 8f, 12f, 5000f, 100f, 100f, 100f, 250f, 0f, 20000f, 56f, -19.5f);
		}

		public static REVERB_PROPERTIES SEWERPIPE()
		{
			return new REVERB_PROPERTIES(2800f, 14f, 21f, 5000f, 14f, 80f, 60f, 250f, 0f, 3400f, 66f, 1.2f);
		}

		public static REVERB_PROPERTIES UNDERWATER()
		{
			return new REVERB_PROPERTIES(1500f, 7f, 11f, 5000f, 10f, 100f, 100f, 250f, 0f, 500f, 92f, 7f);
		}
	}
	public struct ADVANCEDSETTINGS
	{
		public int cbSize;

		public int maxMPEGCodecs;

		public int maxADPCMCodecs;

		public int maxXMACodecs;

		public int maxVorbisCodecs;

		public int maxAT9Codecs;

		public int maxFADPCMCodecs;

		public int maxOpusCodecs;

		public int ASIONumChannels;

		public IntPtr ASIOChannelList;

		public IntPtr ASIOSpeakerList;

		public float vol0virtualvol;

		public uint defaultDecodeBufferSize;

		public ushort profilePort;

		public uint geometryMaxFadeTime;

		public float distanceFilterCenterFreq;

		public int reverb3Dinstance;

		public int DSPBufferPoolSize;

		public DSP_RESAMPLER resamplerMethod;

		public uint randomSeed;

		public int maxConvolutionThreads;

		public int maxSpatialObjects;
	}
	[Flags]
	public enum DRIVER_STATE : uint
	{
		CONNECTED = 1u,
		DEFAULT = 2u
	}
	public enum THREAD_PRIORITY
	{
		PLATFORM_MIN = -32768,
		PLATFORM_MAX = 32768,
		DEFAULT = -32769,
		LOW = -32770,
		MEDIUM = -32771,
		HIGH = -32772,
		VERY_HIGH = -32773,
		EXTREME = -32774,
		CRITICAL = -32775,
		MIXER = -32774,
		FEEDER = -32775,
		STREAM = -32773,
		FILE = -32772,
		NONBLOCKING = -32772,
		RECORD = -32772,
		GEOMETRY = -32770,
		PROFILER = -32771,
		STUDIO_UPDATE = -32771,
		STUDIO_LOAD_BANK = -32771,
		STUDIO_LOAD_SAMPLE = -32771,
		CONVOLUTION1 = -32773,
		CONVOLUTION2 = -32773
	}
	public enum THREAD_STACK_SIZE : uint
	{
		DEFAULT = 0u,
		MIXER = 81920u,
		FEEDER = 16384u,
		STREAM = 98304u,
		FILE = 65536u,
		NONBLOCKING = 114688u,
		RECORD = 16384u,
		GEOMETRY = 49152u,
		PROFILER = 131072u,
		STUDIO_UPDATE = 98304u,
		STUDIO_LOAD_BANK = 98304u,
		STUDIO_LOAD_SAMPLE = 98304u,
		CONVOLUTION1 = 16384u,
		CONVOLUTION2 = 16384u
	}
	[Flags]
	public enum THREAD_AFFINITY : long
	{
		GROUP_DEFAULT = 0x4000000000000000L,
		GROUP_A = 0x4000000000000001L,
		GROUP_B = 0x4000000000000002L,
		GROUP_C = 0x4000000000000003L,
		MIXER = 0x4000000000000001L,
		FEEDER = 0x4000000000000003L,
		STREAM = 0x4000000000000003L,
		FILE = 0x4000000000000003L,
		NONBLOCKING = 0x4000000000000003L,
		RECORD = 0x4000000000000003L,
		GEOMETRY = 0x4000000000000003L,
		PROFILER = 0x4000000000000003L,
		STUDIO_UPDATE = 0x4000000000000002L,
		STUDIO_LOAD_BANK = 0x4000000000000003L,
		STUDIO_LOAD_SAMPLE = 0x4000000000000003L,
		CONVOLUTION1 = 0x4000000000000003L,
		CONVOLUTION2 = 0x4000000000000003L,
		CORE_ALL = 0L,
		CORE_0 = 1L,
		CORE_1 = 2L,
		CORE_2 = 4L,
		CORE_3 = 8L,
		CORE_4 = 0x10L,
		CORE_5 = 0x20L,
		CORE_6 = 0x40L,
		CORE_7 = 0x80L,
		CORE_8 = 0x100L,
		CORE_9 = 0x200L,
		CORE_10 = 0x400L,
		CORE_11 = 0x800L,
		CORE_12 = 0x1000L,
		CORE_13 = 0x2000L,
		CORE_14 = 0x4000L,
		CORE_15 = 0x8000L
	}
	public enum THREAD_TYPE
	{
		MIXER,
		FEEDER,
		STREAM,
		FILE,
		NONBLOCKING,
		RECORD,
		GEOMETRY,
		PROFILER,
		STUDIO_UPDATE,
		STUDIO_LOAD_BANK,
		STUDIO_LOAD_SAMPLE,
		CONVOLUTION1,
		CONVOLUTION2,
		MAX
	}
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	public struct Factory
	{
		public static RESULT System_Create(out System system)
		{
			return FMOD5_System_Create(out system.handle, 131846u);
		}

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_Create(out IntPtr system, uint headerversion);
	}
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	public struct Memory
	{
		public static RESULT Initialize(IntPtr poolmem, int poollen, MEMORY_ALLOC_CALLBACK useralloc, MEMORY_REALLOC_CALLBACK userrealloc, MEMORY_FREE_CALLBACK userfree, MEMORY_TYPE memtypeflags = MEMORY_TYPE.ALL)
		{
			return FMOD5_Memory_Initialize(poolmem, poollen, useralloc, userrealloc, userfree, memtypeflags);
		}

		public static RESULT GetStats(out int currentalloced, out int maxalloced, bool blocking = true)
		{
			return FMOD5_Memory_GetStats(out currentalloced, out maxalloced, blocking);
		}

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Memory_Initialize(IntPtr poolmem, int poollen, MEMORY_ALLOC_CALLBACK useralloc, MEMORY_REALLOC_CALLBACK userrealloc, MEMORY_FREE_CALLBACK userfree, MEMORY_TYPE memtypeflags);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Memory_GetStats(out int currentalloced, out int maxalloced, bool blocking);
	}
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	public struct Debug
	{
		public static RESULT Initialize(DEBUG_FLAGS flags, DEBUG_MODE mode = DEBUG_MODE.TTY, DEBUG_CALLBACK callback = null, string filename = null)
		{
			using StringHelper.ThreadSafeEncoding threadSafeEncoding = StringHelper.GetFreeHelper();
			return FMOD5_Debug_Initialize(flags, mode, callback, threadSafeEncoding.byteFromStringUTF8(filename));
		}

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Debug_Initialize(DEBUG_FLAGS flags, DEBUG_MODE mode, DEBUG_CALLBACK callback, byte[] filename);
	}
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	public struct Thread
	{
		public static RESULT SetAttributes(THREAD_TYPE type, THREAD_AFFINITY affinity = THREAD_AFFINITY.GROUP_DEFAULT, THREAD_PRIORITY priority = THREAD_PRIORITY.DEFAULT, THREAD_STACK_SIZE stacksize = THREAD_STACK_SIZE.DEFAULT)
		{
			return FMOD5_Thread_SetAttributes(type, affinity, priority, stacksize);
		}

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Thread_SetAttributes(THREAD_TYPE type, THREAD_AFFINITY affinity, THREAD_PRIORITY priority, THREAD_STACK_SIZE stacksize);
	}
	public struct System
	{
		public IntPtr handle;

		public RESULT release()
		{
			return FMOD5_System_Release(handle);
		}

		public RESULT setOutput(OUTPUTTYPE output)
		{
			return FMOD5_System_SetOutput(handle, output);
		}

		public RESULT getOutput(out OUTPUTTYPE output)
		{
			return FMOD5_System_GetOutput(handle, out output);
		}

		public RESULT getNumDrivers(out int numdrivers)
		{
			return FMOD5_System_GetNumDrivers(handle, out numdrivers);
		}

		public RESULT getDriverInfo(int id, out string name, int namelen, out Guid guid, out int systemrate, out SPEAKERMODE speakermode, out int speakermodechannels)
		{
			IntPtr intPtr = Marshal.AllocHGlobal(namelen);
			RESULT result = FMOD5_System_GetDriverInfo(handle, id, intPtr, namelen, out guid, out systemrate, out speakermode, out speakermodechannels);
			using (StringHelper.ThreadSafeEncoding threadSafeEncoding = StringHelper.GetFreeHelper())
			{
				name = threadSafeEncoding.stringFromNative(intPtr);
			}
			Marshal.FreeHGlobal(intPtr);
			return result;
		}

		public RESULT getDriverInfo(int id, out Guid guid, out int systemrate, out SPEAKERMODE speakermode, out int speakermodechannels)
		{
			return FMOD5_System_GetDriverInfo(handle, id, IntPtr.Zero, 0, out guid, out systemrate, out speakermode, out speakermodechannels);
		}

		public RESULT setDriver(int driver)
		{
			return FMOD5_System_SetDriver(handle, driver);
		}

		public RESULT getDriver(out int driver)
		{
			return FMOD5_System_GetDriver(handle, out driver);
		}

		public RESULT setSoftwareChannels(int numsoftwarechannels)
		{
			return FMOD5_System_SetSoftwareChannels(handle, numsoftwarechannels);
		}

		public RESULT getSoftwareChannels(out int numsoftwarechannels)
		{
			return FMOD5_System_GetSoftwareChannels(handle, out numsoftwarechannels);
		}

		public RESULT setSoftwareFormat(int samplerate, SPEAKERMODE speakermode, int numrawspeakers)
		{
			return FMOD5_System_SetSoftwareFormat(handle, samplerate, speakermode, numrawspeakers);
		}

		public RESULT getSoftwareFormat(out int samplerate, out SPEAKERMODE speakermode, out int numrawspeakers)
		{
			return FMOD5_System_GetSoftwareFormat(handle, out samplerate, out speakermode, out numrawspeakers);
		}

		public RESULT setDSPBufferSize(uint bufferlength, int numbuffers)
		{
			return FMOD5_System_SetDSPBufferSize(handle, bufferlength, numbuffers);
		}

		public RESULT getDSPBufferSize(out uint bufferlength, out int numbuffers)
		{
			return FMOD5_System_GetDSPBufferSize(handle, out bufferlength, out numbuffers);
		}

		public RESULT setFileSystem(FILE_OPEN_CALLBACK useropen, FILE_CLOSE_CALLBACK userclose, FILE_READ_CALLBACK userread, FILE_SEEK_CALLBACK userseek, FILE_ASYNCREAD_CALLBACK userasyncread, FILE_ASYNCCANCEL_CALLBACK userasynccancel, int blockalign)
		{
			return FMOD5_System_SetFileSystem(handle, useropen, userclose, userread, userseek, userasyncread, userasynccancel, blockalign);
		}

		public RESULT attachFileSystem(FILE_OPEN_CALLBACK useropen, FILE_CLOSE_CALLBACK userclose, FILE_READ_CALLBACK userread, FILE_SEEK_CALLBACK userseek)
		{
			return FMOD5_System_AttachFileSystem(handle, useropen, userclose, userread, userseek);
		}

		public RESULT setAdvancedSettings(ref ADVANCEDSETTINGS settings)
		{
			settings.cbSize = Marshal.SizeOf<ADVANCEDSETTINGS>();
			return FMOD5_System_SetAdvancedSettings(handle, ref settings);
		}

		public RESULT getAdvancedSettings(ref ADVANCEDSETTINGS settings)
		{
			settings.cbSize = Marshal.SizeOf<ADVANCEDSETTINGS>();
			return FMOD5_System_GetAdvancedSettings(handle, ref settings);
		}

		public RESULT setCallback(SYSTEM_CALLBACK callback, SYSTEM_CALLBACK_TYPE callbackmask = SYSTEM_CALLBACK_TYPE.ALL)
		{
			return FMOD5_System_SetCallback(handle, callback, callbackmask);
		}

		public RESULT setPluginPath(string path)
		{
			using StringHelper.ThreadSafeEncoding threadSafeEncoding = StringHelper.GetFreeHelper();
			return FMOD5_System_SetPluginPath(handle, threadSafeEncoding.byteFromStringUTF8(path));
		}

		public RESULT loadPlugin(string filename, out uint handle, uint priority = 0u)
		{
			using StringHelper.ThreadSafeEncoding threadSafeEncoding = StringHelper.GetFreeHelper();
			return FMOD5_System_LoadPlugin(this.handle, threadSafeEncoding.byteFromStringUTF8(filename), out handle, priority);
		}

		public RESULT unloadPlugin(uint handle)
		{
			return FMOD5_System_UnloadPlugin(this.handle, handle);
		}

		public RESULT getNumNestedPlugins(uint handle, out int count)
		{
			return FMOD5_System_GetNumNestedPlugins(this.handle, handle, out count);
		}

		public RESULT getNestedPlugin(uint handle, int index, out uint nestedhandle)
		{
			return FMOD5_System_GetNestedPlugin(this.handle, handle, index, out nestedhandle);
		}

		public RESULT getNumPlugins(PLUGINTYPE plugintype, out int numplugins)
		{
			return FMOD5_System_GetNumPlugins(handle, plugintype, out numplugins);
		}

		public RESULT getPluginHandle(PLUGINTYPE plugintype, int index, out uint handle)
		{
			return FMOD5_System_GetPluginHandle(this.handle, plugintype, index, out handle);
		}

		public RESULT getPluginInfo(uint handle, out PLUGINTYPE plugintype, out string name, int namelen, out uint version)
		{
			IntPtr intPtr = Marshal.AllocHGlobal(namelen);
			RESULT result = FMOD5_System_GetPluginInfo(this.handle, handle, out plugintype, intPtr, namelen, out version);
			using (StringHelper.ThreadSafeEncoding threadSafeEncoding = StringHelper.GetFreeHelper())
			{
				name = threadSafeEncoding.stringFromNative(intPtr);
			}
			Marshal.FreeHGlobal(intPtr);
			return result;
		}

		public RESULT getPluginInfo(uint handle, out PLUGINTYPE plugintype, out uint version)
		{
			return FMOD5_System_GetPluginInfo(this.handle, handle, out plugintype, IntPtr.Zero, 0, out version);
		}

		public RESULT setOutputByPlugin(uint handle)
		{
			return FMOD5_System_SetOutputByPlugin(this.handle, handle);
		}

		public RESULT getOutputByPlugin(out uint handle)
		{
			return FMOD5_System_GetOutputByPlugin(this.handle, out handle);
		}

		public RESULT createDSPByPlugin(uint handle, out DSP dsp)
		{
			return FMOD5_System_CreateDSPByPlugin(this.handle, handle, out dsp.handle);
		}

		public RESULT getDSPInfoByPlugin(uint handle, out IntPtr description)
		{
			return FMOD5_System_GetDSPInfoByPlugin(this.handle, handle, out description);
		}

		public RESULT registerDSP(ref DSP_DESCRIPTION description, out uint handle)
		{
			return FMOD5_System_RegisterDSP(this.handle, ref description, out handle);
		}

		public RESULT init(int maxchannels, INITFLAGS flags, IntPtr extradriverdata)
		{
			return FMOD5_System_Init(handle, maxchannels, flags, extradriverdata);
		}

		public RESULT close()
		{
			return FMOD5_System_Close(handle);
		}

		public RESULT update()
		{
			return FMOD5_System_Update(handle);
		}

		public RESULT setSpeakerPosition(SPEAKER speaker, float x, float y, bool active)
		{
			return FMOD5_System_SetSpeakerPosition(handle, speaker, x, y, active);
		}

		public RESULT getSpeakerPosition(SPEAKER speaker, out float x, out float y, out bool active)
		{
			return FMOD5_System_GetSpeakerPosition(handle, speaker, out x, out y, out active);
		}

		public RESULT setStreamBufferSize(uint filebuffersize, TIMEUNIT filebuffersizetype)
		{
			return FMOD5_System_SetStreamBufferSize(handle, filebuffersize, filebuffersizetype);
		}

		public RESULT getStreamBufferSize(out uint filebuffersize, out TIMEUNIT filebuffersizetype)
		{
			return FMOD5_System_GetStreamBufferSize(handle, out filebuffersize, out filebuffersizetype);
		}

		public RESULT set3DSettings(float dopplerscale, float distancefactor, float rolloffscale)
		{
			return FMOD5_System_Set3DSettings(handle, dopplerscale, distancefactor, rolloffscale);
		}

		public RESULT get3DSettings(out float dopplerscale, out float distancefactor, out float rolloffscale)
		{
			return FMOD5_System_Get3DSettings(handle, out dopplerscale, out distancefactor, out rolloffscale);
		}

		public RESULT set3DNumListeners(int numlisteners)
		{
			return FMOD5_System_Set3DNumListeners(handle, numlisteners);
		}

		public RESULT get3DNumListeners(out int numlisteners)
		{
			return FMOD5_System_Get3DNumListeners(handle, out numlisteners);
		}

		public RESULT set3DListenerAttributes(int listener, ref VECTOR pos, ref VECTOR vel, ref VECTOR forward, ref VECTOR up)
		{
			return FMOD5_System_Set3DListenerAttributes(handle, listener, ref pos, ref vel, ref forward, ref up);
		}

		public RESULT get3DListenerAttributes(int listener, out VECTOR pos, out VECTOR vel, out VECTOR forward, out VECTOR up)
		{
			return FMOD5_System_Get3DListenerAttributes(handle, listener, out pos, out vel, out forward, out up);
		}

		public RESULT set3DRolloffCallback(CB_3D_ROLLOFF_CALLBACK callback)
		{
			return FMOD5_System_Set3DRolloffCallback(handle, callback);
		}

		public RESULT mixerSuspend()
		{
			return FMOD5_System_MixerSuspend(handle);
		}

		public RESULT mixerResume()
		{
			return FMOD5_System_MixerResume(handle);
		}

		public RESULT getDefaultMixMatrix(SPEAKERMODE sourcespeakermode, SPEAKERMODE targetspeakermode, float[] matrix, int matrixhop)
		{
			return FMOD5_System_GetDefaultMixMatrix(handle, sourcespeakermode, targetspeakermode, matrix, matrixhop);
		}

		public RESULT getSpeakerModeChannels(SPEAKERMODE mode, out int channels)
		{
			return FMOD5_System_GetSpeakerModeChannels(handle, mode, out channels);
		}

		public RESULT getVersion(out uint version)
		{
			uint buildnumber;
			return getVersion(out version, out buildnumber);
		}

		public RESULT getVersion(out uint version, out uint buildnumber)
		{
			return FMOD5_System_GetVersion(handle, out version, out buildnumber);
		}

		public RESULT getOutputHandle(out IntPtr handle)
		{
			return FMOD5_System_GetOutputHandle(this.handle, out handle);
		}

		public RESULT getChannelsPlaying(out int channels)
		{
			return FMOD5_System_GetChannelsPlaying(handle, out channels, IntPtr.Zero);
		}

		public RESULT getChannelsPlaying(out int channels, out int realchannels)
		{
			return FMOD5_System_GetChannelsPlaying(handle, out channels, out realchannels);
		}

		public RESULT getCPUUsage(out CPU_USAGE usage)
		{
			return FMOD5_System_GetCPUUsage(handle, out usage);
		}

		public RESULT getFileUsage(out long sampleBytesRead, out long streamBytesRead, out long otherBytesRead)
		{
			return FMOD5_System_GetFileUsage(handle, out sampleBytesRead, out streamBytesRead, out otherBytesRead);
		}

		public RESULT createSound(string name, MODE mode, ref CREATESOUNDEXINFO exinfo, out Sound sound)
		{
			using StringHelper.ThreadSafeEncoding threadSafeEncoding = StringHelper.GetFreeHelper();
			return FMOD5_System_CreateSound(handle, threadSafeEncoding.byteFromStringUTF8(name), mode, ref exinfo, out sound.handle);
		}

		public RESULT createSound(byte[] data, MODE mode, ref CREATESOUNDEXINFO exinfo, out Sound sound)
		{
			return FMOD5_System_CreateSound(handle, data, mode, ref exinfo, out sound.handle);
		}

		public RESULT createSound(IntPtr name_or_data, MODE mode, ref CREATESOUNDEXINFO exinfo, out Sound sound)
		{
			return FMOD5_System_CreateSound(handle, name_or_data, mode, ref exinfo, out sound.handle);
		}

		public RESULT createSound(string name, MODE mode, out Sound sound)
		{
			CREATESOUNDEXINFO exinfo = default(CREATESOUNDEXINFO);
			exinfo.cbsize = Marshal.SizeOf<CREATESOUNDEXINFO>();
			return createSound(name, mode, ref exinfo, out sound);
		}

		public RESULT createStream(string name, MODE mode, ref CREATESOUNDEXINFO exinfo, out Sound sound)
		{
			using StringHelper.ThreadSafeEncoding threadSafeEncoding = StringHelper.GetFreeHelper();
			return FMOD5_System_CreateStream(handle, threadSafeEncoding.byteFromStringUTF8(name), mode, ref exinfo, out sound.handle);
		}

		public RESULT createStream(byte[] data, MODE mode, ref CREATESOUNDEXINFO exinfo, out Sound sound)
		{
			return FMOD5_System_CreateStream(handle, data, mode, ref exinfo, out sound.handle);
		}

		public RESULT createStream(IntPtr name_or_data, MODE mode, ref CREATESOUNDEXINFO exinfo, out Sound sound)
		{
			return FMOD5_System_CreateStream(handle, name_or_data, mode, ref exinfo, out sound.handle);
		}

		public RESULT createStream(string name, MODE mode, out Sound sound)
		{
			CREATESOUNDEXINFO exinfo = default(CREATESOUNDEXINFO);
			exinfo.cbsize = Marshal.SizeOf<CREATESOUNDEXINFO>();
			return createStream(name, mode, ref exinfo, out sound);
		}

		public RESULT createDSP(ref DSP_DESCRIPTION description, out DSP dsp)
		{
			return FMOD5_System_CreateDSP(handle, ref description, out dsp.handle);
		}

		public RESULT createDSPByType(DSP_TYPE type, out DSP dsp)
		{
			return FMOD5_System_CreateDSPByType(handle, type, out dsp.handle);
		}

		public RESULT createChannelGroup(string name, out ChannelGroup channelgroup)
		{
			using StringHelper.ThreadSafeEncoding threadSafeEncoding = StringHelper.GetFreeHelper();
			return FMOD5_System_CreateChannelGroup(handle, threadSafeEncoding.byteFromStringUTF8(name), out channelgroup.handle);
		}

		public RESULT createSoundGroup(string name, out SoundGroup soundgroup)
		{
			using StringHelper.ThreadSafeEncoding threadSafeEncoding = StringHelper.GetFreeHelper();
			return FMOD5_System_CreateSoundGroup(handle, threadSafeEncoding.byteFromStringUTF8(name), out soundgroup.handle);
		}

		public RESULT createReverb3D(out Reverb3D reverb)
		{
			return FMOD5_System_CreateReverb3D(handle, out reverb.handle);
		}

		public RESULT playSound(Sound sound, ChannelGroup channelgroup, bool paused, out Channel channel)
		{
			return FMOD5_System_PlaySound(handle, sound.handle, channelgroup.handle, paused, out channel.handle);
		}

		public RESULT playDSP(DSP dsp, ChannelGroup channelgroup, bool paused, out Channel channel)
		{
			return FMOD5_System_PlayDSP(handle, dsp.handle, channelgroup.handle, paused, out channel.handle);
		}

		public RESULT getChannel(int channelid, out Channel channel)
		{
			return FMOD5_System_GetChannel(handle, channelid, out channel.handle);
		}

		public RESULT getDSPInfoByType(DSP_TYPE type, out IntPtr description)
		{
			return FMOD5_System_GetDSPInfoByType(handle, type, out description);
		}

		public RESULT getMasterChannelGroup(out ChannelGroup channelgroup)
		{
			return FMOD5_System_GetMasterChannelGroup(handle, out channelgroup.handle);
		}

		public RESULT getMasterSoundGroup(out SoundGroup soundgroup)
		{
			return FMOD5_System_GetMasterSoundGroup(handle, out soundgroup.handle);
		}

		public RESULT attachChannelGroupToPort(PORT_TYPE portType, ulong portIndex, ChannelGroup channelgroup, bool passThru = false)
		{
			return FMOD5_System_AttachChannelGroupToPort(handle, portType, portIndex, channelgroup.handle, passThru);
		}

		public RESULT detachChannelGroupFromPort(ChannelGroup channelgroup)
		{
			return FMOD5_System_DetachChannelGroupFromPort(handle, channelgroup.handle);
		}

		public RESULT setReverbProperties(int instance, ref REVERB_PROPERTIES prop)
		{
			return FMOD5_System_SetReverbProperties(handle, instance, ref prop);
		}

		public RESULT getReverbProperties(int instance, out REVERB_PROPERTIES prop)
		{
			return FMOD5_System_GetReverbProperties(handle, instance, out prop);
		}

		public RESULT lockDSP()
		{
			return FMOD5_System_LockDSP(handle);
		}

		public RESULT unlockDSP()
		{
			return FMOD5_System_UnlockDSP(handle);
		}

		public RESULT getRecordNumDrivers(out int numdrivers, out int numconnected)
		{
			return FMOD5_System_GetRecordNumDrivers(handle, out numdrivers, out numconnected);
		}

		public RESULT getRecordDriverInfo(int id, out string name, int namelen, out Guid guid, out int systemrate, out SPEAKERMODE speakermode, out int speakermodechannels, out DRIVER_STATE state)
		{
			IntPtr intPtr = Marshal.AllocHGlobal(namelen);
			RESULT result = FMOD5_System_GetRecordDriverInfo(handle, id, intPtr, namelen, out guid, out systemrate, out speakermode, out speakermodechannels, out state);
			using (StringHelper.ThreadSafeEncoding threadSafeEncoding = StringHelper.GetFreeHelper())
			{
				name = threadSafeEncoding.stringFromNative(intPtr);
			}
			Marshal.FreeHGlobal(intPtr);
			return result;
		}

		public RESULT getRecordDriverInfo(int id, out Guid guid, out int systemrate, out SPEAKERMODE speakermode, out int speakermodechannels, out DRIVER_STATE state)
		{
			return FMOD5_System_GetRecordDriverInfo(handle, id, IntPtr.Zero, 0, out guid, out systemrate, out speakermode, out speakermodechannels, out state);
		}

		public RESULT getRecordPosition(int id, out uint position)
		{
			return FMOD5_System_GetRecordPosition(handle, id, out position);
		}

		public RESULT recordStart(int id, Sound sound, bool loop)
		{
			return FMOD5_System_RecordStart(handle, id, sound.handle, loop);
		}

		public RESULT recordStop(int id)
		{
			return FMOD5_System_RecordStop(handle, id);
		}

		public RESULT isRecording(int id, out bool recording)
		{
			return FMOD5_System_IsRecording(handle, id, out recording);
		}

		public RESULT createGeometry(int maxpolygons, int maxvertices, out Geometry geometry)
		{
			return FMOD5_System_CreateGeometry(handle, maxpolygons, maxvertices, out geometry.handle);
		}

		public RESULT setGeometrySettings(float maxworldsize)
		{
			return FMOD5_System_SetGeometrySettings(handle, maxworldsize);
		}

		public RESULT getGeometrySettings(out float maxworldsize)
		{
			return FMOD5_System_GetGeometrySettings(handle, out maxworldsize);
		}

		public RESULT loadGeometry(IntPtr data, int datasize, out Geometry geometry)
		{
			return FMOD5_System_LoadGeometry(handle, data, datasize, out geometry.handle);
		}

		public RESULT getGeometryOcclusion(ref VECTOR listener, ref VECTOR source, out float direct, out float reverb)
		{
			return FMOD5_System_GetGeometryOcclusion(handle, ref listener, ref source, out direct, out reverb);
		}

		public RESULT setNetworkProxy(string proxy)
		{
			using StringHelper.ThreadSafeEncoding threadSafeEncoding = StringHelper.GetFreeHelper();
			return FMOD5_System_SetNetworkProxy(handle, threadSafeEncoding.byteFromStringUTF8(proxy));
		}

		public RESULT getNetworkProxy(out string proxy, int proxylen)
		{
			IntPtr intPtr = Marshal.AllocHGlobal(proxylen);
			RESULT result = FMOD5_System_GetNetworkProxy(handle, intPtr, proxylen);
			using (StringHelper.ThreadSafeEncoding threadSafeEncoding = StringHelper.GetFreeHelper())
			{
				proxy = threadSafeEncoding.stringFromNative(intPtr);
			}
			Marshal.FreeHGlobal(intPtr);
			return result;
		}

		public RESULT setNetworkTimeout(int timeout)
		{
			return FMOD5_System_SetNetworkTimeout(handle, timeout);
		}

		public RESULT getNetworkTimeout(out int timeout)
		{
			return FMOD5_System_GetNetworkTimeout(handle, out timeout);
		}

		public RESULT setUserData(IntPtr userdata)
		{
			return FMOD5_System_SetUserData(handle, userdata);
		}

		public RESULT getUserData(out IntPtr userdata)
		{
			return FMOD5_System_GetUserData(handle, out userdata);
		}

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_Release(IntPtr system);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_SetOutput(IntPtr system, OUTPUTTYPE output);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_GetOutput(IntPtr system, out OUTPUTTYPE output);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_GetNumDrivers(IntPtr system, out int numdrivers);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_GetDriverInfo(IntPtr system, int id, IntPtr name, int namelen, out Guid guid, out int systemrate, out SPEAKERMODE speakermode, out int speakermodechannels);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_SetDriver(IntPtr system, int driver);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_GetDriver(IntPtr system, out int driver);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_SetSoftwareChannels(IntPtr system, int numsoftwarechannels);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_GetSoftwareChannels(IntPtr system, out int numsoftwarechannels);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_SetSoftwareFormat(IntPtr system, int samplerate, SPEAKERMODE speakermode, int numrawspeakers);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_GetSoftwareFormat(IntPtr system, out int samplerate, out SPEAKERMODE speakermode, out int numrawspeakers);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_SetDSPBufferSize(IntPtr system, uint bufferlength, int numbuffers);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_GetDSPBufferSize(IntPtr system, out uint bufferlength, out int numbuffers);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_SetFileSystem(IntPtr system, FILE_OPEN_CALLBACK useropen, FILE_CLOSE_CALLBACK userclose, FILE_READ_CALLBACK userread, FILE_SEEK_CALLBACK userseek, FILE_ASYNCREAD_CALLBACK userasyncread, FILE_ASYNCCANCEL_CALLBACK userasynccancel, int blockalign);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_AttachFileSystem(IntPtr system, FILE_OPEN_CALLBACK useropen, FILE_CLOSE_CALLBACK userclose, FILE_READ_CALLBACK userread, FILE_SEEK_CALLBACK userseek);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_SetAdvancedSettings(IntPtr system, ref ADVANCEDSETTINGS settings);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_GetAdvancedSettings(IntPtr system, ref ADVANCEDSETTINGS settings);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_SetCallback(IntPtr system, SYSTEM_CALLBACK callback, SYSTEM_CALLBACK_TYPE callbackmask);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_SetPluginPath(IntPtr system, byte[] path);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_LoadPlugin(IntPtr system, byte[] filename, out uint handle, uint priority);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_UnloadPlugin(IntPtr system, uint handle);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_GetNumNestedPlugins(IntPtr system, uint handle, out int count);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_GetNestedPlugin(IntPtr system, uint handle, int index, out uint nestedhandle);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_GetNumPlugins(IntPtr system, PLUGINTYPE plugintype, out int numplugins);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_GetPluginHandle(IntPtr system, PLUGINTYPE plugintype, int index, out uint handle);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_GetPluginInfo(IntPtr system, uint handle, out PLUGINTYPE plugintype, IntPtr name, int namelen, out uint version);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_SetOutputByPlugin(IntPtr system, uint handle);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_GetOutputByPlugin(IntPtr system, out uint handle);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_CreateDSPByPlugin(IntPtr system, uint handle, out IntPtr dsp);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_GetDSPInfoByPlugin(IntPtr system, uint handle, out IntPtr description);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_RegisterDSP(IntPtr system, ref DSP_DESCRIPTION description, out uint handle);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_Init(IntPtr system, int maxchannels, INITFLAGS flags, IntPtr extradriverdata);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_Close(IntPtr system);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_Update(IntPtr system);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_SetSpeakerPosition(IntPtr system, SPEAKER speaker, float x, float y, bool active);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_GetSpeakerPosition(IntPtr system, SPEAKER speaker, out float x, out float y, out bool active);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_SetStreamBufferSize(IntPtr system, uint filebuffersize, TIMEUNIT filebuffersizetype);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_GetStreamBufferSize(IntPtr system, out uint filebuffersize, out TIMEUNIT filebuffersizetype);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_Set3DSettings(IntPtr system, float dopplerscale, float distancefactor, float rolloffscale);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_Get3DSettings(IntPtr system, out float dopplerscale, out float distancefactor, out float rolloffscale);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_Set3DNumListeners(IntPtr system, int numlisteners);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_Get3DNumListeners(IntPtr system, out int numlisteners);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_Set3DListenerAttributes(IntPtr system, int listener, ref VECTOR pos, ref VECTOR vel, ref VECTOR forward, ref VECTOR up);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_Get3DListenerAttributes(IntPtr system, int listener, out VECTOR pos, out VECTOR vel, out VECTOR forward, out VECTOR up);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_Set3DRolloffCallback(IntPtr system, CB_3D_ROLLOFF_CALLBACK callback);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_MixerSuspend(IntPtr system);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_MixerResume(IntPtr system);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_GetDefaultMixMatrix(IntPtr system, SPEAKERMODE sourcespeakermode, SPEAKERMODE targetspeakermode, float[] matrix, int matrixhop);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_GetSpeakerModeChannels(IntPtr system, SPEAKERMODE mode, out int channels);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_GetVersion(IntPtr system, out uint version, out uint buildnumber);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_GetOutputHandle(IntPtr system, out IntPtr handle);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_GetChannelsPlaying(IntPtr system, out int channels, IntPtr zero);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_GetChannelsPlaying(IntPtr system, out int channels, out int realchannels);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_GetCPUUsage(IntPtr system, out CPU_USAGE usage);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_GetFileUsage(IntPtr system, out long sampleBytesRead, out long streamBytesRead, out long otherBytesRead);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_CreateSound(IntPtr system, byte[] name_or_data, MODE mode, ref CREATESOUNDEXINFO exinfo, out IntPtr sound);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_CreateSound(IntPtr system, IntPtr name_or_data, MODE mode, ref CREATESOUNDEXINFO exinfo, out IntPtr sound);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_CreateStream(IntPtr system, byte[] name_or_data, MODE mode, ref CREATESOUNDEXINFO exinfo, out IntPtr sound);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_CreateStream(IntPtr system, IntPtr name_or_data, MODE mode, ref CREATESOUNDEXINFO exinfo, out IntPtr sound);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_CreateDSP(IntPtr system, ref DSP_DESCRIPTION description, out IntPtr dsp);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_CreateDSPByType(IntPtr system, DSP_TYPE type, out IntPtr dsp);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_CreateChannelGroup(IntPtr system, byte[] name, out IntPtr channelgroup);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_CreateSoundGroup(IntPtr system, byte[] name, out IntPtr soundgroup);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_CreateReverb3D(IntPtr system, out IntPtr reverb);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_PlaySound(IntPtr system, IntPtr sound, IntPtr channelgroup, bool paused, out IntPtr channel);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_PlayDSP(IntPtr system, IntPtr dsp, IntPtr channelgroup, bool paused, out IntPtr channel);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_GetChannel(IntPtr system, int channelid, out IntPtr channel);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_GetDSPInfoByType(IntPtr system, DSP_TYPE type, out IntPtr description);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_GetMasterChannelGroup(IntPtr system, out IntPtr channelgroup);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_GetMasterSoundGroup(IntPtr system, out IntPtr soundgroup);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_AttachChannelGroupToPort(IntPtr system, PORT_TYPE portType, ulong portIndex, IntPtr channelgroup, bool passThru);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_DetachChannelGroupFromPort(IntPtr system, IntPtr channelgroup);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_SetReverbProperties(IntPtr system, int instance, ref REVERB_PROPERTIES prop);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_GetReverbProperties(IntPtr system, int instance, out REVERB_PROPERTIES prop);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_LockDSP(IntPtr system);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_UnlockDSP(IntPtr system);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_GetRecordNumDrivers(IntPtr system, out int numdrivers, out int numconnected);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_GetRecordDriverInfo(IntPtr system, int id, IntPtr name, int namelen, out Guid guid, out int systemrate, out SPEAKERMODE speakermode, out int speakermodechannels, out DRIVER_STATE state);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_GetRecordPosition(IntPtr system, int id, out uint position);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_RecordStart(IntPtr system, int id, IntPtr sound, bool loop);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_RecordStop(IntPtr system, int id);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_IsRecording(IntPtr system, int id, out bool recording);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_CreateGeometry(IntPtr system, int maxpolygons, int maxvertices, out IntPtr geometry);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_SetGeometrySettings(IntPtr system, float maxworldsize);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_GetGeometrySettings(IntPtr system, out float maxworldsize);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_LoadGeometry(IntPtr system, IntPtr data, int datasize, out IntPtr geometry);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_GetGeometryOcclusion(IntPtr system, ref VECTOR listener, ref VECTOR source, out float direct, out float reverb);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_SetNetworkProxy(IntPtr system, byte[] proxy);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_GetNetworkProxy(IntPtr system, IntPtr proxy, int proxylen);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_SetNetworkTimeout(IntPtr system, int timeout);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_GetNetworkTimeout(IntPtr system, out int timeout);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_SetUserData(IntPtr system, IntPtr userdata);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_System_GetUserData(IntPtr system, out IntPtr userdata);

		public System(IntPtr ptr)
		{
			handle = ptr;
		}

		public bool hasHandle()
		{
			return handle != IntPtr.Zero;
		}

		public void clearHandle()
		{
			handle = IntPtr.Zero;
		}
	}
	public struct Sound
	{
		public IntPtr handle;

		public RESULT release()
		{
			return FMOD5_Sound_Release(handle);
		}

		public RESULT getSystemObject(out System system)
		{
			return FMOD5_Sound_GetSystemObject(handle, out system.handle);
		}

		public RESULT @lock(uint offset, uint length, out IntPtr ptr1, out IntPtr ptr2, out uint len1, out uint len2)
		{
			return FMOD5_Sound_Lock(handle, offset, length, out ptr1, out ptr2, out len1, out len2);
		}

		public RESULT unlock(IntPtr ptr1, IntPtr ptr2, uint len1, uint len2)
		{
			return FMOD5_Sound_Unlock(handle, ptr1, ptr2, len1, len2);
		}

		public RESULT setDefaults(float frequency, int priority)
		{
			return FMOD5_Sound_SetDefaults(handle, frequency, priority);
		}

		public RESULT getDefaults(out float frequency, out int priority)
		{
			return FMOD5_Sound_GetDefaults(handle, out frequency, out priority);
		}

		public RESULT set3DMinMaxDistance(float min, float max)
		{
			return FMOD5_Sound_Set3DMinMaxDistance(handle, min, max);
		}

		public RESULT get3DMinMaxDistance(out float min, out float max)
		{
			return FMOD5_Sound_Get3DMinMaxDistance(handle, out min, out max);
		}

		public RESULT set3DConeSettings(float insideconeangle, float outsideconeangle, float outsidevolume)
		{
			return FMOD5_Sound_Set3DConeSettings(handle, insideconeangle, outsideconeangle, outsidevolume);
		}

		public RESULT get3DConeSettings(out float insideconeangle, out float outsideconeangle, out float outsidevolume)
		{
			return FMOD5_Sound_Get3DConeSettings(handle, out insideconeangle, out outsideconeangle, out outsidevolume);
		}

		public RESULT set3DCustomRolloff(ref VECTOR points, int numpoints)
		{
			return FMOD5_Sound_Set3DCustomRolloff(handle, ref points, numpoints);
		}

		public RESULT get3DCustomRolloff(out IntPtr points, out int numpoints)
		{
			return FMOD5_Sound_Get3DCustomRolloff(handle, out points, out numpoints);
		}

		public RESULT getSubSound(int index, out Sound subsound)
		{
			return FMOD5_Sound_GetSubSound(handle, index, out subsound.handle);
		}

		public RESULT getSubSoundParent(out Sound parentsound)
		{
			return FMOD5_Sound_GetSubSoundParent(handle, out parentsound.handle);
		}

		public RESULT getName(out string name, int namelen)
		{
			IntPtr intPtr = Marshal.AllocHGlobal(namelen);
			RESULT result = FMOD5_Sound_GetName(handle, intPtr, namelen);
			using (StringHelper.ThreadSafeEncoding threadSafeEncoding = StringHelper.GetFreeHelper())
			{
				name = threadSafeEncoding.stringFromNative(intPtr);
			}
			Marshal.FreeHGlobal(intPtr);
			return result;
		}

		public RESULT getLength(out uint length, TIMEUNIT lengthtype)
		{
			return FMOD5_Sound_GetLength(handle, out length, lengthtype);
		}

		public RESULT getFormat(out SOUND_TYPE type, out SOUND_FORMAT format, out int channels, out int bits)
		{
			return FMOD5_Sound_GetFormat(handle, out type, out format, out channels, out bits);
		}

		public RESULT getNumSubSounds(out int numsubsounds)
		{
			return FMOD5_Sound_GetNumSubSounds(handle, out numsubsounds);
		}

		public RESULT getNumTags(out int numtags, out int numtagsupdated)
		{
			return FMOD5_Sound_GetNumTags(handle, out numtags, out numtagsupdated);
		}

		public RESULT getTag(string name, int index, out TAG tag)
		{
			using StringHelper.ThreadSafeEncoding threadSafeEncoding = StringHelper.GetFreeHelper();
			return FMOD5_Sound_GetTag(handle, threadSafeEncoding.byteFromStringUTF8(name), index, out tag);
		}

		public RESULT getOpenState(out OPENSTATE openstate, out uint percentbuffered, out bool starving, out bool diskbusy)
		{
			return FMOD5_Sound_GetOpenState(handle, out openstate, out percentbuffered, out starving, out diskbusy);
		}

		public RESULT readData(byte[] buffer)
		{
			return FMOD5_Sound_ReadData(handle, buffer, (uint)buffer.Length, IntPtr.Zero);
		}

		public RESULT readData(byte[] buffer, out uint read)
		{
			return FMOD5_Sound_ReadData(handle, buffer, (uint)buffer.Length, out read);
		}

		public RESULT seekData(uint pcm)
		{
			return FMOD5_Sound_SeekData(handle, pcm);
		}

		public RESULT setSoundGroup(SoundGroup soundgroup)
		{
			return FMOD5_Sound_SetSoundGroup(handle, soundgroup.handle);
		}

		public RESULT getSoundGroup(out SoundGroup soundgroup)
		{
			return FMOD5_Sound_GetSoundGroup(handle, out soundgroup.handle);
		}

		public RESULT getNumSyncPoints(out int numsyncpoints)
		{
			return FMOD5_Sound_GetNumSyncPoints(handle, out numsyncpoints);
		}

		public RESULT getSyncPoint(int index, out IntPtr point)
		{
			return FMOD5_Sound_GetSyncPoint(handle, index, out point);
		}

		public RESULT getSyncPointInfo(IntPtr point, out string name, int namelen, out uint offset, TIMEUNIT offsettype)
		{
			IntPtr intPtr = Marshal.AllocHGlobal(namelen);
			RESULT result = FMOD5_Sound_GetSyncPointInfo(handle, point, intPtr, namelen, out offset, offsettype);
			using (StringHelper.ThreadSafeEncoding threadSafeEncoding = StringHelper.GetFreeHelper())
			{
				name = threadSafeEncoding.stringFromNative(intPtr);
			}
			Marshal.FreeHGlobal(intPtr);
			return result;
		}

		public RESULT getSyncPointInfo(IntPtr point, out uint offset, TIMEUNIT offsettype)
		{
			return FMOD5_Sound_GetSyncPointInfo(handle, point, IntPtr.Zero, 0, out offset, offsettype);
		}

		public RESULT addSyncPoint(uint offset, TIMEUNIT offsettype, string name, out IntPtr point)
		{
			using StringHelper.ThreadSafeEncoding threadSafeEncoding = StringHelper.GetFreeHelper();
			return FMOD5_Sound_AddSyncPoint(handle, offset, offsettype, threadSafeEncoding.byteFromStringUTF8(name), out point);
		}

		public RESULT deleteSyncPoint(IntPtr point)
		{
			return FMOD5_Sound_DeleteSyncPoint(handle, point);
		}

		public RESULT setMode(MODE mode)
		{
			return FMOD5_Sound_SetMode(handle, mode);
		}

		public RESULT getMode(out MODE mode)
		{
			return FMOD5_Sound_GetMode(handle, out mode);
		}

		public RESULT setLoopCount(int loopcount)
		{
			return FMOD5_Sound_SetLoopCount(handle, loopcount);
		}

		public RESULT getLoopCount(out int loopcount)
		{
			return FMOD5_Sound_GetLoopCount(handle, out loopcount);
		}

		public RESULT setLoopPoints(uint loopstart, TIMEUNIT loopstarttype, uint loopend, TIMEUNIT loopendtype)
		{
			return FMOD5_Sound_SetLoopPoints(handle, loopstart, loopstarttype, loopend, loopendtype);
		}

		public RESULT getLoopPoints(out uint loopstart, TIMEUNIT loopstarttype, out uint loopend, TIMEUNIT loopendtype)
		{
			return FMOD5_Sound_GetLoopPoints(handle, out loopstart, loopstarttype, out loopend, loopendtype);
		}

		public RESULT getMusicNumChannels(out int numchannels)
		{
			return FMOD5_Sound_GetMusicNumChannels(handle, out numchannels);
		}

		public RESULT setMusicChannelVolume(int channel, float volume)
		{
			return FMOD5_Sound_SetMusicChannelVolume(handle, channel, volume);
		}

		public RESULT getMusicChannelVolume(int channel, out float volume)
		{
			return FMOD5_Sound_GetMusicChannelVolume(handle, channel, out volume);
		}

		public RESULT setMusicSpeed(float speed)
		{
			return FMOD5_Sound_SetMusicSpeed(handle, speed);
		}

		public RESULT getMusicSpeed(out float speed)
		{
			return FMOD5_Sound_GetMusicSpeed(handle, out speed);
		}

		public RESULT setUserData(IntPtr userdata)
		{
			return FMOD5_Sound_SetUserData(handle, userdata);
		}

		public RESULT getUserData(out IntPtr userdata)
		{
			return FMOD5_Sound_GetUserData(handle, out userdata);
		}

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Sound_Release(IntPtr sound);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Sound_GetSystemObject(IntPtr sound, out IntPtr system);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Sound_Lock(IntPtr sound, uint offset, uint length, out IntPtr ptr1, out IntPtr ptr2, out uint len1, out uint len2);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Sound_Unlock(IntPtr sound, IntPtr ptr1, IntPtr ptr2, uint len1, uint len2);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Sound_SetDefaults(IntPtr sound, float frequency, int priority);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Sound_GetDefaults(IntPtr sound, out float frequency, out int priority);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Sound_Set3DMinMaxDistance(IntPtr sound, float min, float max);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Sound_Get3DMinMaxDistance(IntPtr sound, out float min, out float max);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Sound_Set3DConeSettings(IntPtr sound, float insideconeangle, float outsideconeangle, float outsidevolume);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Sound_Get3DConeSettings(IntPtr sound, out float insideconeangle, out float outsideconeangle, out float outsidevolume);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Sound_Set3DCustomRolloff(IntPtr sound, ref VECTOR points, int numpoints);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Sound_Get3DCustomRolloff(IntPtr sound, out IntPtr points, out int numpoints);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Sound_GetSubSound(IntPtr sound, int index, out IntPtr subsound);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Sound_GetSubSoundParent(IntPtr sound, out IntPtr parentsound);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Sound_GetName(IntPtr sound, IntPtr name, int namelen);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Sound_GetLength(IntPtr sound, out uint length, TIMEUNIT lengthtype);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Sound_GetFormat(IntPtr sound, out SOUND_TYPE type, out SOUND_FORMAT format, out int channels, out int bits);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Sound_GetNumSubSounds(IntPtr sound, out int numsubsounds);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Sound_GetNumTags(IntPtr sound, out int numtags, out int numtagsupdated);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Sound_GetTag(IntPtr sound, byte[] name, int index, out TAG tag);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Sound_GetOpenState(IntPtr sound, out OPENSTATE openstate, out uint percentbuffered, out bool starving, out bool diskbusy);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Sound_ReadData(IntPtr sound, byte[] buffer, uint length, IntPtr zero);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Sound_ReadData(IntPtr sound, byte[] buffer, uint length, out uint read);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Sound_SeekData(IntPtr sound, uint pcm);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Sound_SetSoundGroup(IntPtr sound, IntPtr soundgroup);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Sound_GetSoundGroup(IntPtr sound, out IntPtr soundgroup);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Sound_GetNumSyncPoints(IntPtr sound, out int numsyncpoints);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Sound_GetSyncPoint(IntPtr sound, int index, out IntPtr point);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Sound_GetSyncPointInfo(IntPtr sound, IntPtr point, IntPtr name, int namelen, out uint offset, TIMEUNIT offsettype);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Sound_AddSyncPoint(IntPtr sound, uint offset, TIMEUNIT offsettype, byte[] name, out IntPtr point);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Sound_DeleteSyncPoint(IntPtr sound, IntPtr point);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Sound_SetMode(IntPtr sound, MODE mode);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Sound_GetMode(IntPtr sound, out MODE mode);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Sound_SetLoopCount(IntPtr sound, int loopcount);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Sound_GetLoopCount(IntPtr sound, out int loopcount);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Sound_SetLoopPoints(IntPtr sound, uint loopstart, TIMEUNIT loopstarttype, uint loopend, TIMEUNIT loopendtype);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Sound_GetLoopPoints(IntPtr sound, out uint loopstart, TIMEUNIT loopstarttype, out uint loopend, TIMEUNIT loopendtype);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Sound_GetMusicNumChannels(IntPtr sound, out int numchannels);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Sound_SetMusicChannelVolume(IntPtr sound, int channel, float volume);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Sound_GetMusicChannelVolume(IntPtr sound, int channel, out float volume);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Sound_SetMusicSpeed(IntPtr sound, float speed);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Sound_GetMusicSpeed(IntPtr sound, out float speed);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Sound_SetUserData(IntPtr sound, IntPtr userdata);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Sound_GetUserData(IntPtr sound, out IntPtr userdata);

		public Sound(IntPtr ptr)
		{
			handle = ptr;
		}

		public bool hasHandle()
		{
			return handle != IntPtr.Zero;
		}

		public void clearHandle()
		{
			handle = IntPtr.Zero;
		}
	}
	internal interface IChannelControl
	{
		RESULT getSystemObject(out System system);

		RESULT stop();

		RESULT setPaused(bool paused);

		RESULT getPaused(out bool paused);

		RESULT setVolume(float volume);

		RESULT getVolume(out float volume);

		RESULT setVolumeRamp(bool ramp);

		RESULT getVolumeRamp(out bool ramp);

		RESULT getAudibility(out float audibility);

		RESULT setPitch(float pitch);

		RESULT getPitch(out float pitch);

		RESULT setMute(bool mute);

		RESULT getMute(out bool mute);

		RESULT setReverbProperties(int instance, float wet);

		RESULT getReverbProperties(int instance, out float wet);

		RESULT setLowPassGain(float gain);

		RESULT getLowPassGain(out float gain);

		RESULT setMode(MODE mode);

		RESULT getMode(out MODE mode);

		RESULT setCallback(CHANNELCONTROL_CALLBACK callback);

		RESULT isPlaying(out bool isplaying);

		RESULT setPan(float pan);

		RESULT setMixLevelsOutput(float frontleft, float frontright, float center, float lfe, float surroundleft, float surroundright, float backleft, float backright);

		RESULT setMixLevelsInput(float[] levels, int numlevels);

		RESULT setMixMatrix(float[] matrix, int outchannels, int inchannels, int inchannel_hop);

		RESULT getMixMatrix(float[] matrix, out int outchannels, out int inchannels, int inchannel_hop);

		RESULT getDSPClock(out ulong dspclock, out ulong parentclock);

		RESULT setDelay(ulong dspclock_start, ulong dspclock_end, bool stopchannels);

		RESULT getDelay(out ulong dspclock_start, out ulong dspclock_end);

		RESULT getDelay(out ulong dspclock_start, out ulong dspclock_end, out bool stopchannels);

		RESULT addFadePoint(ulong dspclock, float volume);

		RESULT setFadePointRamp(ulong dspclock, float volume);

		RESULT removeFadePoints(ulong dspclock_start, ulong dspclock_end);

		RESULT getFadePoints(ref uint numpoints, ulong[] point_dspclock, float[] point_volume);

		RESULT getDSP(int index, out DSP dsp);

		RESULT addDSP(int index, DSP dsp);

		RESULT removeDSP(DSP dsp);

		RESULT getNumDSPs(out int numdsps);

		RESULT setDSPIndex(DSP dsp, int index);

		RESULT getDSPIndex(DSP dsp, out int index);

		RESULT set3DAttributes(ref VECTOR pos, ref VECTOR vel);

		RESULT get3DAttributes(out VECTOR pos, out VECTOR vel);

		RESULT set3DMinMaxDistance(float mindistance, float maxdistance);

		RESULT get3DMinMaxDistance(out float mindistance, out float maxdistance);

		RESULT set3DConeSettings(float insideconeangle, float outsideconeangle, float outsidevolume);

		RESULT get3DConeSettings(out float insideconeangle, out float outsideconeangle, out float outsidevolume);

		RESULT set3DConeOrientation(ref VECTOR orientation);

		RESULT get3DConeOrientation(out VECTOR orientation);

		RESULT set3DCustomRolloff(ref VECTOR points, int numpoints);

		RESULT get3DCustomRolloff(out IntPtr points, out int numpoints);

		RESULT set3DOcclusion(float directocclusion, float reverbocclusion);

		RESULT get3DOcclusion(out float directocclusion, out float reverbocclusion);

		RESULT set3DSpread(float angle);

		RESULT get3DSpread(out float angle);

		RESULT set3DLevel(float level);

		RESULT get3DLevel(out float level);

		RESULT set3DDopplerLevel(float level);

		RESULT get3DDopplerLevel(out float level);

		RESULT set3DDistanceFilter(bool custom, float customLevel, float centerFreq);

		RESULT get3DDistanceFilter(out bool custom, out float customLevel, out float centerFreq);

		RESULT setUserData(IntPtr userdata);

		RESULT getUserData(out IntPtr userdata);
	}
	public struct Channel : IChannelControl
	{
		public IntPtr handle;

		public RESULT setFrequency(float frequency)
		{
			return FMOD5_Channel_SetFrequency(handle, frequency);
		}

		public RESULT getFrequency(out float frequency)
		{
			return FMOD5_Channel_GetFrequency(handle, out frequency);
		}

		public RESULT setPriority(int priority)
		{
			return FMOD5_Channel_SetPriority(handle, priority);
		}

		public RESULT getPriority(out int priority)
		{
			return FMOD5_Channel_GetPriority(handle, out priority);
		}

		public RESULT setPosition(uint position, TIMEUNIT postype)
		{
			return FMOD5_Channel_SetPosition(handle, position, postype);
		}

		public RESULT getPosition(out uint position, TIMEUNIT postype)
		{
			return FMOD5_Channel_GetPosition(handle, out position, postype);
		}

		public RESULT setChannelGroup(ChannelGroup channelgroup)
		{
			return FMOD5_Channel_SetChannelGroup(handle, channelgroup.handle);
		}

		public RESULT getChannelGroup(out ChannelGroup channelgroup)
		{
			return FMOD5_Channel_GetChannelGroup(handle, out channelgroup.handle);
		}

		public RESULT setLoopCount(int loopcount)
		{
			return FMOD5_Channel_SetLoopCount(handle, loopcount);
		}

		public RESULT getLoopCount(out int loopcount)
		{
			return FMOD5_Channel_GetLoopCount(handle, out loopcount);
		}

		public RESULT setLoopPoints(uint loopstart, TIMEUNIT loopstarttype, uint loopend, TIMEUNIT loopendtype)
		{
			return FMOD5_Channel_SetLoopPoints(handle, loopstart, loopstarttype, loopend, loopendtype);
		}

		public RESULT getLoopPoints(out uint loopstart, TIMEUNIT loopstarttype, out uint loopend, TIMEUNIT loopendtype)
		{
			return FMOD5_Channel_GetLoopPoints(handle, out loopstart, loopstarttype, out loopend, loopendtype);
		}

		public RESULT isVirtual(out bool isvirtual)
		{
			return FMOD5_Channel_IsVirtual(handle, out isvirtual);
		}

		public RESULT getCurrentSound(out Sound sound)
		{
			return FMOD5_Channel_GetCurrentSound(handle, out sound.handle);
		}

		public RESULT getIndex(out int index)
		{
			return FMOD5_Channel_GetIndex(handle, out index);
		}

		public RESULT getSystemObject(out System system)
		{
			return FMOD5_Channel_GetSystemObject(handle, out system.handle);
		}

		public RESULT stop()
		{
			return FMOD5_Channel_Stop(handle);
		}

		public RESULT setPaused(bool paused)
		{
			return FMOD5_Channel_SetPaused(handle, paused);
		}

		public RESULT getPaused(out bool paused)
		{
			return FMOD5_Channel_GetPaused(handle, out paused);
		}

		public RESULT setVolume(float volume)
		{
			return FMOD5_Channel_SetVolume(handle, volume);
		}

		public RESULT getVolume(out float volume)
		{
			return FMOD5_Channel_GetVolume(handle, out volume);
		}

		public RESULT setVolumeRamp(bool ramp)
		{
			return FMOD5_Channel_SetVolumeRamp(handle, ramp);
		}

		public RESULT getVolumeRamp(out bool ramp)
		{
			return FMOD5_Channel_GetVolumeRamp(handle, out ramp);
		}

		public RESULT getAudibility(out float audibility)
		{
			return FMOD5_Channel_GetAudibility(handle, out audibility);
		}

		public RESULT setPitch(float pitch)
		{
			return FMOD5_Channel_SetPitch(handle, pitch);
		}

		public RESULT getPitch(out float pitch)
		{
			return FMOD5_Channel_GetPitch(handle, out pitch);
		}

		public RESULT setMute(bool mute)
		{
			return FMOD5_Channel_SetMute(handle, mute);
		}

		public RESULT getMute(out bool mute)
		{
			return FMOD5_Channel_GetMute(handle, out mute);
		}

		public RESULT setReverbProperties(int instance, float wet)
		{
			return FMOD5_Channel_SetReverbProperties(handle, instance, wet);
		}

		public RESULT getReverbProperties(int instance, out float wet)
		{
			return FMOD5_Channel_GetReverbProperties(handle, instance, out wet);
		}

		public RESULT setLowPassGain(float gain)
		{
			return FMOD5_Channel_SetLowPassGain(handle, gain);
		}

		public RESULT getLowPassGain(out float gain)
		{
			return FMOD5_Channel_GetLowPassGain(handle, out gain);
		}

		public RESULT setMode(MODE mode)
		{
			return FMOD5_Channel_SetMode(handle, mode);
		}

		public RESULT getMode(out MODE mode)
		{
			return FMOD5_Channel_GetMode(handle, out mode);
		}

		public RESULT setCallback(CHANNELCONTROL_CALLBACK callback)
		{
			return FMOD5_Channel_SetCallback(handle, callback);
		}

		public RESULT isPlaying(out bool isplaying)
		{
			return FMOD5_Channel_IsPlaying(handle, out isplaying);
		}

		public RESULT setPan(float pan)
		{
			return FMOD5_Channel_SetPan(handle, pan);
		}

		public RESULT setMixLevelsOutput(float frontleft, float frontright, float center, float lfe, float surroundleft, float surroundright, float backleft, float backright)
		{
			return FMOD5_Channel_SetMixLevelsOutput(handle, frontleft, frontright, center, lfe, surroundleft, surroundright, backleft, backright);
		}

		public RESULT setMixLevelsInput(float[] levels, int numlevels)
		{
			return FMOD5_Channel_SetMixLevelsInput(handle, levels, numlevels);
		}

		public RESULT setMixMatrix(float[] matrix, int outchannels, int inchannels, int inchannel_hop = 0)
		{
			return FMOD5_Channel_SetMixMatrix(handle, matrix, outchannels, inchannels, inchannel_hop);
		}

		public RESULT getMixMatrix(float[] matrix, out int outchannels, out int inchannels, int inchannel_hop = 0)
		{
			return FMOD5_Channel_GetMixMatrix(handle, matrix, out outchannels, out inchannels, inchannel_hop);
		}

		public RESULT getDSPClock(out ulong dspclock, out ulong parentclock)
		{
			return FMOD5_Channel_GetDSPClock(handle, out dspclock, out parentclock);
		}

		public RESULT setDelay(ulong dspclock_start, ulong dspclock_end, bool stopchannels = true)
		{
			return FMOD5_Channel_SetDelay(handle, dspclock_start, dspclock_end, stopchannels);
		}

		public RESULT getDelay(out ulong dspclock_start, out ulong dspclock_end)
		{
			return FMOD5_Channel_GetDelay(handle, out dspclock_start, out dspclock_end, IntPtr.Zero);
		}

		public RESULT getDelay(out ulong dspclock_start, out ulong dspclock_end, out bool stopchannels)
		{
			return FMOD5_Channel_GetDelay(handle, out dspclock_start, out dspclock_end, out stopchannels);
		}

		public RESULT addFadePoint(ulong dspclock, float volume)
		{
			return FMOD5_Channel_AddFadePoint(handle, dspclock, volume);
		}

		public RESULT setFadePointRamp(ulong dspclock, float volume)
		{
			return FMOD5_Channel_SetFadePointRamp(handle, dspclock, volume);
		}

		public RESULT removeFadePoints(ulong dspclock_start, ulong dspclock_end)
		{
			return FMOD5_Channel_RemoveFadePoints(handle, dspclock_start, dspclock_end);
		}

		public RESULT getFadePoints(ref uint numpoints, ulong[] point_dspclock, float[] point_volume)
		{
			return FMOD5_Channel_GetFadePoints(handle, ref numpoints, point_dspclock, point_volume);
		}

		public RESULT getDSP(int index, out DSP dsp)
		{
			return FMOD5_Channel_GetDSP(handle, index, out dsp.handle);
		}

		public RESULT addDSP(int index, DSP dsp)
		{
			return FMOD5_Channel_AddDSP(handle, index, dsp.handle);
		}

		public RESULT removeDSP(DSP dsp)
		{
			return FMOD5_Channel_RemoveDSP(handle, dsp.handle);
		}

		public RESULT getNumDSPs(out int numdsps)
		{
			return FMOD5_Channel_GetNumDSPs(handle, out numdsps);
		}

		public RESULT setDSPIndex(DSP dsp, int index)
		{
			return FMOD5_Channel_SetDSPIndex(handle, dsp.handle, index);
		}

		public RESULT getDSPIndex(DSP dsp, out int index)
		{
			return FMOD5_Channel_GetDSPIndex(handle, dsp.handle, out index);
		}

		public RESULT set3DAttributes(ref VECTOR pos, ref VECTOR vel)
		{
			return FMOD5_Channel_Set3DAttributes(handle, ref pos, ref vel);
		}

		public RESULT get3DAttributes(out VECTOR pos, out VECTOR vel)
		{
			return FMOD5_Channel_Get3DAttributes(handle, out pos, out vel);
		}

		public RESULT set3DMinMaxDistance(float mindistance, float maxdistance)
		{
			return FMOD5_Channel_Set3DMinMaxDistance(handle, mindistance, maxdistance);
		}

		public RESULT get3DMinMaxDistance(out float mindistance, out float maxdistance)
		{
			return FMOD5_Channel_Get3DMinMaxDistance(handle, out mindistance, out maxdistance);
		}

		public RESULT set3DConeSettings(float insideconeangle, float outsideconeangle, float outsidevolume)
		{
			return FMOD5_Channel_Set3DConeSettings(handle, insideconeangle, outsideconeangle, outsidevolume);
		}

		public RESULT get3DConeSettings(out float insideconeangle, out float outsideconeangle, out float outsidevolume)
		{
			return FMOD5_Channel_Get3DConeSettings(handle, out insideconeangle, out outsideconeangle, out outsidevolume);
		}

		public RESULT set3DConeOrientation(ref VECTOR orientation)
		{
			return FMOD5_Channel_Set3DConeOrientation(handle, ref orientation);
		}

		public RESULT get3DConeOrientation(out VECTOR orientation)
		{
			return FMOD5_Channel_Get3DConeOrientation(handle, out orientation);
		}

		public RESULT set3DCustomRolloff(ref VECTOR points, int numpoints)
		{
			return FMOD5_Channel_Set3DCustomRolloff(handle, ref points, numpoints);
		}

		public RESULT get3DCustomRolloff(out IntPtr points, out int numpoints)
		{
			return FMOD5_Channel_Get3DCustomRolloff(handle, out points, out numpoints);
		}

		public RESULT set3DOcclusion(float directocclusion, float reverbocclusion)
		{
			return FMOD5_Channel_Set3DOcclusion(handle, directocclusion, reverbocclusion);
		}

		public RESULT get3DOcclusion(out float directocclusion, out float reverbocclusion)
		{
			return FMOD5_Channel_Get3DOcclusion(handle, out directocclusion, out reverbocclusion);
		}

		public RESULT set3DSpread(float angle)
		{
			return FMOD5_Channel_Set3DSpread(handle, angle);
		}

		public RESULT get3DSpread(out float angle)
		{
			return FMOD5_Channel_Get3DSpread(handle, out angle);
		}

		public RESULT set3DLevel(float level)
		{
			return FMOD5_Channel_Set3DLevel(handle, level);
		}

		public RESULT get3DLevel(out float level)
		{
			return FMOD5_Channel_Get3DLevel(handle, out level);
		}

		public RESULT set3DDopplerLevel(float level)
		{
			return FMOD5_Channel_Set3DDopplerLevel(handle, level);
		}

		public RESULT get3DDopplerLevel(out float level)
		{
			return FMOD5_Channel_Get3DDopplerLevel(handle, out level);
		}

		public RESULT set3DDistanceFilter(bool custom, float customLevel, float centerFreq)
		{
			return FMOD5_Channel_Set3DDistanceFilter(handle, custom, customLevel, centerFreq);
		}

		public RESULT get3DDistanceFilter(out bool custom, out float customLevel, out float centerFreq)
		{
			return FMOD5_Channel_Get3DDistanceFilter(handle, out custom, out customLevel, out centerFreq);
		}

		public RESULT setUserData(IntPtr userdata)
		{
			return FMOD5_Channel_SetUserData(handle, userdata);
		}

		public RESULT getUserData(out IntPtr userdata)
		{
			return FMOD5_Channel_GetUserData(handle, out userdata);
		}

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_SetFrequency(IntPtr channel, float frequency);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_GetFrequency(IntPtr channel, out float frequency);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_SetPriority(IntPtr channel, int priority);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_GetPriority(IntPtr channel, out int priority);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_SetPosition(IntPtr channel, uint position, TIMEUNIT postype);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_GetPosition(IntPtr channel, out uint position, TIMEUNIT postype);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_SetChannelGroup(IntPtr channel, IntPtr channelgroup);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_GetChannelGroup(IntPtr channel, out IntPtr channelgroup);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_SetLoopCount(IntPtr channel, int loopcount);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_GetLoopCount(IntPtr channel, out int loopcount);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_SetLoopPoints(IntPtr channel, uint loopstart, TIMEUNIT loopstarttype, uint loopend, TIMEUNIT loopendtype);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_GetLoopPoints(IntPtr channel, out uint loopstart, TIMEUNIT loopstarttype, out uint loopend, TIMEUNIT loopendtype);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_IsVirtual(IntPtr channel, out bool isvirtual);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_GetCurrentSound(IntPtr channel, out IntPtr sound);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_GetIndex(IntPtr channel, out int index);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_GetSystemObject(IntPtr channel, out IntPtr system);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_Stop(IntPtr channel);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_SetPaused(IntPtr channel, bool paused);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_GetPaused(IntPtr channel, out bool paused);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_SetVolume(IntPtr channel, float volume);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_GetVolume(IntPtr channel, out float volume);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_SetVolumeRamp(IntPtr channel, bool ramp);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_GetVolumeRamp(IntPtr channel, out bool ramp);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_GetAudibility(IntPtr channel, out float audibility);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_SetPitch(IntPtr channel, float pitch);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_GetPitch(IntPtr channel, out float pitch);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_SetMute(IntPtr channel, bool mute);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_GetMute(IntPtr channel, out bool mute);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_SetReverbProperties(IntPtr channel, int instance, float wet);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_GetReverbProperties(IntPtr channel, int instance, out float wet);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_SetLowPassGain(IntPtr channel, float gain);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_GetLowPassGain(IntPtr channel, out float gain);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_SetMode(IntPtr channel, MODE mode);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_GetMode(IntPtr channel, out MODE mode);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_SetCallback(IntPtr channel, CHANNELCONTROL_CALLBACK callback);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_IsPlaying(IntPtr channel, out bool isplaying);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_SetPan(IntPtr channel, float pan);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_SetMixLevelsOutput(IntPtr channel, float frontleft, float frontright, float center, float lfe, float surroundleft, float surroundright, float backleft, float backright);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_SetMixLevelsInput(IntPtr channel, float[] levels, int numlevels);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_SetMixMatrix(IntPtr channel, float[] matrix, int outchannels, int inchannels, int inchannel_hop);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_GetMixMatrix(IntPtr channel, float[] matrix, out int outchannels, out int inchannels, int inchannel_hop);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_GetDSPClock(IntPtr channel, out ulong dspclock, out ulong parentclock);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_SetDelay(IntPtr channel, ulong dspclock_start, ulong dspclock_end, bool stopchannels);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_GetDelay(IntPtr channel, out ulong dspclock_start, out ulong dspclock_end, IntPtr zero);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_GetDelay(IntPtr channel, out ulong dspclock_start, out ulong dspclock_end, out bool stopchannels);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_AddFadePoint(IntPtr channel, ulong dspclock, float volume);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_SetFadePointRamp(IntPtr channel, ulong dspclock, float volume);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_RemoveFadePoints(IntPtr channel, ulong dspclock_start, ulong dspclock_end);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_GetFadePoints(IntPtr channel, ref uint numpoints, ulong[] point_dspclock, float[] point_volume);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_GetDSP(IntPtr channel, int index, out IntPtr dsp);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_AddDSP(IntPtr channel, int index, IntPtr dsp);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_RemoveDSP(IntPtr channel, IntPtr dsp);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_GetNumDSPs(IntPtr channel, out int numdsps);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_SetDSPIndex(IntPtr channel, IntPtr dsp, int index);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_GetDSPIndex(IntPtr channel, IntPtr dsp, out int index);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_Set3DAttributes(IntPtr channel, ref VECTOR pos, ref VECTOR vel);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_Get3DAttributes(IntPtr channel, out VECTOR pos, out VECTOR vel);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_Set3DMinMaxDistance(IntPtr channel, float mindistance, float maxdistance);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_Get3DMinMaxDistance(IntPtr channel, out float mindistance, out float maxdistance);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_Set3DConeSettings(IntPtr channel, float insideconeangle, float outsideconeangle, float outsidevolume);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_Get3DConeSettings(IntPtr channel, out float insideconeangle, out float outsideconeangle, out float outsidevolume);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_Set3DConeOrientation(IntPtr channel, ref VECTOR orientation);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_Get3DConeOrientation(IntPtr channel, out VECTOR orientation);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_Set3DCustomRolloff(IntPtr channel, ref VECTOR points, int numpoints);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_Get3DCustomRolloff(IntPtr channel, out IntPtr points, out int numpoints);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_Set3DOcclusion(IntPtr channel, float directocclusion, float reverbocclusion);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_Get3DOcclusion(IntPtr channel, out float directocclusion, out float reverbocclusion);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_Set3DSpread(IntPtr channel, float angle);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_Get3DSpread(IntPtr channel, out float angle);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_Set3DLevel(IntPtr channel, float level);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_Get3DLevel(IntPtr channel, out float level);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_Set3DDopplerLevel(IntPtr channel, float level);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_Get3DDopplerLevel(IntPtr channel, out float level);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_Set3DDistanceFilter(IntPtr channel, bool custom, float customLevel, float centerFreq);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_Get3DDistanceFilter(IntPtr channel, out bool custom, out float customLevel, out float centerFreq);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_SetUserData(IntPtr channel, IntPtr userdata);

		[DllImport("fmod")]
		private static extern RESULT FMOD5_Channel_GetUserData(IntPtr channel, out IntPtr userdata);

		public Channel(IntPtr ptr)
		{
			handle = ptr;
		}

		public bool hasHandle()
		{
			return handle != IntPtr.Zero;
		}

		public void clearHandle()
		{
			handle = IntPtr.Zero;
		}
	}
	public struct ChannelGroup : IChannelControl
	{
		public IntPtr handle;

		public RESULT release()
		{
			return FMOD5_ChannelGroup_Release(handle);
		}

		public RESULT addGroup(ChannelGroup group, bool propagatedspclock = true)
		{
			return FMOD5_ChannelGroup_AddGroup(handle, group.handle, propagatedspclock, IntPtr.Zero);
		}

		public RESULT addGroup(ChannelGroup group, bool propagatedspclock, out DSPConnection connection)
		{
			return FMOD5_ChannelGroup_AddGroup(handle, group.handle, propagatedspclock, out connection.handle);
		}

		public RESULT getNumGroups(out int numgroups)
		{
			return FMOD5_ChannelGroup_GetNumGroups(handle, out numgroups);
		}

		public RESULT getGroup(int index, out ChannelGroup group)
		{
			return FMOD5_ChannelGroup_GetGroup(handle, index, out group.handle);
		}

		public RESULT getParentGroup(out ChannelGroup group)
		{
			return FMOD5_ChannelGroup_GetParentGroup(handle, out group.handle);
		}

		public RESULT getName(out string name, int namelen)
		{
			IntPtr intPtr = Marshal.AllocHGlobal(namelen);
			RESULT result = FMOD5_ChannelGroup_GetName(handle, intPtr, namelen);
			using (StringHelper.ThreadSafeEncoding threadSafeEncoding = StringHelper.GetFreeHelper())
			{
				name = threadSafeEncoding.stringFromNative(intPtr);
			}
			Marshal.FreeHGlobal(intPtr);
			return result;
		}

		public RESULT getNumChannels(out int numchannels)
		{
			return FMOD5_ChannelGroup_GetNumChannels(handle, out numchannels);
		}

		public RESULT getChannel(int index, out Channel channel)
		{
			return FMOD5_ChannelGroup_GetChannel(handle, index, out channel.handle);
		}

		public RESULT getSystemObject(out System system)
		{
			return FMOD5_ChannelGroup_GetSystemObject(handle, out system.handle);
		}

		public RESULT stop()
		{
			return FMOD5_ChannelGroup_Stop(handle);
		}

		public RESULT setPaused(bool paused)
		{
			return FMOD5_ChannelGroup_SetPaused(handle, paused);
		}

		public RESULT getPaused(out bool paused)
		{
			return FMOD5_ChannelGroup_GetPaused(handle, out paused);
		}

		public RESULT setVolume(float volume)
		{
			return FMOD5_ChannelGroup_SetVolume(handle, volume);
		}

		public RESULT getVolume(out float volume)
		{
			return FMOD5_ChannelGroup_GetVolume(handle, out volume);
		}

		public RESULT setVolumeRamp(bool ramp)
		{
			return FMOD5_ChannelGroup_SetVolumeRamp(handle, ramp);
		}

		public RESULT getVolumeRamp(out bool ramp)
		{
			return FMOD5_ChannelGroup_GetVolumeRamp(handle, out ramp);
		}

		public RESULT getAudibility(out float audibility)
		{
			return FMOD5_ChannelGroup_GetAudibility(handle, out audibility);
		}

		public RESULT setPitch(float pitch)
		{
			return FMOD5_ChannelGroup_SetPitch(handle, pitch);
		}

		public RESULT getPitch(out float pitch)
		{
			return FMOD5_ChannelGroup_GetPitch(handle, out pitch);
		}

		public RESULT setMute(bool mute)
		{
			return FMOD5_ChannelGroup_SetMute(handle, mute);
		}

		public RESULT getMute(out bool mute)
		{
			return FMOD5_ChannelGroup_GetMute(handle, out mute);
		}

		public RESULT setReverbProperties(int instance, float wet)
		{
			return FMOD5_ChannelGroup_SetReverbProperties(handle, instance, wet);
		}

		public RESULT getReverbProperties(int instance, out float wet)
		{
			return FMOD5_ChannelGroup_GetReverbProperties(handle, instance, out wet);
		}

		public RESULT setLowPassGain(float gain)
		{
			return FMOD5_ChannelGroup_SetLowPassGain(handle, gain);
		}

		public RESULT getLowPassGain(out float gain)
		{
			return FMOD5_ChannelGroup_GetLowPassGain(handle, out gain);
		}

		public RESULT setMode(MODE mode)
		{
			return FMOD5_ChannelGroup_SetMode(handle, mode);
		}

		public RESULT getMode(out MODE mode)
		{
			return FMOD5_ChannelGroup_GetMode(handle, out mode);
		}

		public RESULT setCallback(CHANNELCONTROL_CALLBACK callback)
		{
			return FMOD5_ChannelGroup_SetCallback(handle, callback);
		}

		public RESULT isPlaying(out bool isplaying)
		{
			return FMOD5_ChannelGroup_IsPlaying(handle, out isplaying);
		}

		public RESULT setPan(float pan)
		{
			return FMOD5_ChannelGroup_SetPan(handle, pan);
		}

		public RESULT setMixLevelsOutput(float frontleft, float frontright, float center, float lfe, float surroundleft, float surr