using System;
using System.Runtime.InteropServices;

namespace UMP.Wrappers
{
    internal class WrapperStandalone : IWrapperNative, IWrapperPlayer, IWrapperSpu, IWrapperAudio
    {
        private IntPtr _libVLCHandler = IntPtr.Zero;
        private IntPtr _libUMPHandler = IntPtr.Zero;

        private int _nativeIndex;

        private delegate void ManageLogCallback(string msg);
        private ManageLogCallback _manageLogCallback;

        #region Native Imports
        [DllImport(UMPSettings.ASSET_NAME)]
        private static extern int UMPNativeInit();

        [DllImport(UMPSettings.ASSET_NAME)]
        private static extern void UMPNativeUpdateIndex(int index);

        [DllImport(UMPSettings.ASSET_NAME)]
        private static extern void UMPNativeSetTexture(int index, IntPtr texture);

        [DllImport(UMPSettings.ASSET_NAME)]
        private static extern void UMPNativeSetPixelsBuffer(int index, IntPtr buffer, int width, int height);

        [DllImport(UMPSettings.ASSET_NAME)]
        private static extern IntPtr UMPNativeGetPixelsBuffer(int index);

        [DllImport(UMPSettings.ASSET_NAME)]
        private static extern void UMPNativePixelsBufferRelease(int index);

        [DllImport(UMPSettings.ASSET_NAME)]
        private static extern IntPtr UMPNativeGetLogMessage(int index);

        [DllImport(UMPSettings.ASSET_NAME)]
        private static extern int UMPNativeGetLogLevel(int index);

        [DllImport(UMPSettings.ASSET_NAME)]
        private static extern int UMPNativeGetState(int index);

        [DllImport(UMPSettings.ASSET_NAME)]
        private static extern float UMPNativeGetStateFloatValue(int index);

        [DllImport(UMPSettings.ASSET_NAME)]
        private static extern long UMPNativeGetStateLongValue(int index);

        [DllImport(UMPSettings.ASSET_NAME)]
        private static extern IntPtr UMPNativeGetStateStringValue(int index);

        [DllImport(UMPSettings.ASSET_NAME)]
        private static extern int UMPNativeSetPixelsVerticalFlip(int index, bool flip);

        [DllImport(UMPSettings.ASSET_NAME)]
        internal static extern void UMPNativeSetAudioParams(int index, int numChannels, int sampleRate);

        [DllImport(UMPSettings.ASSET_NAME)]
        internal static extern IntPtr UMPNativeGetAudioParams(int index, char separator);

        [DllImport(UMPSettings.ASSET_NAME)]
        internal static extern int UMPNativeGetAudioSamples(int index, IntPtr decodedSamples, int samplesLength, AudioOutput.AudioChannels audioChannel);

        [DllImport(UMPSettings.ASSET_NAME)]
        internal static extern bool UMPNativeClearAudioSamples(int index, int samplesLength);

        [DllImport(UMPSettings.ASSET_NAME)]
        internal static extern void UMPNativeDirectRender(int index);

        [DllImport(UMPSettings.ASSET_NAME)]
        private static extern IntPtr UMPNativeGetUnityRenderCallback();

        [DllImport(UMPSettings.ASSET_NAME)]
        private static extern IntPtr UMPNativeGetVideoLockCallback();

        [DllImport(UMPSettings.ASSET_NAME)]
        private static extern IntPtr UMPNativeGetVideoDisplayCallback();

        [DllImport(UMPSettings.ASSET_NAME)]
        private static extern IntPtr UMPNativeGetVideoFormatCallback();

        [DllImport(UMPSettings.ASSET_NAME)]
        private static extern IntPtr UMPNativeGetVideoCleanupCallback();

        [DllImport(UMPSettings.ASSET_NAME)]
        private static extern IntPtr UMPNativeGetAudioSetupCallback();

        [DllImport(UMPSettings.ASSET_NAME)]
        private static extern IntPtr UMPNativeGetAudioPlayCallback();

        [DllImport(UMPSettings.ASSET_NAME)]
        private static extern IntPtr UMPNativeMediaPlayerEventCallback();

        [DllImport(UMPSettings.ASSET_NAME)]
        private static extern void UMPNativeSetBufferSizeCallback(int index, IntPtr callback);

        [DllImport(UMPSettings.ASSET_NAME)]
        private static extern IntPtr UMPNativeGetLogMessageCallback();

        [DllImport(UMPSettings.ASSET_NAME)]
        private static extern void UMPNativeSetUnityLogMessageCallback(IntPtr callback);

        [DllImport(UMPSettings.ASSET_NAME)]
        private static extern void UMPNativeUpdateFramesCounter(int index, int counter);

        [DllImport(UMPSettings.ASSET_NAME)]
        private static extern int UMPNativeGetFramesCounter(int index);

