public MediaStateChangedEventArgs(BufferState bufferState, NetworkState networkState, PlaybackState playbackState, SeekState seekState)
		{
			this.bufferState = bufferState;
			this.networkState = networkState;
			this.playbackState = playbackState;
			this.seekState = seekState;
		}

        private void MediaEngine_MediaStateChanged(MediaState state)
        {
            switch (state)
            {
                case MediaState.Loading:
                    this.PlaybackState = PlaybackState.Loading;

                    break;

                case MediaState.Stopped:
                    this.PlaybackState = PlaybackState.Paused;

                    break;

                case MediaState.Playing:
                    this.PlaybackState = PlaybackState.Playing;
                    break;

                case MediaState.Error:
                    this.PlaybackState = PlaybackState.Error_MediaInvalid;
                    break;

                case MediaState.Ended:
                    this.PlaybackState = PlaybackState.Ended;
                    break;
            }
        }

 public static PlayerState? Convert(PlaybackState? inState)
 {
     if(!inState.HasValue) {
         return null;
     } else {
         return Convert(inState.Value);
     }
 }

        public Form1()
        {
            InitializeComponent();

            m_state = PlaybackState.Closed;
            m_pPlayer = new DShowPlayer(panVideoWin, Handle, WM_GRAPH_EVENT);
            m_bDrag = false;
        }

        public MediaNotificationManager(MusicService serv)
        {
            service = serv;
            UpdateSessionToken();

            notificationColor = ResourceHelper.GetThemeColor(service,
                Android.Resource.Attribute.ColorPrimary, Color.DarkGray);

            notificationManager = (NotificationManager) service
                .GetSystemService(Context.NotificationService);

            string pkg = service.PackageName;
            pauseIntent = PendingIntent.GetBroadcast(service, RequestCode,
                new Intent(ActionPause).SetPackage(pkg), PendingIntentFlags.CancelCurrent);
            playIntent = PendingIntent.GetBroadcast(service, RequestCode,
                new Intent(ActionPlay).SetPackage(pkg), PendingIntentFlags.CancelCurrent);
            previousIntent = PendingIntent.GetBroadcast(service, RequestCode,
                new Intent(ActionPrev).SetPackage(pkg), PendingIntentFlags.CancelCurrent);
            nextIntent = PendingIntent.GetBroadcast(service, RequestCode,
                new Intent(ActionNext).SetPackage(pkg), PendingIntentFlags.CancelCurrent);

            notificationManager.CancelAll ();

            mCb.OnPlaybackStateChangedImpl = (state) => {
                playbackState = state;
                LogHelper.Debug (Tag, "Received new playback state", state);
                if (state != null && (state.State == PlaybackStateCode.Stopped ||
                    state.State == PlaybackStateCode.None)) {
                    StopNotification ();
                } else {
                    Notification notification = CreateNotification ();
                    if (notification != null) {
                        notificationManager.Notify (NotificationId, notification);
                    }
                }
            };

            mCb.OnMetadataChangedImpl = (meta) => {
                metadata = meta;
                LogHelper.Debug (Tag, "Received new metadata ", metadata);
                Notification notification = CreateNotification ();
                if (notification != null) {
                    notificationManager.Notify (NotificationId, notification);
                }
            };

            mCb.OnSessionDestroyedImpl = () => {
                LogHelper.Debug (Tag, "Session was destroyed, resetting to the new session token");
                UpdateSessionToken ();
            };
        }

        /// <summary>
        /// Begin playback
        /// </summary>
        public void Play()
        {
            if (playbackState == PlaybackState.Stopped)
            {
                // -------------------------------------------------------------------------------------
                // Thread that process samples
                // -------------------------------------------------------------------------------------
                notifyThread = new Thread(new ThreadStart(processSamples));
                // put this back to highest when we are confident we don't have any bugs in the thread proc
                notifyThread.Priority = ThreadPriority.Normal;
                notifyThread.IsBackground = true;
                notifyThread.Start();
            }

            lock (m_LockObject)
            {
                playbackState = PlaybackState.Playing;
            }
        }

        /// <summary>
        /// Initialises the WaveOut device
        /// </summary>
        /// <param name="waveProvider">WaveProvider to play</param>
        public void Init(IWaveProvider waveProvider)
        {
            this.waveStream = waveProvider;
            int bufferSize = waveProvider.WaveFormat.ConvertLatencyToByteSize((DesiredLatency + NumberOfBuffers - 1) / NumberOfBuffers);            

            MmResult result;
            lock (waveOutLock)
            {
                result = WaveInterop.waveOutOpenWindow(out hWaveOut, (IntPtr)DeviceNumber, waveStream.WaveFormat, callbackEvent.SafeWaitHandle.DangerousGetHandle(), IntPtr.Zero, WaveInterop.WaveInOutOpenFlags.CallbackEvent);
            }
            MmException.Try(result, "waveOutOpen");

            buffers = new WaveOutBuffer[NumberOfBuffers];
            playbackState = PlaybackState.Stopped;
            for (int n = 0; n < NumberOfBuffers; n++)
            {
                buffers[n] = new WaveOutBuffer(hWaveOut, bufferSize, waveStream, waveOutLock);
            }
        }

        /// <summary>
        /// Public method called by the main view to start playing the playlist
        /// </summary>
        public void play()
        {
            // If there is no backgroundworker initialized, do that
            if (playerThread == null)
            {
                playerThread = new BackgroundWorker();
                playerThread.DoWork += new DoWorkEventHandler(playerThread_DoWork);
                playerThread.ProgressChanged += new ProgressChangedEventHandler(playerThread_ProgressChanged);
                playerThread.RunWorkerCompleted += new RunWorkerCompletedEventHandler(playerThread_RunWorkerCompleted);
                playerThread.WorkerReportsProgress = true;

            }

            // Set state to playing
            this.playState = PlaybackState.Playing;

            // start playing the entire queue
            playQueue();
        }

 /// <summary>
 /// Stop playback
 /// </summary>
 public void Stop()
 {
     // Try and tidy up nicely
     if (Monitor.TryEnter(m_LockObject, 50))
     {
         playbackState = PlaybackState.Stopped;
         Monitor.Exit(m_LockObject);
     }
     else
     {
         // No joy - abort the thread!
         if (notifyThread != null)
         {
             notifyThread.Abort();
             notifyThread = null;
         }
     }
 }

        /// <summary>
        /// Stop playback without flushing buffers
        /// </summary>
        public void Pause()
        {
            if (playbackState == PlaybackState.Playing)
            {
                playbackState = PlaybackState.Paused;
            }

        }

 /// <summary>
 /// Begin Playback
 /// </summary>
 public void Play()
 {
     if (playbackState != PlaybackState.Playing)
     {
         if (playbackState == PlaybackState.Stopped && !preventNewPlayTaskCreation)
         {
             playbackState = PlaybackState.Playing;
             playTask = Task.Run((Action)PlayThread);
         }
         else
         {
             playbackState = PlaybackState.Playing;
         }
     }
 }

		public void RefreshPlaybackState()
		{
			PlaybackState nextPlaybackState = playbackState;
		
			if (sound != null)
			{
				if (sound.CurrentSubSoundIndex != -1 && sound.CurrentSubSound != null)
				{
					if (sound.CurrentSubSound.Channel.IsPlaying)
					{
						if (sound.CurrentSubSound.Channel.Paused)
							nextPlaybackState = PlaybackState.Paused;
						else nextPlaybackState = PlaybackState.Playing;
					}
					else nextPlaybackState = PlaybackState.Stopped;
				}
				else
				{
					if (sound.Channel != null)
					{
						if (sound.Channel.IsPlaying)
						{
							if (sound.Channel.Paused)
								nextPlaybackState = PlaybackState.Paused;
							else nextPlaybackState = PlaybackState.Playing;
						}
						else nextPlaybackState = PlaybackState.Stopped;
					}
					else nextPlaybackState = PlaybackState.None;
				}
			}
			else nextPlaybackState = PlaybackState.None;

			if (playbackState != nextPlaybackState)
			{
				playbackState = nextPlaybackState;
				if (PlaybackStateChanged != null)
					PlaybackStateChanged(this, new MediaStateChangedEventArgs(BufferState, NetworkState, PlaybackState, SeekState));
			}
		}

        /// <summary>
        /// Begin Playback
        /// </summary>
        public void Play()
        {
            if (playbackState != PlaybackState.Playing)
            {
                if (playbackState == PlaybackState.Stopped)
                {
                    playThread = new Thread(new ThreadStart(PlayThread));
                    playbackState = PlaybackState.Playing;
                    playThread.Start();
                }
                else
                {
                    playbackState = PlaybackState.Playing;
                }

            }
        }

 /// <summary>
 /// Stop and reset the WaveOut device
 /// </summary>
 public void Stop()
 {
     if (playbackState != PlaybackState.Stopped)
     {
         // in the call to waveOutReset with function callbacks
         // some drivers will block here until OnDone is called
         // for every buffer
         playbackState = PlaybackState.Stopped; // set this here to avoid a problem with some drivers whereby 
         MmResult result;
         lock (waveOutLock)
         {
             result = WaveInterop.waveOutReset(hWaveOut);
         }
         if (result != MmResult.NoError)
         {
             throw new MmException(result, "waveOutReset");
         }
         callbackEvent.Set(); // give the thread a kick, make sure we exit
     }
 }

        /// <summary>
        /// Initialises the WaveOut device
        /// </summary>
        /// <param name="waveProvider">WaveProvider to play</param>
        public void Init(IWaveProvider waveProvider)
        {
            this.waveStream = waveProvider;
            int bufferSize = waveProvider.WaveFormat.ConvertLatencyToByteSize((DesiredLatency + NumberOfBuffers - 1) / NumberOfBuffers);

            MmResult result;
            lock (waveOutLock)
            {
                result = callbackInfo.WaveOutOpen(out hWaveOut, DeviceNumber, waveStream.WaveFormat, callback);
            }
            MmException.Try(result, "waveOutOpen");

            buffers = new WaveOutBuffer[NumberOfBuffers];
            playbackState = PlaybackState.Stopped;
            for (int n = 0; n < NumberOfBuffers; n++)
            {
                buffers[n] = new WaveOutBuffer(hWaveOut, bufferSize, waveStream, waveOutLock);
            }
        }

 /// <summary>
 /// Pause the audio
 /// </summary>
 public void Pause()
 {
     if (playbackState == PlaybackState.Playing)
     {
         MmResult result;
         lock (waveOutLock)
         {
             result = WaveInterop.waveOutPause(hWaveOut);
         }
         if (result != MmResult.NoError)
         {
             throw new MmException(result, "waveOutPause");
         }
         playbackState = PlaybackState.Paused;
     }
 }

 /// <summary>
 /// Resume playing after a pause from the same position
 /// </summary>
 private void Resume()
 {
     if (playbackState == PlaybackState.Paused)
     {
         MmResult result;
         lock (waveOutLock)
         {
             result = WaveInterop.waveOutRestart(hWaveOut);
         }
         if (result != MmResult.NoError)
         {
             throw new MmException(result, "waveOutRestart");
         }
         playbackState = PlaybackState.Playing;
     }
 }

 /// <summary>
 /// Start playing the audio from the WaveStream
 /// </summary>
 public void Play()
 {
     if (playbackState == PlaybackState.Stopped)
     {
         playbackState = PlaybackState.Playing;
         Debug.Assert(queuedBuffers == 0, "Buffers already queued on play");
         EnqueueBuffers();
     }
     else if (playbackState == PlaybackState.Paused)
     {
         EnqueueBuffers();
         Resume();
         playbackState = PlaybackState.Playing;
     }
 }

        /// <summary>
        /// Initialises the WaveOut device
        /// </summary>
        /// <param name="waveProvider">WaveProvider to play</param>
        public void Init(IWaveProvider waveProvider)
        {
            if (playbackState != PlaybackState.Stopped)
            {
                throw new InvalidOperationException("Can't re-initialize during playback");
            }
            if (hWaveOut != IntPtr.Zero)
            {
                // normally we don't allow calling Init twice, but as experiment, see if we can clean up and go again
                // try to allow reuse of this waveOut device
                // n.b. risky if Playback thread has not exited
                DisposeBuffers();
                CloseWaveOut();
            }

            this.callbackEvent = new AutoResetEvent(false);

            this.waveStream = waveProvider;
            int bufferSize = waveProvider.WaveFormat.ConvertLatencyToByteSize((DesiredLatency + NumberOfBuffers - 1) / NumberOfBuffers);            

            MmResult result;
            lock (waveOutLock)
            {
                result = WaveInterop.waveOutOpenWindow(out hWaveOut, (IntPtr)DeviceNumber, waveStream.WaveFormat, callbackEvent.SafeWaitHandle.DangerousGetHandle(), IntPtr.Zero, WaveInterop.WaveInOutOpenFlags.CallbackEvent);
            }
            MmException.Try(result, "waveOutOpen");

            buffers = new WaveOutBuffer[NumberOfBuffers];
            playbackState = PlaybackState.Stopped;
            for (int n = 0; n < NumberOfBuffers; n++)
            {
                buffers[n] = new WaveOutBuffer(hWaveOut, bufferSize, waveStream, waveOutLock);
            }
        }

        /// <summary>
        /// Stop and reset the WaveOut device
        /// </summary>
        public void Stop()
        {
            if (playbackState != PlaybackState.Stopped)
            {

                // in the call to waveOutReset with function callbacks
                // some drivers will block here until OnDone is called
                // for every buffer
                playbackState = PlaybackState.Stopped; // set this here to avoid a problem with some drivers whereby
                MmResult result;
                lock (waveOutLock)
                {
                    result = WaveInterop.waveOutReset(hWaveOut);
                }
                if (result != MmResult.NoError)
                {
                    throw new MmException(result, "waveOutReset");
                }

                // with function callbacks, waveOutReset will call OnDone,
                // and so PlaybackStopped must not be raised from the handler
                // we know playback has definitely stopped now, so raise callback
                if (callbackInfo.Strategy == WaveCallbackStrategy.FunctionCallback)
                {
                    RaisePlaybackStoppedEvent(null);
                }
            }
        }