protected override void MediaPlayerEventOccured(ref libvlc_event_t libvlc_event, IntPtr userData)
{
switch (libvlc_event.type)
{
case libvlc_event_e.libvlc_MediaListPlayerPlayed:
if (m_mediaListPlayerPlayed != null)
{
m_mediaListPlayerPlayed(m_eventProvider, EventArgs.Empty);
}
break;
case libvlc_event_e.libvlc_MediaListPlayerNextItemSet:
if (m_mediaListPlayerNextItemSet != null)
{
BasicMedia media = new BasicMedia(libvlc_event.MediaDescriptor.media_list_player_next_item_set.item, ReferenceCountAction.AddRef);
m_mediaListPlayerNextItemSet(m_eventProvider, new MediaListPlayerNextItemSet(media));
//media.Release();
}
break;
case libvlc_event_e.libvlc_MediaListPlayerStopped:
if (m_mediaListPlayerStopped != null)
{
m_mediaListPlayerStopped(m_eventProvider, EventArgs.Empty);
}
break;
}
}
/**
* Create an event.
*
* @param event native event
* @return media list event, or <code>null</code> if the native event type is not enabled or otherwise could not be handled
*/
public MediaListEvent CreateEvent(libvlc_event_t evt)
{
// Create an event suitable for the native event type...
MediaListEvent result = null;
switch (evt.type)
{
case libvlc_event_e.libvlc_MediaListWillAddItem:
//result = new MediaListWillAddItemEvent(mediaList, evt.u.media_list_event.item, evt.u.media_list_event.index); // FIXME
break;
case libvlc_event_e.libvlc_MediaListItemAdded:
//result = new MediaListItemAddedEvent(mediaList, evt.u.media_list_event.item, evt.u.media_list_event.index);
break;
case libvlc_event_e.libvlc_MediaListWillDeleteItem:
//result = new MediaListWillDeleteItemEvent(mediaList, evt.u.media_list_event.item, evt.u.media_list_event.index);
break;
case libvlc_event_e.libvlc_MediaListItemDeleted:
//result = new MediaListItemDeletedEvent(mediaList, evt.u.media_list_event.item, evt.u.media_list_event.index);
break;
}
return(result);
}
private void OnVlcEvent(ref libvlc_event_t type, IntPtr userdata)
{
switch (type.type)
{
case libvlc_event_e.MediaMetaChanged:
EventsHelper.RaiseEvent(MetaChanged, this, new VlcEventArgs <MetaTypes>((MetaTypes)type.media_meta_changed.meta_type));
break;
case libvlc_event_e.MediaSubItemAdded:
//TODO
//EventsHelper.RaiseEvent(SubItemAdded, this, new VlcEventArgs<MetaData>((MetaData)type.media_subitem_added.new_child));
break;
case libvlc_event_e.MediaDurationChanged:
EventsHelper.RaiseEvent(DurationChanged, this, new VlcEventArgs <long>(type.media_duration_changed.new_duration));
break;
case libvlc_event_e.MediaParsedChanged:
EventsHelper.RaiseEvent(ParsedChanged, this, new VlcEventArgs <int>(type.media_parsed_changed.new_status));
break;
case libvlc_event_e.MediaFreed:
//TODO
//EventsHelper.RaiseEvent(Freed, this, new VlcEventArgs<MediaBase>(type.media_freed.md));
break;
case libvlc_event_e.MediaStateChanged:
EventsHelper.RaiseEvent(StateChanged, this, new VlcEventArgs <MediaStates>((MediaStates)type.media_state_changed.new_state));
break;
}
}
protected override void MediaPlayerEventOccured(ref libvlc_event_t libvlc_event, IntPtr userData)
{
switch (libvlc_event.type)
{
case libvlc_event_e.libvlc_MediaMetaChanged:
if (metaDataChanged != null)
{
metaDataChanged(m_eventProvider, new MediaMetaDataChange((MetaDataType)libvlc_event.MediaDescriptor.media_meta_changed.meta_type));
}
break;
case libvlc_event_e.libvlc_MediaSubItemAdded:
if (subItemAdded != null)
{
BasicMedia media = new BasicMedia(libvlc_event.MediaDescriptor.media_subitem_added.new_child, ReferenceCountAction.AddRef);
subItemAdded(m_eventProvider, new MediaNewSubItem(media));
media.Release();
}
break;
case libvlc_event_e.libvlc_MediaDurationChanged:
if (durationChanged != null)
{
durationChanged(m_eventProvider, new MediaDurationChange(libvlc_event.MediaDescriptor.media_duration_changed.new_duration));
}
break;
case libvlc_event_e.libvlc_MediaParsedChanged:
if (parsedChanged != null)
{
parsedChanged(m_eventProvider, new MediaParseChange(Convert.ToBoolean(libvlc_event.MediaDescriptor.media_parsed_changed.new_status)));
}
break;
case libvlc_event_e.libvlc_MediaFreed:
if (mediaFreed != null)
{
mediaFreed(m_eventProvider, new MediaFree(libvlc_event.MediaDescriptor.media_freed.md));
}
break;
case libvlc_event_e.libvlc_MediaStateChanged:
if (stateChanged != null)
{
stateChanged(m_eventProvider, new MediaStateChange((MediaState)libvlc_event.MediaDescriptor.media_state_changed.new_state));
}
break;
default:
break;
}
}
/**
* Create a new media player event for a given native event.
*
* @param event native event
* @param eventMask bit mask of enabled events (i.e. events to send notifications for)
* @return media player event, or <code>null</code> if the native event type is not enabled or otherwise could not be handled
*/
public MediaListPlayerEvent newMediaListPlayerEvent(libvlc_event_t evt, int eventMask)
{
// Create an event suitable for the native event type...
MediaListPlayerEvent result = null;
switch (evt.type)
{
// === Events relating to the media list player =========================
case libvlc_event_e.libvlc_MediaListPlayerNextItemSet:
// if(MediaPlayerEventType.set(eventMask, MediaPlayerEventType.MEDIA_CHANGED)) {
IntPtr media = evt.u.item;
result = new MediaListPlayerNextItemSetEvent(mediaListPlayer, media, mediaListPlayer.Mrl(media));
// }
break;
// === Events relating to the current media =============================
case libvlc_event_e.libvlc_MediaMetaChanged:
// if(MediaPlayerEventType.set(eventMask, MediaPlayerEventType.MEDIA_META_CHANGED)) {
result = new MediaListMediaMetaChangedEvent(mediaListPlayer, evt.u.meta_type);
// }
break;
case libvlc_event_e.libvlc_MediaSubItemAdded:
// if(MediaPlayerEventType.set(eventMask, MediaPlayerEventType.MEDIA_SUB_ITEM_ADDED)) {
result = new MediaListMediaSubItemAddedEvent(mediaListPlayer, evt.u.new_child);
// }
break;
case libvlc_event_e.libvlc_MediaDurationChanged:
// if(MediaPlayerEventType.set(eventMask, MediaPlayerEventType.MEDIA_DURATION_CHANGED)) {
result = new MediaListMediaDurationChangedEvent(mediaListPlayer, evt.u.new_duration);
// }
break;
case libvlc_event_e.libvlc_MediaParsedChanged:
// if(MediaPlayerEventType.set(eventMask, MediaPlayerEventType.MEDIA_PARSED_CHANGED)) {
result = new MediaListMediaParsedChangedEvent(mediaListPlayer, evt.u.new_status);
// }
break;
case libvlc_event_e.libvlc_MediaFreed:
// if(MediaPlayerEventType.set(eventMask, MediaPlayerEventType.MEDIA_FREED)) {
result = new MediaListMediaFreedEvent(mediaListPlayer);
// }
break;
case libvlc_event_e.libvlc_MediaStateChanged:
// if(MediaPlayerEventType.set(eventMask, MediaPlayerEventType.MEDIA_STATE_CHANGED)) {
result = new MediaListMediaStateChangedEvent(mediaListPlayer, evt.u.new_state);
// }
break;
}
return(result);
}
/**
* A call-back to handle events from the native media list.
* <p>
* There are some important implementation details for this callback:
* <ul>
* <li>First, the event notifications are off-loaded to a different thread so as to prevent
* application code re-entering libvlc in an event call-back which may lead to a deadlock in the
* native code;</li>
* <li>Second, the native event union structure refers to natively allocated memory which will
* not be in the scope of the thread used to actually dispatch the event notifications.</li>
* </ul>
* Without copying the fields at this point from the native union structure, the native memory
* referred to by the native event is likely to get deallocated and overwritten by the time the
* notification thread runs. This would lead to unreliable data being sent with the
* notification, or even a fatal JVM crash.
*
* @param evt event
* @param data user data (unused)
*/
private void HandleEvent(IntPtr evt, IntPtr data)
{
if (eventListenerList.Count > 0)
{
libvlc_event_t e = (libvlc_event_t)Marshal.PtrToStructure(evt, typeof(libvlc_event_t));
// Create a new media player event for the native event
// RaiseEvent(eventFactory.CreateEvent(evt, eventMask));
RaiseEvent(eventFactory.CreateEvent(e));
}
}
protected override void MediaPlayerEventOccured(ref libvlc_event_t libvlc_event, IntPtr userData)
{
switch (libvlc_event.type)
{
case libvlc_event_e.libvlc_MediaDiscovererStarted:
break;
case libvlc_event_e.libvlc_MediaDiscovererEnded:
break;
}
}
protected override void MediaPlayerEventOccured(ref libvlc_event_t libvlc_event, IntPtr userData)
{
switch (libvlc_event.type)
{
case libvlc_event_e.libvlc_MediaListItemAdded:
if (m_itemAdded != null)
{
BasicMedia media = new BasicMedia(libvlc_event.MediaDescriptor.media_list_item_added.item, ReferenceCountAction.AddRef);
m_itemAdded(m_eventProvider, new MediaListItemAdded(media, libvlc_event.MediaDescriptor.media_list_item_added.index));
media.Release();
}
break;
case libvlc_event_e.libvlc_MediaListWillAddItem:
if (m_willAddItem != null)
{
BasicMedia media2 = new BasicMedia(libvlc_event.MediaDescriptor.media_list_will_add_item.item, ReferenceCountAction.AddRef);
m_willAddItem(m_eventProvider, new MediaListWillAddItem(media2, libvlc_event.MediaDescriptor.media_list_will_add_item.index));
media2.Release();
}
break;
case libvlc_event_e.libvlc_MediaListItemDeleted:
if (m_itemDeleted != null)
{
BasicMedia media3 = new BasicMedia(libvlc_event.MediaDescriptor.media_list_item_deleted.item, ReferenceCountAction.AddRef);
m_itemDeleted(m_eventProvider, new MediaListItemDeleted(media3, libvlc_event.MediaDescriptor.media_list_item_deleted.index));
media3.Release();
}
break;
case libvlc_event_e.libvlc_MediaListWillDeleteItem:
if (m_willDeleteItem != null)
{
BasicMedia media4 = new BasicMedia(libvlc_event.MediaDescriptor.media_list_will_delete_item.item, ReferenceCountAction.AddRef);
m_willDeleteItem(m_eventProvider, new MediaListWillDeleteItem(media4, libvlc_event.MediaDescriptor.media_list_will_delete_item.index));
media4.Release();
}
break;
case libvlc_event_e.libvlc_MediaListEndReached:
if (m_endReached != null)
{
m_endReached(m_eventProvider, EventArgs.Empty);
}
break;
default:
throw new InvalidOperationException(string.Format("Unknown event type {0}", libvlc_event.type));
}
}
private void HandleEvent(IntPtr evt, IntPtr data)
{
if (eventListenerList.Count > 0)
{
libvlc_event_t e = (libvlc_event_t)Marshal.PtrToStructure(evt, typeof(libvlc_event_t));
// Create a new media player event for the native event
// MediaListPlayerEvent mediaListPlayerEvent = eventFactory.newMediaListPlayerEvent(e, eventMask);
MediaListPlayerEvent mediaListPlayerEvent = eventFactory.newMediaListPlayerEvent(e, 0);
Logger.Trace("mediaListPlayerEvent={}", mediaListPlayerEvent);
if (mediaListPlayerEvent != null)
{
listenersService.Submit(new NotifyListenersRunnable(this, mediaListPlayerEvent));
}
}
} // FIXME refactor part to separate raiseEvent like main player?
protected override void MediaPlayerEventOccured(ref libvlc_event_t libvlc_event, IntPtr userData)
{
switch (libvlc_event.type)
{
case libvlc_event_e.libvlc_MediaDiscovererStarted:
if (m_mediaDiscoveryStarted != null)
{
m_mediaDiscoveryStarted(this, EventArgs.Empty);
}
break;
case libvlc_event_e.libvlc_MediaDiscovererEnded:
if (m_mediaDiscoveryEnded != null)
{
m_mediaDiscoveryEnded(this, EventArgs.Empty);
}
break;
}
}
protected override void MediaPlayerEventOccured(ref libvlc_event_t libvlc_event, IntPtr userData)
{
switch (libvlc_event.type)
{
case libvlc_event_e.libvlc_MediaListItemAdded:
if (m_itemAdded != null)
{
BasicMedia media = new BasicMedia(libvlc_event.MediaDescriptor.media_list_item_added.item, ReferenceCountAction.AddRef);
m_itemAdded(m_eventProvider, new MediaListItemAdded(media, libvlc_event.MediaDescriptor.media_list_item_added.index));
media.Release();
}
break;
case libvlc_event_e.libvlc_MediaListWillAddItem:
if (m_willAddItem != null)
{
BasicMedia media2 = new BasicMedia(libvlc_event.MediaDescriptor.media_list_will_add_item.item, ReferenceCountAction.AddRef);
m_willAddItem(m_eventProvider, new MediaListWillAddItem(media2, libvlc_event.MediaDescriptor.media_list_will_add_item.index));
media2.Release();
}
break;
case libvlc_event_e.libvlc_MediaListItemDeleted:
if (m_itemDeleted != null)
{
BasicMedia media3 = new BasicMedia(libvlc_event.MediaDescriptor.media_list_item_deleted.item, ReferenceCountAction.AddRef);
m_itemDeleted(m_eventProvider, new MediaListItemDeleted(media3, libvlc_event.MediaDescriptor.media_list_item_deleted.index));
media3.Release();
}
break;
case libvlc_event_e.libvlc_MediaListWillDeleteItem:
if (m_willDeleteItem != null)
{
BasicMedia media4 = new BasicMedia(libvlc_event.MediaDescriptor.media_list_will_delete_item.item, ReferenceCountAction.AddRef);
m_willDeleteItem(m_eventProvider, new MediaListWillDeleteItem(media4, libvlc_event.MediaDescriptor.media_list_will_delete_item.index));
media4.Release();
}
break;
}
}
protected override void MediaPlayerEventOccured(ref libvlc_event_t libvlc_event, IntPtr userData)
{
switch (libvlc_event.type)
{
case libvlc_event_e.libvlc_RendererDiscovererItemAdded:
if (m_rendererDiscovererItemAdded != null)
{
var item = libvlc_event.MediaDescriptor.renderer_discoverer_item_added.item;
RendererItem renderItem = new RendererItem(item);
m_rendererDiscovererItemAdded(this, new RendererItemChanged(renderItem));
}
break;
case libvlc_event_e.libvlc_RendererDiscovererItemDeleted:
if (m_rendererDiscovererItemDeleted != null)
{
var item = libvlc_event.MediaDescriptor.renderer_discoverer_item_deleted.item;
RendererItem renderItem = new RendererItem(item);
m_rendererDiscovererItemDeleted(this, new RendererItemChanged(renderItem));
}
break;
}
}
protected override void MediaPlayerEventOccured(ref libvlc_event_t libvlc_event, IntPtr userData)
{
switch (libvlc_event.type)
{
case libvlc_event_e.libvlc_MediaPlayerTimeChanged:
RaiseTimeChanged(libvlc_event.MediaDescriptor.media_player_time_changed.new_time);
break;
case libvlc_event_e.libvlc_MediaPlayerEndReached:
RaiseMediaEnded();
break;
case libvlc_event_e.libvlc_MediaPlayerMediaChanged:
if (m_mediaChanged != null)
{
BasicMedia media = new BasicMedia(libvlc_event.MediaDescriptor.media_player_media_changed.new_media, ReferenceCountAction.AddRef);
m_mediaChanged(m_eventProvider, new MediaPlayerMediaChanged(media));
//media.Release();
}
break;
case libvlc_event_e.libvlc_MediaPlayerNothingSpecial:
if (m_nothingSpecial != null)
{
m_nothingSpecial(m_eventProvider, EventArgs.Empty);
}
break;
case libvlc_event_e.libvlc_MediaPlayerOpening:
if (m_playerOpening != null)
{
m_playerOpening(m_eventProvider, EventArgs.Empty);
}
break;
case libvlc_event_e.libvlc_MediaPlayerBuffering:
if (m_playerBuffering != null)
{
m_playerBuffering(m_eventProvider, EventArgs.Empty);
}
break;
case libvlc_event_e.libvlc_MediaPlayerPlaying:
if (m_playerPlaying != null)
{
m_playerPlaying(m_eventProvider, EventArgs.Empty);
}
break;
case libvlc_event_e.libvlc_MediaPlayerPaused:
if (m_playerPaused != null)
{
m_playerPaused(m_eventProvider, EventArgs.Empty);
}
break;
case libvlc_event_e.libvlc_MediaPlayerStopped:
if (m_playerStopped != null)
{
m_playerStopped(m_eventProvider, EventArgs.Empty);
}
break;
case libvlc_event_e.libvlc_MediaPlayerForward:
if (m_playerForward != null)
{
m_playerForward(m_eventProvider, EventArgs.Empty);
}
break;
case libvlc_event_e.libvlc_MediaPlayerBackward:
if (m_playerPaused != null)
{
m_playerPaused(m_eventProvider, EventArgs.Empty);
}
break;
case libvlc_event_e.libvlc_MediaPlayerEncounteredError:
if (m_playerEncounteredError != null)
{
m_playerEncounteredError(m_eventProvider, EventArgs.Empty);
}
break;
case libvlc_event_e.libvlc_MediaPlayerPositionChanged:
if (m_playerPositionChanged != null)
{
m_playerPositionChanged(m_eventProvider, new MediaPlayerPositionChanged(libvlc_event.MediaDescriptor.media_player_position_changed.new_position));
}
break;
case libvlc_event_e.libvlc_MediaPlayerSeekableChanged:
if (m_playerSeekableChanged != null)
{
m_playerSeekableChanged(m_eventProvider, new MediaPlayerSeekableChanged(libvlc_event.MediaDescriptor.media_player_seekable_changed.new_seekable));
}
break;
case libvlc_event_e.libvlc_MediaPlayerPausableChanged:
if (m_playerPausableChanged != null)
{
m_playerPausableChanged(m_eventProvider, new MediaPlayerPausableChanged(libvlc_event.MediaDescriptor.media_player_pausable_changed.new_pausable));
}
break;
case libvlc_event_e.libvlc_MediaPlayerTitleChanged:
if (m_playerTitleChanged != null)
{
m_playerTitleChanged(m_eventProvider, new MediaPlayerTitleChanged(libvlc_event.MediaDescriptor.media_player_title_changed.new_title));
}
break;
case libvlc_event_e.libvlc_MediaPlayerSnapshotTaken:
if (m_playerSnapshotTaken != null)
{
m_playerSnapshotTaken(m_eventProvider, new MediaPlayerSnapshotTaken(Marshal.PtrToStringAuto(libvlc_event.MediaDescriptor.media_player_snapshot_taken.psz_filename)));
}
break;
case libvlc_event_e.libvlc_MediaPlayerLengthChanged:
if (m_playerLengthChanged != null)
{
m_playerLengthChanged(m_eventProvider, new MediaPlayerLengthChanged(libvlc_event.MediaDescriptor.media_player_length_changed.new_length));
}
break;
}
}
protected override void MediaPlayerEventOccured(ref libvlc_event_t libvlc_event, IntPtr userData)
{
switch (libvlc_event.type)
{
case libvlc_event_e.libvlc_VlmMediaAdded:
if (m_MediaAdded != null)
{
m_MediaAdded(m_eventProvider, new VlmEvent(Marshal.PtrToStringAuto(libvlc_event.vlm_media_event.psz_instance_name), Marshal.PtrToStringAuto(libvlc_event.vlm_media_event.psz_media_name)));
}
break;
case libvlc_event_e.libvlc_VlmMediaRemoved:
if (m_MediaRemoved != null)
{
m_MediaRemoved(m_eventProvider, new VlmEvent(Marshal.PtrToStringAuto(libvlc_event.vlm_media_event.psz_instance_name), Marshal.PtrToStringAuto(libvlc_event.vlm_media_event.psz_media_name)));
}
break;
case libvlc_event_e.libvlc_VlmMediaChanged:
if (m_MediaChanged != null)
{
m_MediaChanged(m_eventProvider, new VlmEvent(Marshal.PtrToStringAuto(libvlc_event.vlm_media_event.psz_instance_name), Marshal.PtrToStringAuto(libvlc_event.vlm_media_event.psz_media_name)));
}
break;
case libvlc_event_e.libvlc_VlmMediaInstanceStarted:
if (m_MediaInstanceStarted != null)
{
m_MediaInstanceStarted(m_eventProvider, new VlmEvent(Marshal.PtrToStringAuto(libvlc_event.vlm_media_event.psz_instance_name), Marshal.PtrToStringAuto(libvlc_event.vlm_media_event.psz_media_name)));
}
break;
case libvlc_event_e.libvlc_VlmMediaInstanceStopped:
if (m_MediaInstanceStopped != null)
{
m_MediaInstanceStopped(m_eventProvider, new VlmEvent(Marshal.PtrToStringAuto(libvlc_event.vlm_media_event.psz_instance_name), Marshal.PtrToStringAuto(libvlc_event.vlm_media_event.psz_media_name)));
}
break;
case libvlc_event_e.libvlc_VlmMediaInstanceStatusInit:
if (m_MediaInstanceInit != null)
{
m_MediaInstanceInit(m_eventProvider, new VlmEvent(Marshal.PtrToStringAuto(libvlc_event.vlm_media_event.psz_instance_name), Marshal.PtrToStringAuto(libvlc_event.vlm_media_event.psz_media_name)));
}
break;
case libvlc_event_e.libvlc_VlmMediaInstanceStatusOpening:
if (m_MediaInstanceOpening != null)
{
m_MediaInstanceOpening(m_eventProvider, new VlmEvent(Marshal.PtrToStringAuto(libvlc_event.vlm_media_event.psz_instance_name), Marshal.PtrToStringAuto(libvlc_event.vlm_media_event.psz_media_name)));
}
break;
case libvlc_event_e.libvlc_VlmMediaInstanceStatusPlaying:
if (m_MediaInstancePlaying != null)
{
m_MediaInstancePlaying(m_eventProvider, new VlmEvent(Marshal.PtrToStringAuto(libvlc_event.vlm_media_event.psz_instance_name), Marshal.PtrToStringAuto(libvlc_event.vlm_media_event.psz_media_name)));
}
break;
case libvlc_event_e.libvlc_VlmMediaInstanceStatusPause:
if (m_MediaInstancePause != null)
{
m_MediaInstancePause(m_eventProvider, new VlmEvent(Marshal.PtrToStringAuto(libvlc_event.vlm_media_event.psz_instance_name), Marshal.PtrToStringAuto(libvlc_event.vlm_media_event.psz_media_name)));
}
break;
case libvlc_event_e.libvlc_VlmMediaInstanceStatusEnd:
if (m_MediaInstanceEnd != null)
{
m_MediaInstanceEnd(m_eventProvider, new VlmEvent(Marshal.PtrToStringAuto(libvlc_event.vlm_media_event.psz_instance_name), Marshal.PtrToStringAuto(libvlc_event.vlm_media_event.psz_media_name)));
}
break;
case libvlc_event_e.libvlc_VlmMediaInstanceStatusError:
if (m_MediaInstanceError != null)
{
m_MediaInstanceError(m_eventProvider, new VlmEvent(Marshal.PtrToStringAuto(libvlc_event.vlm_media_event.psz_instance_name), Marshal.PtrToStringAuto(libvlc_event.vlm_media_event.psz_media_name)));
}
break;
default:
break;
}
}
private void OnVlcEvent(ref libvlc_event_t eventData, IntPtr userData)
{
switch (eventData.type)
{
case libvlc_event_e.MediaPlayerBackward:
EventsHelper.RaiseEvent(Backward, this, new VlcEventArgs <EventArgs>(EventArgs.Empty));
break;
case libvlc_event_e.MediaPlayerBuffering:
EventsHelper.RaiseEvent(Buffering, this, new VlcEventArgs <float>(eventData.media_player_buffering.new_cache));
break;
case libvlc_event_e.MediaPlayerEncounteredError:
EventsHelper.RaiseEvent(EncounteredError, this, new VlcEventArgs <EventArgs>(EventArgs.Empty));
break;
case libvlc_event_e.MediaPlayerEndReached:
EventsHelper.RaiseEvent(EndReached, this, new VlcEventArgs <EventArgs>(EventArgs.Empty));
break;
case libvlc_event_e.MediaPlayerForward:
EventsHelper.RaiseEvent(Forward, this, new VlcEventArgs <EventArgs>(EventArgs.Empty));
break;
case libvlc_event_e.MediaPlayerLengthChanged:
EventsHelper.RaiseEvent(LengthChanged, this, new VlcEventArgs <long>(eventData.media_player_length_changed.new_length));
break;
case libvlc_event_e.MediaPlayerMediaChanged:
//TODO
//EventsHelper.RaiseEvent(MediaChanged, this, new VlcEventArgs<MediaBase>(eventData.media_player_media_changed.new_media));
break;
case libvlc_event_e.MediaPlayerNothingSpecial:
break;
case libvlc_event_e.MediaPlayerOpening:
break;
case libvlc_event_e.MediaPlayerPausableChanged:
EventsHelper.RaiseEvent(PausableChanged, this, new VlcEventArgs <int>(eventData.media_player_pausable_changed.new_pausable));
break;
case libvlc_event_e.MediaPlayerPaused:
EventsHelper.RaiseEvent(Paused, this, new VlcEventArgs <EventArgs>(EventArgs.Empty));
break;
case libvlc_event_e.MediaPlayerPositionChanged:
EventsHelper.RaiseEvent(PositionChanged, this, new VlcEventArgs <float>(eventData.media_player_position_changed.new_position));
break;
case libvlc_event_e.MediaPlayerSeekableChanged:
EventsHelper.RaiseEvent(SeekableChanged, this, new VlcEventArgs <int>(eventData.media_player_seekable_changed.new_seekable));
break;
case libvlc_event_e.MediaPlayerSnapshotTaken:
EventsHelper.RaiseEvent(SnapshotTaken, this, new VlcEventArgs <string>(IntPtrExtensions.ToStringAnsi(eventData.media_player_snapshot_taken.psz_filename)));
break;
case libvlc_event_e.MediaPlayerStopped:
EventsHelper.RaiseEvent(Stopped, this, new VlcEventArgs <EventArgs>(EventArgs.Empty));
break;
case libvlc_event_e.MediaPlayerTimeChanged:
EventsHelper.RaiseEvent(TimeChanged, this, new VlcEventArgs <long>(eventData.media_player_time_changed.new_time));
break;
case libvlc_event_e.MediaPlayerTitleChanged:
EventsHelper.RaiseEvent(TitleChanged, this, new VlcEventArgs <long>(eventData.media_player_title_changed.new_title));
break;
}
}
protected abstract void MediaPlayerEventOccured(ref libvlc_event_t libvlc_event, IntPtr userData);
/**
* Create a new media player event for a given native event.
*
* @param event native event
* @param eventMask bit mask of enabled events (i.e. events to send notifications for)
* @return media player event, or <code>null</code> if the native event type is not enabled or otherwise could not be handled
*/
public MediaPlayerEvent CreateEvent(libvlc_event_t evt, int eventMask)
{
// Create an event suitable for the native event type...
MediaPlayerEvent result = null;
switch (evt.type)
{
// === Events relating to the media player ==============================
case libvlc_event_e.libvlc_MediaPlayerMediaChanged:
// if(MediaPlayerEventType.set(eventMask, MediaPlayerEventType.MEDIA_CHANGED)) {
result = new MediaPlayerMediaChangedEvent(mediaPlayer, evt.u.md, mediaPlayer.Mrl(evt.u.md));
// }
break;
case libvlc_event_e.libvlc_MediaPlayerNothingSpecial:
// if(MediaPlayerEventType.set(eventMask, MediaPlayerEventType.MEDIA_CHANGED)) {
result = new MediaPlayerNothingSpecialEvent(mediaPlayer);
// }
break;
case libvlc_event_e.libvlc_MediaPlayerOpening:
// if(MediaPlayerEventType.set(eventMask, MediaPlayerEventType.OPENING)) {
result = new MediaPlayerOpeningEvent(mediaPlayer);
// }
break;
case libvlc_event_e.libvlc_MediaPlayerBuffering:
// if(MediaPlayerEventType.set(eventMask, MediaPlayerEventType.BUFFERING)) {
result = new MediaPlayerBufferingEvent(mediaPlayer, evt.u.new_cache);
// }
break;
case libvlc_event_e.libvlc_MediaPlayerPlaying:
// if(MediaPlayerEventType.set(eventMask, MediaPlayerEventType.PLAYING)) {
result = new MediaPlayerPlayingEvent(mediaPlayer);
// }
break;
case libvlc_event_e.libvlc_MediaPlayerPaused:
// if(MediaPlayerEventType.set(eventMask, MediaPlayerEventType.PAUSED)) {
result = new MediaPlayerPausedEvent(mediaPlayer);
// }
break;
case libvlc_event_e.libvlc_MediaPlayerStopped:
// if(MediaPlayerEventType.set(eventMask, MediaPlayerEventType.STOPPED)) {
result = new MediaPlayerStoppedEvent(mediaPlayer);
// }
break;
case libvlc_event_e.libvlc_MediaPlayerForward:
// if(MediaPlayerEventType.set(eventMask, MediaPlayerEventType.FORWARD)) {
result = new MediaPlayerForwardEvent(mediaPlayer);
// }
break;
case libvlc_event_e.libvlc_MediaPlayerBackward:
// if(MediaPlayerEventType.set(eventMask, MediaPlayerEventType.BACKWARD)) {
result = new MediaPlayerBackwardEvent(mediaPlayer);
// }
break;
case libvlc_event_e.libvlc_MediaPlayerEndReached:
// if(MediaPlayerEventType.set(eventMask, MediaPlayerEventType.FINISHED)) {
result = new MediaPlayerEndReachedEvent(mediaPlayer);
// }
break;
case libvlc_event_e.libvlc_MediaPlayerEncounteredError:
// if(MediaPlayerEventType.set(eventMask, MediaPlayerEventType.ERROR)) {
result = new MediaPlayerEncounteredErrorEvent(mediaPlayer);
// }
break;
case libvlc_event_e.libvlc_MediaPlayerTimeChanged:
// if(MediaPlayerEventType.set(eventMask, MediaPlayerEventType.TIME_CHANGED)) {
result = new MediaPlayerTimeChangedEvent(mediaPlayer, evt.u.new_time);
// }
break;
case libvlc_event_e.libvlc_MediaPlayerPositionChanged:
// if(MediaPlayerEventType.set(eventMask, MediaPlayerEventType.POSITION_CHANGED)) {
result = new MediaPlayerPositionChangedEvent(mediaPlayer, evt.u.new_position);
// }
break;
case libvlc_event_e.libvlc_MediaPlayerSeekableChanged:
// if(MediaPlayerEventType.set(eventMask, MediaPlayerEventType.SEEKABLE_CHANGED)) {
result = new MediaPlayerSeekableChangedEvent(mediaPlayer, evt.u.new_seekable);
// }
break;
case libvlc_event_e.libvlc_MediaPlayerPausableChanged:
// if(MediaPlayerEventType.set(eventMask, MediaPlayerEventType.PAUSABLE_CHANGED)) {
result = new MediaPlayerPausableChangedEvent(mediaPlayer, evt.u.new_pausable);
// }
break;
case libvlc_event_e.libvlc_MediaPlayerTitleChanged:
// if(MediaPlayerEventType.set(eventMask, MediaPlayerEventType.TITLE_CHANGED)) {
result = new MediaPlayerTitleChangedEvent(mediaPlayer, evt.u.new_title);
// }
break;
case libvlc_event_e.libvlc_MediaPlayerSnapshotTaken:
// if(MediaPlayerEventType.set(eventMask, MediaPlayerEventType.SNAPSHOT_TAKEN)) {
result = new MediaPlayerSnapshotTakenEvent(mediaPlayer, NativeString.String(evt.u.psz_filename));
// }
break;
case libvlc_event_e.libvlc_MediaPlayerLengthChanged:
// if(MediaPlayerEventType.set(eventMask, MediaPlayerEventType.LENGTH_CHANGED)) {
result = new MediaPlayerLengthChangedEvent(mediaPlayer, evt.u.new_length);
// }
break;
case libvlc_event_e.libvlc_MediaPlayerVout:
// if(MediaPlayerEventType.set(eventMask, MediaPlayerEventType.VIDEO_OUTPUT)) {
result = new MediaPlayerVoutEvent(mediaPlayer, evt.u.new_count);
// }
break;
// === Events relating to the current media =============================
case libvlc_event_e.libvlc_MediaMetaChanged:
// if(MediaPlayerEventType.set(eventMask, MediaPlayerEventType.MEDIA_META_CHANGED)) {
result = new MediaMetaChangedEvent(mediaPlayer, evt.u.meta_type);
// }
break;
case libvlc_event_e.libvlc_MediaSubItemAdded:
// if(MediaPlayerEventType.set(eventMask, MediaPlayerEventType.MEDIA_SUB_ITEM_ADDED)) {
result = new MediaSubItemAddedEvent(mediaPlayer, evt.u.new_child);
// }
break;
case libvlc_event_e.libvlc_MediaDurationChanged:
// if(MediaPlayerEventType.set(eventMask, MediaPlayerEventType.MEDIA_DURATION_CHANGED)) {
result = new MediaDurationChangedEvent(mediaPlayer, evt.u.new_duration);
// }
break;
case libvlc_event_e.libvlc_MediaParsedChanged:
// if(MediaPlayerEventType.set(eventMask, MediaPlayerEventType.MEDIA_PARSED_CHANGED)) {
result = new MediaParsedChangedEvent(mediaPlayer, evt.u.new_status);
// }
break;
case libvlc_event_e.libvlc_MediaFreed:
// if(MediaPlayerEventType.set(eventMask, MediaPlayerEventType.MEDIA_FREED)) {
result = new MediaFreedEvent(mediaPlayer);
// }
break;
case libvlc_event_e.libvlc_MediaStateChanged:
// if(MediaPlayerEventType.set(eventMask, MediaPlayerEventType.MEDIA_STATE_CHANGED)) {
result = new MediaStateChangedEvent(mediaPlayer, evt.u.new_state);
// }
break;
}
return(result);
}
private void VlcEventHandler(ref libvlc_event_t libvlc_event, IntPtr userData)
{
}