        [NativeFunction("UMPNativeInit")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate int UMPNativeInitDel();

        [NativeFunction("UMPNativeUpdateIndex")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate void UMPNativeUpdateIndexDel(int index);

        [NativeFunction("UMPNativeSetTexture")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate void UMPNativeSetTextureDel(int index, IntPtr texture);

        [NativeFunction("UMPNativeSetPixelsBuffer")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate void UMPNativeSetPixelsBufferDel(int index, IntPtr buffer, int width, int height);

        [NativeFunction("UMPNativeGetPixeslBuffer")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate IntPtr UMPNativeGetPixelsBufferDel(int index);

        [NativeFunction("UMPNativePixelsBufferRelease")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate void UMPNativePixelsBufferReleaseDel(int index);

        [NativeFunction("UMPNativeGetLogMessage")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate IntPtr UMPNativeGetLogMessageDel(int index);

        [NativeFunction("UMPNativeGetLogLevel")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate int UMPNativeGetLogLevelDel(int index);

        [NativeFunction("UMPNativeGetState")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate int UMPNativeGetStateDel(int index);

        [NativeFunction("UMPNativeGetStateFloatValue")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate float UMPNativeGetStateFloatValueDel(int index);

        [NativeFunction("UMPNativeGetStateLongValue")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate long UMPNativeGetStateLongValueDel(int index);

        [NativeFunction("UMPNativeGetStateStringValue")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate IntPtr UMPNativeGetStateStringValueDel(int index);

        [NativeFunction("UMPNativeSetPixelsVerticalFlip")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate void UMPNativeSetPixelsVerticalFlipDel(int index, bool flip);

        [NativeFunction("UMPNativeSetAudioParams")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate void UMPNativeSetAudioParamsDel(int index, int numChannels, int sampleRate);

        [NativeFunction("UMPNativeGetAudioParams")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate IntPtr UMPNativeGetAudioParamsDel(int index, char separator);

        [NativeFunction("UMPNativeGetAudioChannels")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate int UMPNativeGetAudioChannelsDel(int index);

        [NativeFunction("UMPNativeGetAudioSamples")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate int UMPNativeGetAudioSamplesDel(int index, IntPtr decodedSamples, int samplesLength, AudioOutput.AudioChannels audioChannel);

        [NativeFunction("UMPNativeClearAudioSamples")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate bool UMPNativeClearAudioSamplesDel(int index, int samplesLength);

        [NativeFunction("UMPNativeDirectRender")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate void UMPNativeDirectRenderDel(int index);

        [NativeFunction("UMPNativeGetUnityRenderCallback")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate IntPtr UMPNativeGetUnityRenderCallbackDel();

        [NativeFunction("UMPNativeGetVideoLockCallback")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate IntPtr UMPNativeGetVideoLockCallbackDel();

        [NativeFunction("UMPNativeGetVideoDisplayCallback")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate IntPtr UMPNativeGetVideoDisplayCallbackDel();

        [NativeFunction("UMPNativeGetVideoFormatCallback")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate IntPtr UMPNativeGetVideoFormatCallbackDel();

        [NativeFunction("UMPNativeGetVideoCleanupCallback")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate IntPtr UMPNativeGetVideoCleanupCallbackDel();

        [NativeFunction("UMPNativeGetAudioSetupCallback")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate IntPtr UMPNativeGetAudioSetupCallbackDel();

        [NativeFunction("UMPNativeGetAudioPlayCallback")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate IntPtr UMPNativeGetAudioPlayCallbackDel();

        [NativeFunction("UMPNativeMediaPlayerEventCallback")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate IntPtr UMPNativeMediaPlayerEventCallbackDel();

        [NativeFunction("UMPNativeSetBufferSizeCallback")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate void UMPNativeSetBufferSizeCallbackDel(int index, IntPtr callback);

        [NativeFunction("UMPNativeGetLogMessageCallback")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate IntPtr UMPNativeGetLogMessageCallbackDel();

        [NativeFunction("UMPNativeSetUnityLogMessageCallback")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate void UMPNativeSetUnityLogMessageCallbackDel(IntPtr callback);

        [NativeFunction("UMPNativeUpdateFramesCounter")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate void UMPNativeUpdateFramesCounterCallbackDel(int index, int counter);

        [NativeFunction("UMPNativeGetFramesCounter")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate int UMPNativeGetFramesCounterCallbackDel(int index);
        #endregion

        #region LibVLC Imports
        /// <summary>
        /// Set current crop filter geometry.
        /// </summary>
        [NativeFunction("libvlc_video_set_aspect_ratio")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate void SetVideoAspectRatio(IntPtr playerObject, string cropGeometry);

        /// <summary>
        /// Unset libvlc log instance.
        /// </summary>
        [NativeFunction("libvlc_log_unset")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate void LogUnset(IntPtr instance);

        /// <summary>
        /// Unset libvlc log instance.
        /// </summary>
        [NativeFunction("libvlc_log_set")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate void LogSet(IntPtr instance, IntPtr callback, IntPtr data);

        /// <summary>
        /// Create and initialize a libvlc instance.
        /// </summary>
        /// <returns>Return the libvlc instance or NULL in case of error.</returns>
        [NativeFunction("libvlc_new")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate IntPtr CreateNewInstance(int argc, string[] argv);

        /// <summary>
        /// Destroy libvlc instance.
        /// </summary>
        [NativeFunction("libvlc_release")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate void ReleaseInstance(IntPtr instance);

        /// <summary>
        /// Frees an heap allocation returned by a LibVLC function.
        /// </summary>
        /// <returns>Return the libvlc instance or NULL in case of error.</returns>
        [NativeFunction("libvlc_free")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate void Free(IntPtr ptr);

        /// <summary>
        /// CCallback function notification.
        /// </summary>
        [NativeFunction("libvlc_callback_t")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate void EventCallback(IntPtr args);

        /// <summary>
        /// Register for an event notification.
        /// </summary>
        /// <param name="eventManagerInstance">Event manager to which you want to attach to.</param>
        /// <param name="eventType">The desired event to which we want to listen.</param>
        /// <param name="callback">The function to call when i_event_type occurs.</param>
        /// <param name="userData">User provided data to carry with the event.</param>
        /// <returns>Return 0 on success, ENOMEM on error.</returns>
        [NativeFunction("libvlc_event_attach")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        public delegate int AttachEvent(IntPtr eventManagerInstance, EventTypes eventType, IntPtr callback, IntPtr userData);

        /// <summary>
        /// Unregister an event notification.
        /// </summary>
        /// <param name="eventManagerInstance">Event manager to which you want to attach to.</param>
        /// <param name="eventType">The desired event to which we want to listen.</param>
        /// <param name="callback">The function to call when i_event_type occurs.</param>
        /// <param name="userData">User provided data to carry with the event.</param>
        /// <returns>Return 0 on success, ENOMEM on error.</returns>
        [NativeFunction("libvlc_event_detach")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        public delegate int DetachEvent(IntPtr eventManagerInstance, EventTypes eventType, IntPtr callback, IntPtr userData);

        /// <summary>
        /// Create a media with a certain given media resource location, for instance a valid URL.
        /// </summary>
        /// <returns>Return the newly created media or NULL on error.</returns>
        [NativeFunction("libvlc_media_new_location")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate IntPtr CreateNewMediaFromLocation(IntPtr instance, [MarshalAs(UnmanagedType.LPStr)] string path);

        /// <summary>
        /// Create a media for a certain file path.
        /// </summary>
        /// <returns>Return the newly created media or NULL on error.</returns>
        [NativeFunction("libvlc_media_new_path")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate IntPtr CreateNewMediaFromPath(IntPtr instance, [MarshalAs(UnmanagedType.LPStr)] string path);

        /// <summary>
        /// Add an option to the media.
        /// </summary>
        [NativeFunction("libvlc_media_add_option")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate void AddOptionToMedia(IntPtr mediaInstance, [MarshalAs(UnmanagedType.LPStr)] string option);

        /// <summary>
        /// It will release the media descriptor object. It will send out an libvlc_MediaFreed event to all listeners. If the media descriptor object has been released it should not be used again.
        /// </summary>
        [NativeFunction("libvlc_media_release")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate void ReleaseMedia(IntPtr mediaInstance);

        /// <summary>
        /// Get the media resource locator (mrl) from a media descriptor object.
        /// </summary>
        [NativeFunction("libvlc_media_get_mrl")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate IntPtr GetMediaMrl(IntPtr mediaInstance);

        /// <summary>
        /// Get Parsed status for media descriptor object.
        /// </summary>
        [NativeFunction("libvlc_media_get_parsed_status")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate ParsedStatus GetMediaParsedStatus(IntPtr mediaInstance);

        /// <summary>
        /// Read a meta of the media.
        /// </summary>
        [NativeFunction("libvlc_media_get_meta")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate IntPtr GetMediaMetadata(IntPtr mediaInstance, MediaMetadatas meta);

        /// <summary>
        /// Get the current statistics about the media
        /// </summary>
        /// <param name="mediaInstance">Media descriptor object</param>
        /// <param name="statsInformationsPointer">Structure that contain
        /// the statistics about the media 
        /// (this structure must be allocated by the caller)</param>
        /// <returns></returns>
        [NativeFunction("libvlc_media_get_stats")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate int GetMediaStats(IntPtr mediaInstance, out MediaStats statsInformationsPointer);

        /// <summary>
        /// Parse a media meta data and tracks information. 
        /// </summary>
        [NativeFunction("libvlc_media_parse")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate void ParseMedia(IntPtr mediaInstance);

        /// <summary>
        /// Parse a media meta data and tracks information async. 
        /// </summary>
        [NativeFunction("libvlc_media_parse_async")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate void ParseMediaAsync(IntPtr mediaInstance);

        /// <summary>
        /// Get Parsed status for media descriptor object.
        /// </summary>
        [NativeFunction("libvlc_media_is_parsed")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate int IsParsedMedia(IntPtr mediaInstance);

        /// <summary>
        /// Get media descriptor's elementary streams description.
        /// </summary>
        [NativeFunction("libvlc_media_get_tracks_info")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate int GetMediaTracksInformations(IntPtr mediaInstance, out IntPtr tracksInformationsPointer);

        /// <summary>
        /// Create an empty Media Player object.
        /// </summary>
        /// <returns>Return a new media player object, or NULL on error.</returns>
        [NativeFunction("libvlc_media_player_new")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate IntPtr CreateMediaPlayer(IntPtr instance);

        /// <summary>
        /// It will release the media player object. If the media player object has been released, then it should not be used again.
        /// </summary>
        [NativeFunction("libvlc_media_player_release")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate void ReleaseMediaPlayer(IntPtr playerObject);

        /// <summary>
        /// Set the media that will be used by the media_player. If any, previous media will be released.
        /// </summary>
        /// <returns>Return a new media player object, or NULL on error.</returns>
        [NativeFunction("libvlc_media_player_set_media")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate void SetMediaToMediaPlayer(IntPtr playerObject, IntPtr mediaInstance);

        /// <summary>
        /// Get the Event Manager from which the media player send event.
        /// </summary>
        /// <returns>Return the event manager associated with media player.</returns>
        [NativeFunction("libvlc_media_player_event_manager")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate IntPtr GetMediaPlayerEventManager(IntPtr playerObject);

        /// <summary>
        /// Check if media player is playing.
        /// </summary>
        [NativeFunction("libvlc_media_player_is_playing")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate int IsPlaying(IntPtr playerObject);

        /// <summary>
        /// Play.
        /// </summary>
        /// <returns>Return 0 if playback started (and was already started), or -1 on error.</returns>
        [NativeFunction("libvlc_media_player_play")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate int Play(IntPtr playerObject);

        /// <summary>
        /// Toggle pause (no effect if there is no media).
        /// </summary>
        [NativeFunction("libvlc_media_player_pause")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate void Pause(IntPtr playerObject);

        /// <summary>
        /// Stop.
        /// </summary>
        [NativeFunction("libvlc_media_player_stop")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate void Stop(IntPtr playerObject);

        /// <summary>
        /// Set video callbacks.
        /// </summary>
        [NativeFunction("libvlc_video_set_callbacks")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate void SetVideoCallbacks(IntPtr playerObject, IntPtr @lock, IntPtr unlock, IntPtr display, IntPtr opaque);

        /// <summary>
        /// Set video format.
        /// </summary>
        [NativeFunction("libvlc_video_set_format")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate void SetVideoFormat(IntPtr playerObject, [MarshalAs(UnmanagedType.LPStr)] string chroma, uint width, uint height, uint pitch);

        /// <summary>
        /// Set video format callbacks.
        /// </summary>
        [NativeFunction("libvlc_video_set_format_callbacks")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate void SetVideoFormatCallbacks(IntPtr playerObject, IntPtr setup, IntPtr cleanup);

        /// <summary>
        /// Get length of movie playing
        /// </summary>
        /// <returns>Get the requested movie play rate.</returns>
        [NativeFunction("libvlc_media_player_get_length")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate long GetLength(IntPtr playerObject);

        /// <summary>
        /// Get Rate at which movie is playing.
        /// </summary>
        /// <returns>Get the requested movie play rate.</returns>
        [NativeFunction("libvlc_media_player_get_time")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate long GetTime(IntPtr playerObject);

        /// <summary>
        /// Get time at which movie is playing.
        /// </summary>
        /// <returns>Get the requested movie play time.</returns>
        [NativeFunction("libvlc_media_player_set_time")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate void SetTime(IntPtr playerObject, long time);

        /// <summary>
        /// Get media position.
        /// </summary>
        [NativeFunction("libvlc_media_player_get_position")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate float GetMediaPosition(IntPtr playerObject);

        /// <summary>
        /// Get media position.
        /// </summary>
        [NativeFunction("libvlc_media_player_set_position")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]

        private delegate void SetMediaPosition(IntPtr playerObject, float position);

        /// <summary>
        /// Is the player able to play.
        /// </summary>
        [NativeFunction("libvlc_media_player_will_play")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate int CouldPlay(IntPtr playerObject);

        /// <summary>
        /// Get the requested media play rate.
        /// </summary>
        [NativeFunction("libvlc_media_player_get_rate")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate float GetRate(IntPtr playerObject);

        /// <summary>
        /// Set the requested media play rate.
        /// </summary>
        [NativeFunction("libvlc_media_player_set_rate")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate int SetRate(IntPtr playerObject, float rate);

        /// <summary>
        /// Get the media state.
        /// </summary>
        [NativeFunction("libvlc_media_player_get_state")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate MediaStates GetMediaPlayerState(IntPtr playerObject);

        /// <summary>
        /// Get media fps rate.
        /// </summary>
        [NativeFunction("libvlc_media_player_get_fps")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate float GetFramesPerSecond(IntPtr playerObject);

        /// <summary>
        /// Get video size in pixels.
        /// </summary>
        [NativeFunction("libvlc_video_get_size")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate int GetVideoSize(IntPtr playerObject, uint num, out uint px, out uint py);

        /// <summary>
        /// Get video scale.
        /// </summary>
        [NativeFunction("libvlc_video_get_scale")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate float GetVideoScale(IntPtr playerObject);

        /// <summary>
        /// Set video scale.
        /// </summary>
        [NativeFunction("libvlc_video_set_scale")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate float SetVideoScale(IntPtr playerObject, float f_factor);

        /// <summary>
        /// Take a snapshot of the current video window.
        /// </summary>
        /// <returns>Return 0 on success, -1 if the video was not found.</returns>
        [NativeFunction("libvlc_video_take_snapshot")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate int TakeSnapshot(IntPtr playerObject, uint num, string fileName, uint width, uint height);

        #region Spu setup
        /// <summary>
        /// Get the number of available video subtitles.
        /// </summary>
        [NativeFunction("libvlc_video_get_spu_count")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate int GetVideoSpuCount(IntPtr playerObject);

        /// <summary>
        /// Get the description of available video subtitles.
        /// </summary>
        [NativeFunction("libvlc_video_get_spu_description")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate IntPtr GetVideoSpuDescription(IntPtr playerObject);

        /// <summary>
        /// Get current video subtitle.
        /// </summary>
        [NativeFunction("libvlc_video_get_spu")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]

        private delegate int GetVideoSpu(IntPtr playerObject);

        /// <summary>
        /// Set new video subtitle.
        /// </summary>
        [NativeFunction("libvlc_video_set_spu")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate int SetVideoSpu(IntPtr playerObject, int spu);

        /// <summary>
        /// Set new video subtitle file.
        /// </summary>
        [NativeFunction("libvlc_video_set_subtitle_file")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate int SetVideoSubtitleFile(IntPtr playerObject, [MarshalAs(UnmanagedType.LPStr)] string path);
        #endregion

        #region Audio setup
        /// <summary>
        /// Set audio format.
        /// </summary>
        [NativeFunction("libvlc_audio_set_format")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate void SetAudioFormat(IntPtr playerObject, [MarshalAs(UnmanagedType.LPStr)] string format, int rate, int channels);

        /// <summary>
        /// Set audio callbacks.
        /// </summary>
        [NativeFunction("libvlc_audio_set_callbacks")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate void SetAudioCallbacks(IntPtr playerObject, IntPtr play, IntPtr pause, IntPtr resume, IntPtr flush, IntPtr drain, IntPtr opaque);

        /// <summary>
        /// Set audio format callbacks.
        /// </summary>
        [NativeFunction("libvlc_audio_set_format_callbacks")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate void SetAudioFormatCallbacks(IntPtr playerObject, IntPtr setup, IntPtr cleanup);

        /// <summary>
        /// Get number of available audio tracks.
        /// </summary>
        [NativeFunction("libvlc_audio_get_track_count")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate int GetAudioTracksCount(IntPtr playerObject);

        /// <summary>
        /// Get the description of available audio tracks.
        /// </summary>
        [NativeFunction("libvlc_audio_get_track_description")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate IntPtr GetAudioTracksDescriptions(IntPtr playerObject);

        /// <summary>
        /// Relase the description of available track.
        /// </summary>
        [NativeFunction("libvlc_track_description_release")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate IntPtr ReleaseTracksDescriptions(IntPtr trackDescription);

        /// <summary>
        /// Get current audio track.
        /// </summary>
        [NativeFunction("libvlc_audio_get_track")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate int GetAudioTrack(IntPtr playerObject);

        /// <summary>
        /// Set audio track.
        /// </summary>
        [NativeFunction("libvlc_audio_set_track")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate int SetAudioTrack(IntPtr playerObject, int trackId);

        /// <summary>
        /// Get current audio delay.
        /// </summary>
        [NativeFunction("libvlc_audio_get_delay")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate long GetAudioDelay(IntPtr playerObject);

        /// <summary>
        /// Set current audio delay. The audio delay will be reset to zero each time the media changes.
        /// </summary>
        [NativeFunction("libvlc_audio_set_delay")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate void SetAudioDelay(IntPtr playerObject, long channel);

        /// <summary>
        /// Get current software audio volume.
        /// </summary>
        [NativeFunction("libvlc_audio_get_volume")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate int GetVolume(IntPtr playerObject);

        /// <summary>
        /// Set current software audio volume.
        /// </summary>
        [NativeFunction("libvlc_audio_set_volume")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate int SetVolume(IntPtr playerObject, int volume);

        /// <summary>
        /// Set current mute status.
        /// </summary>
        [NativeFunction("libvlc_audio_set_mute")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate void SetMute(IntPtr playerObject, int status);

        /// <summary>
        /// Get current mute status.
        /// </summary>
        [NativeFunction("libvlc_audio_get_mute")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate int IsMute(IntPtr playerObject);

        /// <summary>
        /// Get the list of available audio outputs.
        /// </summary>
        [NativeFunction("libvlc_audio_output_list_get")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate IntPtr GetAudioOutputsDescriptions(IntPtr instance);

        /// <summary>
        /// It will release the list of available audio outputs.
        /// </summary>
        [NativeFunction("libvlc_audio_output_list_release")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate void ReleaseAudioOutputDescription(IntPtr audioOutput);

        /// <summary>
        /// Set the audio output. Change will be applied after stop and play.
        /// </summary>
        [NativeFunction("libvlc_audio_output_set")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate int SetAudioOutput(IntPtr playerObject, IntPtr audioOutputName);

        /// <summary>
        ///  Set audio output device. Changes are only effective after stop and play.
        /// </summary>
        [NativeFunction("libvlc_audio_output_device_set")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate void SetAudioOutputDevice(IntPtr playerObject, [MarshalAs(UnmanagedType.LPStr)] string audioOutputName, [MarshalAs(UnmanagedType.LPStr)] string deviceName);

        /// <summary>
        ///  Get audio output devices list.
        /// </summary>
        [NativeFunction("libvlc_audio_output_device_list_get")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate IntPtr GetAudioOutputDeviceList(IntPtr playerObject, [MarshalAs(UnmanagedType.LPStr)] string aout);

        /// <summary>
        ///  Release audio output devices list.
        /// </summary>
        [NativeFunction("libvlc_audio_output_device_list_release")]
        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        private delegate IntPtr ReleaseAudioOutputDeviceList(IntPtr p_list);
        #endregion
        #endregion

        public WrapperStandalone(PlayerOptionsStandalone options)
        {
            var settings = UMPSettings.Instance;

            // Additional loading of 'libVLCCore' library for correct work of main library
            NativeInterop.LoadLibrary(UMPSettings.LIB_VLC_CORE_NAME, settings.LibrariesPath);
            _libVLCHandler = NativeInterop.LoadLibrary(UMPSettings.LIB_VLC_NAME, settings.LibrariesPath);

            if (UMPSettings.RuntimePlatform == UMPSettings.Platforms.Linux)
            {
                var umpLibraryPath = settings.GetLibrariesPath(UMPSettings.RuntimePlatform, false);
                _libUMPHandler = NativeInterop.LoadLibrary(UMPSettings.ASSET_NAME, umpLibraryPath);
            }

            _manageLogCallback = DebugLogHandler;
            NativeSetUnityLogMessageCallback(Marshal.GetFunctionPointerForDelegate(_manageLogCallback));

            if (UMPSettings.RuntimePlatform == UMPSettings.Platforms.Linux)
                _nativeIndex = NativeInterop.GetLibraryDelegate<UMPNativeInitDel>(_libUMPHandler).Invoke();
            else
                _nativeIndex = UMPNativeInit();
        }

        private void DebugLogHandler(string msg)
        {
            UnityEngine.Debug.LogError(msg);
        }

        #region Native
        public int NativeIndex
        {
            get
            {
                return _nativeIndex;
            }
        }

        public void NativeUpdateIndex()
        {
            if (UMPSettings.RuntimePlatform == UMPSettings.Platforms.Linux)
                NativeInterop.GetLibraryDelegate<UMPNativeUpdateIndexDel>(_libUMPHandler).Invoke(_nativeIndex);
            else
                UMPNativeUpdateIndex(_nativeIndex);
        }

        public void NativeSetTexture(IntPtr texture)
        {
            if (UMPSettings.RuntimePlatform == UMPSettings.Platforms.Linux)
                NativeInterop.GetLibraryDelegate<UMPNativeSetTextureDel>(_libUMPHandler).Invoke(_nativeIndex, texture);
            else
                UMPNativeSetTexture(_nativeIndex, texture);
        }

        public void NativeSetPixelsBuffer(IntPtr buffer, int width, int height)
        {
            if (UMPSettings.RuntimePlatform == UMPSettings.Platforms.Linux)
                NativeInterop.GetLibraryDelegate<UMPNativeSetPixelsBufferDel>(_libUMPHandler).Invoke(_nativeIndex, buffer, width, height);
            else
                UMPNativeSetPixelsBuffer(_nativeIndex, buffer, width, height);
        }

        public IntPtr NativeGetPixelsBuffer()
        {
            if (UMPSettings.RuntimePlatform == UMPSettings.Platforms.Linux)
                return NativeInterop.GetLibraryDelegate<UMPNativeGetPixelsBufferDel>(_libUMPHandler).Invoke(_nativeIndex);

            return UMPNativeGetPixelsBuffer(_nativeIndex);
        }

        public void NativePixelsBufferRelease()
        {
            if (UMPSettings.RuntimePlatform == UMPSettings.Platforms.Linux)
                NativeInterop.GetLibraryDelegate<UMPNativePixelsBufferReleaseDel>(_libUMPHandler).Invoke(_nativeIndex);
            else
                UMPNativePixelsBufferRelease(_nativeIndex);
        }

        public string NativeGetLogMessage()
        {
            IntPtr value = IntPtr.Zero;

            if (UMPSettings.RuntimePlatform == UMPSettings.Platforms.Linux)
                value = NativeInterop.GetLibraryDelegate<UMPNativeGetLogMessageDel>(_libUMPHandler).Invoke(_nativeIndex);
            else
                value = UMPNativeGetLogMessage(_nativeIndex);

            return value != IntPtr.Zero ? Marshal.PtrToStringAnsi(value) : null;
        }

        public int NativeGetLogLevel()
        {
            if (UMPSettings.RuntimePlatform == UMPSettings.Platforms.Linux)
                return NativeInterop.GetLibraryDelegate<UMPNativeGetLogLevelDel>(_libUMPHandler).Invoke(_nativeIndex);

            return UMPNativeGetLogLevel(_nativeIndex);
        }

        public int NativeGetState()
        {
            if (UMPSettings.RuntimePlatform == UMPSettings.Platforms.Linux)
                return NativeInterop.GetLibraryDelegate<UMPNativeGetStateDel>(_libUMPHandler).Invoke(_nativeIndex);

            return UMPNativeGetState(_nativeIndex);
        }

        private float NativeGetStateFloatValue()
        {
            if (UMPSettings.RuntimePlatform == UMPSettings.Platforms.Linux)
                return NativeInterop.GetLibraryDelegate<UMPNativeGetStateFloatValueDel>(_libUMPHandler).Invoke(_nativeIndex);

            return UMPNativeGetStateFloatValue(_nativeIndex);
        }

        private long NativeGetStateLongValue()
        {
            if (UMPSettings.RuntimePlatform == UMPSettings.Platforms.Linux)
                return NativeInterop.GetLibraryDelegate<UMPNativeGetStateLongValueDel>(_libUMPHandler).Invoke(_nativeIndex);

            return UMPNativeGetStateLongValue(_nativeIndex);
        }

        private string NativeGetStateStringValue()
        {
            IntPtr value = IntPtr.Zero;

            if (UMPSettings.RuntimePlatform == UMPSettings.Platforms.Linux)
                value = NativeInterop.GetLibraryDelegate<UMPNativeGetStateStringValueDel>(_libUMPHandler).Invoke(_nativeIndex);
            else
                value = UMPNativeGetStateStringValue(_nativeIndex);

            return value != IntPtr.Zero ? Marshal.PtrToStringAnsi(value) : null;
        }

        public void NativeSetPixelsVerticalFlip(bool flip)
        {
            if (UMPSettings.RuntimePlatform == UMPSettings.Platforms.Linux)
                NativeInterop.GetLibraryDelegate<UMPNativeSetPixelsVerticalFlipDel>(_libUMPHandler).Invoke(_nativeIndex, flip);
            else
                UMPNativeSetPixelsVerticalFlip(_nativeIndex, flip);
        }

        public void NativeSetAudioParams(int numChannels, int sampleRate)
        {
            if (UMPSettings.RuntimePlatform == UMPSettings.Platforms.Linux)
                NativeInterop.GetLibraryDelegate<UMPNativeSetAudioParamsDel>(_libUMPHandler).Invoke(_nativeIndex, numChannels, sampleRate);
            else
                UMPNativeSetAudioParams(_nativeIndex, numChannels, sampleRate);
        }

        public string NativeGetAudioParams(char separator)
        {
            IntPtr value = IntPtr.Zero;

            if (UMPSettings.RuntimePlatform == UMPSettings.Platforms.Linux)
                value = NativeInterop.GetLibraryDelegate<UMPNativeGetAudioParamsDel>(_libUMPHandler).Invoke(_nativeIndex, separator);
            else
                value = UMPNativeGetAudioParams(_nativeIndex, separator);

            return value != IntPtr.Zero ? Marshal.PtrToStringAnsi(value) : null;
        }

        public int NativeGetAudioSamples(IntPtr decodedSamples, int samplesLength, AudioOutput.AudioChannels audioChannel)
        {
            if (UMPSettings.RuntimePlatform == UMPSettings.Platforms.Linux)
                return NativeInterop.GetLibraryDelegate<UMPNativeGetAudioSamplesDel>(_libUMPHandler).Invoke(_nativeIndex, decodedSamples, samplesLength, audioChannel);

            return UMPNativeGetAudioSamples(_nativeIndex, decodedSamples, samplesLength, audioChannel);
        }

        public bool NativeClearAudioSamples(int samplesLength)
        {
            if (UMPSettings.RuntimePlatform == UMPSettings.Platforms.Linux)
                return NativeInterop.GetLibraryDelegate<UMPNativeClearAudioSamplesDel>(_libUMPHandler).Invoke(_nativeIndex, samplesLength);

            return UMPNativeClearAudioSamples(_nativeIndex, samplesLength);
        }

        public IntPtr NativeGetUnityRenderCallback()
        {
            if (UMPSettings.RuntimePlatform == UMPSettings.Platforms.Linux)
                return NativeInterop.GetLibraryDelegate<UMPNativeGetUnityRenderCallbackDel>(_libUMPHandler).Invoke();

            return UMPNativeGetUnityRenderCallback();
        }

        public IntPtr NativeGetVideoLockCallback()
        {
            if (UMPSettings.RuntimePlatform == UMPSettings.Platforms.Linux)
                return NativeInterop.GetLibraryDelegate<UMPNativeGetVideoLockCallbackDel>(_libUMPHandler).Invoke();

            return UMPNativeGetVideoLockCallback();
        }

        public IntPtr NativeGetVideoDisplayCallback()
        {
            if (UMPSettings.RuntimePlatform == UMPSettings.Platforms.Linux)
                return NativeInterop.GetLibraryDelegate<UMPNativeGetVideoDisplayCallbackDel>(_libUMPHandler).Invoke();

            return UMPNativeGetVideoDisplayCallback();
        }

        public IntPtr NativeGetVideoFormatCallback()
        {
            if (UMPSettings.RuntimePlatform == UMPSettings.Platforms.Linux)
                return NativeInterop.GetLibraryDelegate<UMPNativeGetVideoFormatCallbackDel>(_libUMPHandler).Invoke();

            return UMPNativeGetVideoFormatCallback();
        }

        public IntPtr NativeGetVideoCleanupCallback()
        {
            if (UMPSettings.RuntimePlatform == UMPSettings.Platforms.Linux)
                return NativeInterop.GetLibraryDelegate<UMPNativeGetVideoCleanupCallbackDel>(_libUMPHandler).Invoke();

            return UMPNativeGetVideoCleanupCallback();
        }

        public IntPtr NativeGetAudioSetupCallback()
        {
            if (UMPSettings.RuntimePlatform == UMPSettings.Platforms.Linux)
                return NativeInterop.GetLibraryDelegate<UMPNativeGetAudioSetupCallbackDel>(_libUMPHandler).Invoke();

            return UMPNativeGetAudioSetupCallback();
        }

        public IntPtr NativeGetAudioPlayCallback()
        {
            if (UMPSettings.RuntimePlatform == UMPSettings.Platforms.Linux)
                return NativeInterop.GetLibraryDelegate<UMPNativeGetAudioPlayCallbackDel>(_libUMPHandler).Invoke();

            return UMPNativeGetAudioPlayCallback();
        }

        public IntPtr NativeMediaPlayerEventCallback()
        {
            if (UMPSettings.RuntimePlatform == UMPSettings.Platforms.Linux)
                return NativeInterop.GetLibraryDelegate<UMPNativeMediaPlayerEventCallbackDel>(_libUMPHandler).Invoke();

            return UMPNativeMediaPlayerEventCallback();
        }

        public void NativeSetBufferSizeCallback(IntPtr callback)
        {
            if (UMPSettings.RuntimePlatform == UMPSettings.Platforms.Linux)
                NativeInterop.GetLibraryDelegate<UMPNativeSetBufferSizeCallbackDel>(_libUMPHandler).Invoke(_nativeIndex, callback);
            else
                UMPNativeSetBufferSizeCallback(_nativeIndex, callback);
        }

        public IntPtr NativeGetLogMessageCallback()
        {
            if (UMPSettings.RuntimePlatform == UMPSettings.Platforms.Linux)
                return NativeInterop.GetLibraryDelegate<UMPNativeGetLogMessageCallbackDel>(_libUMPHandler).Invoke();

            return UMPNativeGetLogMessageCallback();
        }

        public void NativeSetUnityLogMessageCallback(IntPtr callback)
        {
            if (UMPSettings.RuntimePlatform == UMPSettings.Platforms.Linux)
                NativeInterop.GetLibraryDelegate<UMPNativeSetUnityLogMessageCallbackDel>(_libUMPHandler).Invoke(callback);
            else
                UMPNativeSetUnityLogMessageCallback(callback);
        }

        public void NativeUpdateFramesCounter(int counter)
        {
            if (UMPSettings.RuntimePlatform == UMPSettings.Platforms.Linux)
                NativeInterop.GetLibraryDelegate<UMPNativeUpdateFramesCounterCallbackDel>(_libUMPHandler).Invoke(_nativeIndex, counter);
            else
                UMPNativeUpdateFramesCounter(_nativeIndex, counter);
        }

        public int NativeGetFramesCounter()
        {
            if (UMPSettings.RuntimePlatform == UMPSettings.Platforms.Linux)
                return NativeInterop.GetLibraryDelegate<UMPNativeGetFramesCounterCallbackDel>(_libUMPHandler).Invoke(_nativeIndex);

            return UMPNativeGetFramesCounter(_nativeIndex);
        }
        #endregion

        #region Player
        public void PlayerSetDataSource(string path, object playerObject = null)
        {
        }

        public bool PlayerPlay(object playerObject)
        {
            return NativeInterop.GetLibraryDelegate<Play>(_libVLCHandler).Invoke((IntPtr)playerObject) == 0;
        }

        public void PlayerPause(object playerObject)
        {
            NativeInterop.GetLibraryDelegate<Pause>(_libVLCHandler).Invoke((IntPtr)playerObject);
        }

        public void PlayerStop(object playerObject)
        {
            NativeInterop.GetLibraryDelegate<Stop>(_libVLCHandler).Invoke((IntPtr)playerObject);
        }

        public void PlayerRelease(object playerObject)
        {
            NativeInterop.GetLibraryDelegate<ReleaseMediaPlayer>(_libVLCHandler).Invoke((IntPtr)playerObject);
        }

        public bool PlayerIsPlaying(object playerObject)
        {
            return NativeInterop.GetLibraryDelegate<IsPlaying>(_libVLCHandler).Invoke((IntPtr)playerObject) == 1;
        }

        public bool PlayerWillPlay(object playerObject)
        {
            return NativeInterop.GetLibraryDelegate<CouldPlay>(_libVLCHandler).Invoke((IntPtr)playerObject) == 1;
        }

        public long PlayerGetLength(object playerObject)
        {
            return NativeInterop.GetLibraryDelegate<GetLength>(_libVLCHandler).Invoke((IntPtr)playerObject);
        }

        public float PlayerGetBufferingPercentage(object playerObject)
        {
            return 0;
        }

        public long PlayerGetTime(object playerObject)
        {
            return NativeInterop.GetLibraryDelegate<GetTime>(_libVLCHandler).Invoke((IntPtr)playerObject);
        }

        public void PlayerSetTime(long time, object playerObject)
        {
            NativeInterop.GetLibraryDelegate<SetTime>(_libVLCHandler).Invoke((IntPtr)playerObject, time);
        }

        public float PlayerGetPosition(object playerObject)
        {
            return NativeInterop.GetLibraryDelegate<GetMediaPosition>(_libVLCHandler).Invoke((IntPtr)playerObject);
        }

        public void PlayerSetPosition(float pos, object playerObject)
        {
            NativeInterop.GetLibraryDelegate<SetMediaPosition>(_libVLCHandler).Invoke((IntPtr)playerObject, pos);
        }

        public float PlayerGetRate(object playerObject)
        {
            return NativeInterop.GetLibraryDelegate<GetRate>(_libVLCHandler).Invoke((IntPtr)playerObject);
        }

        public bool PlayerSetRate(float rate, object playerObject)
        {
            return NativeInterop.GetLibraryDelegate<SetRate>(_libVLCHandler).Invoke((IntPtr)playerObject, rate) == 0;
        }

        public int PlayerGetVolume(object playerObject)
        {
            return NativeInterop.GetLibraryDelegate<GetVolume>(_libVLCHandler).Invoke((IntPtr)playerObject);
        }

        public int PlayerSetVolume(int volume, object playerObject)
        {
            return NativeInterop.GetLibraryDelegate<SetVolume>(_libVLCHandler).Invoke((IntPtr)playerObject, volume);
        }

        public bool PlayerGetMute(object playerObject)
        {
            return NativeInterop.GetLibraryDelegate<IsMute>(_libVLCHandler).Invoke((IntPtr)playerObject) == 1;
        }

        public void PlayerSetMute(bool mute, object playerObject)
        {
            NativeInterop.GetLibraryDelegate<SetMute>(_libVLCHandler).Invoke((IntPtr)playerObject, mute ? 1 : 0);
        }

        public int PlayerVideoWidth(object playerObject)
        {
            uint width = 0, height = 0;
            NativeInterop.GetLibraryDelegate<GetVideoSize>(_libVLCHandler).Invoke((IntPtr)playerObject, 0, out width, out height);
            return (int)width;
        }

        public int PlayerVideoHeight(object playerObject)
        {
            uint width = 0, height = 0;
            NativeInterop.GetLibraryDelegate<GetVideoSize>(_libVLCHandler).Invoke((IntPtr)playerObject, 0, out width, out height);
            return (int)height;
        }

        public int PlayerVideoFramesCounter(object playerObject)
        {
            return 0;
        }
        
        public PlayerState PlayerGetState()
        {
            return (PlayerState)NativeGetState();
        }

        public object PlayerGetStateValue()
        {
            object value = NativeGetStateFloatValue();

            if ((float)value < 0)
            {
                value = NativeGetStateLongValue();

                if ((long)value < 0)
                {
                    value = NativeGetStateStringValue();
                }
            }

            return value;
        }
        #endregion

        #region Player Spu
        public MediaTrackInfo[] PlayerSpuGetTracks(object playerObject)
        {
            var tracks = new System.Collections.Generic.List<MediaTrackInfo>();
            var tracksCount = NativeInterop.GetLibraryDelegate<GetVideoSpuCount>(_libVLCHandler).Invoke((IntPtr)playerObject);
            var tracksHandler = NativeInterop.GetLibraryDelegate<GetVideoSpuDescription>(_libVLCHandler).Invoke((IntPtr)playerObject);

            for (int i = 0; i < tracksCount; i++)
            {
                if (tracksHandler != IntPtr.Zero)
                {
                    var track = (TrackDescription)Marshal.PtrToStructure(tracksHandler, typeof(TrackDescription));
                    tracks.Add(new MediaTrackInfo(track.Id, track.Name));
                    tracksHandler = track.NextDescription;
                }
            }

            return tracks.ToArray();
        }

        public int PlayerSpuGetTrack(object playerObject)
        {
            return NativeInterop.GetLibraryDelegate<GetVideoSpu>(_libVLCHandler).Invoke((IntPtr)playerObject);
        }

        public int PlayerSpuSetTrack(int spuIndex, object playerObject)
        {
            return NativeInterop.GetLibraryDelegate<SetVideoSpu>(_libVLCHandler).Invoke((IntPtr)playerObject, spuIndex);
        }
        #endregion

        #region Player Audio
        public MediaTrackInfo[] PlayerAudioGetTracks(object playerObject)
        {
            var tracks = new System.Collections.Generic.List<MediaTrackInfo>();
            var tracksCount = NativeInterop.GetLibraryDelegate<GetAudioTracksCount>(_libVLCHandler).Invoke((IntPtr)playerObject);
            var tracksHandler = NativeInterop.GetLibraryDelegate<GetAudioTracksDescriptions>(_libVLCHandler).Invoke((IntPtr)playerObject);

            for (int i = 0; i < tracksCount; i++)
            {
                if (tracksHandler != IntPtr.Zero)
                {
                    var track = (TrackDescription)Marshal.PtrToStructure(tracksHandler, typeof(TrackDescription));
                    tracks.Add(new MediaTrackInfo(track.Id, track.Name));
                    tracksHandler = track.NextDescription;
                }
            }

            //InteropLibraryLoader.GetInteropDelegate<ReleaseTracksDescriptions>(_libVLCHandler).Invoke(tracksHandler);

            return tracks.ToArray();
        }

        public int PlayerAudioGetTrack(object playerObject)
        {
            return NativeInterop.GetLibraryDelegate<GetAudioTrack>(_libVLCHandler).Invoke((IntPtr)playerObject);
        }

        public int PlayerAudioSetTrack(int audioIndex, object playerObject)
        {
            return NativeInterop.GetLibraryDelegate<SetAudioTrack>(_libVLCHandler).Invoke((IntPtr)playerObject, audioIndex);
        }
        #endregion

        #region Platform dependent functionality
        public IntPtr ExpandedLibVLCNew(string[] args)
        {
            if (args == null)
                args = new string[0];

            return NativeInterop.GetLibraryDelegate<CreateNewInstance>(_libVLCHandler).Invoke(args.Length, args);
        }

        public void ExpandedLibVLCRelease(IntPtr libVLCInst)
        {
            NativeInterop.GetLibraryDelegate<ReleaseInstance>(_libVLCHandler).Invoke(libVLCInst);
        }

        public IntPtr ExpandedMediaNewLocation(IntPtr libVLCInst, string path)
        {
            return NativeInterop.GetLibraryDelegate<CreateNewMediaFromLocation>(_libVLCHandler).Invoke(libVLCInst, path);
        }

        public void ExpandedSetMedia(IntPtr mpInstance, IntPtr libVLCMediaInst)
        {
            NativeInterop.GetLibraryDelegate<SetMediaToMediaPlayer>(_libVLCHandler).Invoke(mpInstance, libVLCMediaInst);
        }

        public void ExpandedAddOption(IntPtr libVLCMediaInst, string option)
        {
            NativeInterop.GetLibraryDelegate<AddOptionToMedia>(_libVLCHandler).Invoke(libVLCMediaInst, option);
        }

        // TODO Move to IPlayerWrapper
        public void ExpandedMediaGetStats(IntPtr mpInstance, out MediaStats mediaStats)
        {
            NativeInterop.GetLibraryDelegate<GetMediaStats>(_libVLCHandler).Invoke(mpInstance, out mediaStats);
        }

        // TODO Move to IPlayerWrapper
        public TrackInfo[] ExpandedMediaGetTracksInfo(IntPtr mpInstance)
        {
            IntPtr result_buffer = new IntPtr();
            int trackCount = NativeInterop.GetLibraryDelegate<GetMediaTracksInformations>(_libVLCHandler).Invoke(mpInstance, out result_buffer);

            if (trackCount < 0)
                return null;

            IntPtr buffer = result_buffer;
            var tracks = new TrackInfo[trackCount];

            for (int i = 0; i < tracks.Length; i++)
            {
                tracks[i] = (TrackInfo)Marshal.PtrToStructure(buffer, typeof(TrackInfo));
                buffer = new IntPtr(buffer.ToInt64() + Marshal.SizeOf(typeof(TrackInfo)));
            }
            ExpandedFree(result_buffer);
            return tracks;
        }

        public void ExpandedMediaRelease(IntPtr libVLCMediaInst)
        {
            NativeInterop.GetLibraryDelegate<ReleaseMedia>(_libVLCHandler).Invoke(libVLCMediaInst);
        }

        public IntPtr ExpandedMediaPlayerNew(IntPtr libVLCInst)
        {
            return NativeInterop.GetLibraryDelegate<CreateMediaPlayer>(_libVLCHandler).Invoke(libVLCInst);
        }

        public void ExpandedFree(IntPtr instance)
        {
            NativeInterop.GetLibraryDelegate<Free>(_libVLCHandler).Invoke(instance);
        }

        public IntPtr ExpandedEventManager(IntPtr mpInstance)
        {
            return NativeInterop.GetLibraryDelegate<GetMediaPlayerEventManager>(_libVLCHandler).Invoke(mpInstance);
        }

        public int ExpandedEventAttach(IntPtr eventManagerInst, EventTypes eventType, IntPtr callback, IntPtr userData)
        {
            return NativeInterop.GetLibraryDelegate<AttachEvent>(_libVLCHandler).Invoke(eventManagerInst, eventType, callback, userData);
        }

        public void ExpandedEventDetach(IntPtr eventManagerInst, EventTypes eventType, IntPtr callback, IntPtr userData)
        {
            NativeInterop.GetLibraryDelegate<DetachEvent>(_libVLCHandler).Invoke(eventManagerInst, eventType, callback, userData);
        }

        public void ExpandedLogSet(IntPtr libVLC, IntPtr callback, IntPtr data)
        {
            NativeInterop.GetLibraryDelegate<LogSet>(_libVLCHandler).Invoke(libVLC, callback, data);
        }

        public void ExpandedLogUnset(IntPtr libVLC)
        {
            NativeInterop.GetLibraryDelegate<LogUnset>(_libVLCHandler).Invoke(libVLC);
        }

        public void ExpandedVideoSetCallbacks(IntPtr mpInstance, IntPtr @lock, IntPtr unlock, IntPtr display, IntPtr opaque)
        {
            NativeInterop.GetLibraryDelegate<SetVideoCallbacks>(_libVLCHandler).Invoke(mpInstance, @lock, unlock, display, opaque);
        }

        public void ExpandedVideoSetFormatCallbacks(IntPtr mpInstance, IntPtr setup, IntPtr cleanup)
        {
            NativeInterop.GetLibraryDelegate<SetVideoFormatCallbacks>(_libVLCHandler).Invoke(mpInstance, setup, cleanup);
        }

        public void ExpandedVideoSetFormat(IntPtr mpInstance, string chroma, int width, int height, int pitch)
        {
            NativeInterop.GetLibraryDelegate<SetVideoFormat>(_libVLCHandler).Invoke(mpInstance, chroma, (uint)width, (uint)height, (uint)pitch);
        }

        public void ExpandedAudioSetCallbacks(IntPtr mpInstance, IntPtr play, IntPtr pause, IntPtr resume, IntPtr flush, IntPtr drain, IntPtr opaque)
        {
            NativeInterop.GetLibraryDelegate<SetAudioCallbacks>(_libVLCHandler).Invoke(mpInstance, play, pause, resume, flush, drain, opaque);
        }

        public void ExpandedAudioSetFormatCallbacks(IntPtr mpInstance, IntPtr setup, IntPtr cleanup)
        {
            NativeInterop.GetLibraryDelegate<SetAudioFormatCallbacks>(_libVLCHandler).Invoke(mpInstance, setup, cleanup);
        }

        public void ExpandedAudioSetFormat(IntPtr mpInstance, string format, int rate, int channels)
        {
            NativeInterop.GetLibraryDelegate<SetAudioFormat>(_libVLCHandler).Invoke(mpInstance, format, rate, channels);
        }

        public long ExpandedGetAudioDelay(IntPtr mpInstance)
        {
            return NativeInterop.GetLibraryDelegate<GetAudioDelay>(_libVLCHandler).Invoke(mpInstance);
        }

        public void ExpandedSetAudioDelay(IntPtr mpInstance, long channel)
        {
            NativeInterop.GetLibraryDelegate<SetAudioDelay>(_libVLCHandler).Invoke(mpInstance, channel);
        }

        public int ExpandedAudioOutputSet(IntPtr mpInstance, string psz_name)
        {
            return NativeInterop.GetLibraryDelegate<SetAudioOutput>(_libVLCHandler).Invoke(mpInstance, Marshal.StringToHGlobalAnsi(psz_name));
        }

        public IntPtr ExpandedAudioOutputListGet(IntPtr mpInstance)
        {
            return NativeInterop.GetLibraryDelegate<GetAudioOutputsDescriptions>(_libVLCHandler).Invoke(mpInstance);
        }

        public void ExpandedAudioOutputListRelease(IntPtr outputListInst)
        {
            NativeInterop.GetLibraryDelegate<ReleaseAudioOutputDescription>(_libVLCHandler).Invoke(outputListInst);
        }

        public void ExpandedAudioOutputDeviceSet(IntPtr mpInstance, string psz_audio_output, string psz_device_id)
        {
            NativeInterop.GetLibraryDelegate<SetAudioOutputDevice>(_libVLCHandler).Invoke(mpInstance, psz_audio_output, psz_device_id);
        }

        public IntPtr ExpandedAudioOutputDeviceListGet(IntPtr mpInstance, string aout)
        {
            return NativeInterop.GetLibraryDelegate<GetAudioOutputDeviceList>(_libVLCHandler).Invoke(mpInstance, aout);
        }

        public void ExpandedAudioOutputDeviceListRelease(IntPtr deviceListInst)
        {
            NativeInterop.GetLibraryDelegate<ReleaseAudioOutputDeviceList>(_libVLCHandler).Invoke(deviceListInst);
        }

        public int ExpandedSpuSetFile(IntPtr mpInstance, string path)
        {
            return NativeInterop.GetLibraryDelegate<SetVideoSubtitleFile>(_libVLCHandler).Invoke(mpInstance, path);
        }

        public float ExpandedVideoGetScale(IntPtr mpInstance)
        {
            return NativeInterop.GetLibraryDelegate<GetVideoScale>(_libVLCHandler).Invoke(mpInstance);
        }

        public void ExpandedVideoSetScale(IntPtr mpInstance, float factor)
        {
            NativeInterop.GetLibraryDelegate<SetVideoScale>(_libVLCHandler).Invoke(mpInstance, factor);
        }

        public void ExpandedVideoTakeSnapshot(IntPtr mpInstance, uint stream, string filePath, uint width, uint height)
        {
            NativeInterop.GetLibraryDelegate<TakeSnapshot>(_libVLCHandler).Invoke(mpInstance, stream, filePath, width, height);
        }

        public float ExpandedVideoFrameRate(IntPtr mpInstance)
        {
            return NativeInterop.GetLibraryDelegate<GetFramesPerSecond>(_libVLCHandler).Invoke(mpInstance);
        }
        #endregion
    }
}