/// <summary>
/// Waits for the specified event.
/// </summary>
/// <param name="desiredEventCode">event code to wait for</param>
/// <param name="msTimeout">timeout</param>
/// <param name="actuallyReceivedEventCode">The event actually received, or "0" if no event was received</param>
/// <param name="param">1st parameter associated with event</param>
/// <returns>True if the desired event was received. False if timed out, or different event received</returns>
public bool WaitForEvent(EventCode desiredEventCode, int msTimeout, out EventCode actuallyReceivedEventCode, out int param)
{
bool restartTimer = false;
if (_mediaSeekTimer.Enabled)
{
_mediaSeekTimer.Stop();
restartTimer = true;
}
int hr = 0;
IntPtr lparam1, lparam2;
hr = _mediaEvent.GetEvent(out actuallyReceivedEventCode, out lparam1, out lparam2, msTimeout);
if (DsError.Succeeded(hr))
{
Debug.WriteLine("WaitForEvent got " + actuallyReceivedEventCode.ToString() + " 0x" + lparam1.ToString("X") + " 0x" + lparam2.ToString("X"));
param = lparam1.ToInt32();
_mediaEvent.FreeEventParams(actuallyReceivedEventCode, lparam1, lparam2);
}
else
{
actuallyReceivedEventCode = 0;
param = 0;
}
if (restartTimer)
{
_mediaSeekTimer.Start();
}
return(DsError.Succeeded(hr) && (actuallyReceivedEventCode == desiredEventCode));
}
protected override void WndProc(ref Message m)
{
switch (m.Msg)
{
case WM_PAINT:
{
UpdateEnvironment();
RenderEnvironment();
NativeMethods.InvalidateRect(this.Handle, IntPtr.Zero, 0);
return;
}
case WM_GRAPHNOTIFY:
{
IMediaEventEx eventEx = (IMediaEventEx)graphBuilder;
EventCode evCode;
IntPtr param1, param2;
while (eventEx.GetEvent(out evCode, out param1, out param2, 0) == 0)
{
eventEx.FreeEventParams(evCode, param1, param2);
Debug.WriteLine(string.Format("### Event : {0} Param1 : {1} Param2 {2}", evCode.ToString(), param1.ToString(), param2.ToString()));
}
break;
}
}
base.WndProc(ref m);
}
// Filter graph events
public void HandleGraphEvent(GraphEventCallback pCB)
{
if (pCB == null)
{
throw new COMException("No callback set", E_Pointer);
}
if (m_pEvent == null)
{
throw new COMException("No event pointer", E_Unexpected);
}
EventCode evCode = 0;
IntPtr param1, param2;
// Get the events from the queue.
while (Succeeded(m_pEvent.GetEvent(out evCode, out param1, out param2, 0)))
{
// Invoke the callback.
pCB.OnGraphEvent(evCode, param1, param2);
// Free the event data.
int hr = m_pEvent.FreeEventParams(evCode, param1, param2);
DsError.ThrowExceptionForHR(hr);
}
}
/// <summary>
/// Called by the owning HWND when an event the graph cares about occurs
/// </summary>
public void NotifyMediaEvent()
{
IMediaEventEx mediaEvent = (IMediaEventEx)_graphBuilder;
if (mediaEvent != null)
{
bool fireComplete = false;
EventCode eventCode;
IntPtr param1;
IntPtr param2;
int hr = mediaEvent.GetEvent(out eventCode, out param1, out param2, -1);
if (hr == 0)
{
if (eventCode == EventCode.Complete)
{
fireComplete = true;
}
mediaEvent.FreeEventParams(eventCode, param1, param2);
}
Debug.WriteLine("GetEvent got " + eventCode.ToString());
if (fireComplete && Complete != null)
{
Complete(this, new EventArgs());
}
}
}
public bool IsFinished()
{
if (mediaControl == null)
{
return(true);
}
FilterState state;
mediaControl.GetState(200, out state);
if (state == FilterState.Stopped)
{
Cleanup();
return(true);
}
int p1, p2, hr = 0;
EventCode code;
hr = mediaEvt.GetEvent(out code, out p1, out p2, 0);
hr = mediaEvt.FreeEventParams(code, p1, p2);
if (code == EventCode.Complete || code == EventCode.ErrorAbort)
{
Cleanup();
return(true);
}
return(false);
}
protected override void WndProc(ref Message m)
{
if (m.Msg == WM_GRAPHNOTIFY)
{
timerThread.Enabled = true;
timerThread.Start();
int p1, p2;
EventCode code;
if (me == null)
{
return;
}
while (me.GetEvent(out code, out p1, out p2, 0) == 0)
{
if (code == EventCode.Complete)
{
timerThread.Stop();
timerThread.Enabled = false;
while (topProgressBar.Maximum != topProgressBar.Value)
{
topProgressBar.PerformStep();
topProgressBar.Refresh();
}
progressText.Text = "Dönüþtürme iþlemi tamamlandý";
start.Enabled = true;
convert.Enabled = true;
mc.Stop();
}
me.FreeEventParams(code, p1, p2);
}
return;
}
base.WndProc(ref m);
}
private void OnFilterGraphMessage()
{
int p1, p2;
EventCode code = EventCode.None;
if (mediaEvent == null)
{
return;
}
while (mediaEvent.GetEvent(out code, out p1, out p2, 0) == 0)
{
try
{
int hr = mediaEvent.FreeEventParams(code, p1, p2);
DsError.ThrowExceptionForHR(hr);
Logger.LogTrace("HandleGraphEvent: code={0} p1={1} p2={2}", code, p1, p2);
HandleGraphEvent(code, p1, p2);
}
catch (COMException ex)
{
Logger.LogTrace("Filter graph message loop broken because: {0}",
ErrorDispatcher.GetErrorMessageForException(ex, false));
break;
}
catch (Exception ex)
{
Logger.LogException(ex);
break;
}
}
}
/// <summary>
/// Called by the owning HWND when an event the graph cares about occurs
/// </summary>
public void NotifyMediaEvent()
{
IMediaEventEx mediaEvent = (IMediaEventEx)_graphBuilder;
if (mediaEvent != null)
{
bool fireComplete = false;
EventCode eventCode;
IntPtr param1;
IntPtr param2;
while (mediaEvent.GetEvent(out eventCode, out param1, out param2, 0) >= 0)
{
if (eventCode == EventCode.Complete)
{
fireComplete = true;
}
Log(String.Format("IMediaEventEx.GetEvent got {0}", eventCode.ToString()));
mediaEvent.FreeEventParams(eventCode, param1, param2);
if (fireComplete && Complete != null)
{
Complete(this, new EventArgs());
break;
}
}
}
}
protected override void WndProc(ref Message m)
{
if (m.Msg == WM_GRAPHNOTIFY)
{
int lEventCode;
int lParam1, lParam2;
while (true)
{
try
{
mediaEventEx.GetEvent(out lEventCode,
out lParam1,
out lParam2,
0);
mediaEventEx.FreeEventParams(lEventCode, lParam1, lParam2);
if (lEventCode == EC_COMPLETE)
{
this.Stop();
mediaPosition.CurrentPosition = 0;
this.State = MediaStatus.Stopped;
}
}
catch (Exception)
{
break;
}
}
}
base.WndProc(ref m);
}
/// <summary>
/// Callback that handles events sent from the IFilterGraph
/// </summary>
private void HandleGraphEvent()
{
int hr = 0;
EventCode evCode;
IntPtr evParam1, evParam2;
// Make sure that we don't access the media event interface
// after it has already been released.
if (_mediaEventEx == null)
{
return;
}
// Process all queued events
while (_mediaEventEx.GetEvent(out evCode, out evParam1, out evParam2, 0) == 0)
{
// Free memory associated with callback, since we're not using it
hr = _mediaEventEx.FreeEventParams(evCode, evParam1, evParam2);
// If this is the end of the clip, reset to beginning
if (evCode == EventCode.Complete)
{
Stop();
// Rewind to first frame of movie
hr = _mediaSeeking.SetPositions((long)_timeSliderControl.Min * 10000, AMSeekingSeekingFlags.AbsolutePositioning,
null, AMSeekingSeekingFlags.NoPositioning);
_timeSliderControl.Pos = _timeSliderControl.Min;
}
}
}
private void _eventTimer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
{
try
{
_eventTimer.Enabled = false;
IMediaEventEx mediaEvent = _graphBuilder as IMediaEventEx;
if (mediaEvent == null)
{
AppLogger.Message("couldn't get IMediaEventEx from graph builder!");
return;
}
EventCode eventCode;
IntPtr lparam1, lparam2;
while (mediaEvent.GetEvent(out eventCode, out lparam1, out lparam2, 10) == 0)
{
AppLogger.Message("ASFNetSink -- Got Media Event: " + eventCode.ToString() + " 0x" + lparam1.ToString("X") + " 0x" + lparam2.ToString("X"));
OnDirectShowEvent(eventCode, lparam1, lparam2);
mediaEvent.FreeEventParams(eventCode, lparam1, lparam2);
}
_eventTimer.Enabled = true;
}
catch (Exception ex)
{
AppLogger.Message("ASFNetSink -- Can't get Media Event due to an error");
AppLogger.Dump(ex);
}
}
protected virtual bool ProcessGraphMessage()
{
if (m_MediaEventEx != null)
{
int hr = 0;
while (hr == 0)
{
hr = m_MediaEventEx.GetEvent(out DsEvCode _code, out int _param1, out int _param2, 20);
if (hr == 0)
{
hr = m_MediaEventEx.FreeEventParams(_code, _param1, _param2);
if (_code == DsEvCode.Complete)
{
return(true);
}
if (_code == DsEvCode.DeviceLost)
{
return(true);
}
}
}
}
return(false);
}
// Media events are sent to use as windows messages. Used to test GetCmdFromEvent
protected override void WndProc(ref Message m)
{
switch (m.Msg)
{
// If this is a windows media message
case WM_GRAPHNOTIFY:
EventCode eventCode;
IntPtr p1, p2;
int hr;
hr = m_mediaEvent.GetEvent(out eventCode, out p1, out p2, 0);
while (hr == 0)
{
switch (eventCode)
{
case EventCode.DvdCmdEnd:
{
IDvdCmd pCmdObj = null;
hr = this.m_idi2.GetCmdFromEvent(p1, out pCmdObj);
Debug.WriteLine(String.Format("{0} status1", hr));
// Handle the event.
Debug.WriteLine(eventCode);
break;
}
case EventCode.DvdCmdStart:
{
IDvdCmd pCmdObj = null;
hr = this.m_idi2.GetCmdFromEvent(p1, out pCmdObj);
Debug.WriteLine(String.Format("{0} status2", hr));
// Handle the event.
Debug.WriteLine(eventCode);
break;
}
default:
{
Debug.WriteLine(eventCode);
break;
}
}
// Release parms
m_mediaEvent.FreeEventParams(eventCode, p1, p2);
// check for additional events
hr = m_mediaEvent.GetEvent(out eventCode, out p1, out p2, 0);
}
break;
// All other messages
default:
// unhandled window message
base.WndProc(ref m);
break;
}
}
public override void OnVideoEvent(int cookies)
{
if (this.graphBuilder == null || this.graphBuilder2 == null)
{
return;
}
try
{
if (cookies == cookiesSink)
{
IMediaEventEx mediaEvent = this.graphBuilder as IMediaEventEx;
EventCode eventCode;
IntPtr param1, param2;
while (mediaEvent.GetEvent(out eventCode, out param1, out param2, 0) >= 0)
{
Trace.WriteLineIf(trace.TraceVerbose, "OnVideoEvent(Sink) -> " + eventCode.ToString());
if (eventCode == EventCode.VMRRenderDeviceSet)
{
VideoRefresh();
}
//switch (eventCode)
//{
// // Call application-defined functions for each
// // type of event that you want to handle.
//}
int hr = mediaEvent.FreeEventParams(eventCode, param1, param2);
}
}
else if (cookies == cookiesSource)
{
IMediaEventEx mediaEvent = this.graphBuilder2 as IMediaEventEx;
EventCode eventCode;
IntPtr param1, param2;
while (mediaEvent.GetEvent(out eventCode, out param1, out param2, 0) >= 0)
{
Trace.WriteLineIf(trace.TraceVerbose, "OnVideoEvent(Source) -> " + eventCode.ToString());
if (eventCode == EventCode.VMRRenderDeviceSet)
{
VideoRefresh();
}
//switch (eventCode)
//{
// // Call application-defined functions for each
// // type of event that you want to handle.
//}
int hr = mediaEvent.FreeEventParams(eventCode, param1, param2);
}
}
}
catch (Exception ex)
{
Trace.WriteLineIf(trace.TraceError, ex.ToString());
}
}
void HandleGraphEvent()
{
if (mediaEventEx == null)
{
return;
}
while (mediaEventEx.GetEvent(out var eventCode, out var param1, out var param2, 0) == 0)
{
var hr = mediaEventEx.FreeEventParams(eventCode, param1, param2);
DsError.ThrowExceptionForHR(hr);
}
}
private void TimerElapsed(object sender, ElapsedEventArgs e)
{
if (_mediaEvent != null)
{
IntPtr param1;
IntPtr param2;
EventCode code;
while (_mediaEvent.GetEvent(out code, out param1, out param2, 0) == 0)
{
_mediaEvent.FreeEventParams(code, param1, param2);
}
}
}
/// <summary> graph event (WM_GRAPHNOTIFY) handler. </summary>
void OnGraphNotify()
{
DsEvCode code;
int p1, p2, hr = 0;
do
{
hr = mediaEvt.GetEvent(out code, out p1, out p2, 0);
if (hr < 0)
{
break;
}
hr = mediaEvt.FreeEventParams(code, p1, p2);
}while (hr == 0);
}
public void HandleGraphEvent()
{
int hr = 0;
EventCode evCode;
IntPtr evParam1, evParam2;
// Make sure that we don't access the media event interface
// after it has already been released.
if (mediaEventEx == null)
{
return;
}
// Process all queued events
while (mediaEventEx.GetEvent(out evCode, out evParam1, out evParam2, 0) == 0)
{
// Free memory associated with callback, since we're not using it
hr = mediaEventEx.FreeEventParams(evCode, evParam1, evParam2);
// If this is the end of the clip, reset to beginning
if (evCode == EventCode.Complete)
{
if (!usePlayList)
{
DsLong pos = new DsLong(0);
// Reset to first frame of movie
hr = mediaSeeking.SetPositions(pos, AMSeekingSeekingFlags.AbsolutePositioning,
null, AMSeekingSeekingFlags.NoPositioning);
if (hr < 0)
{
// Some custom filters (like the Windows CE MIDI filter)
// may not implement seeking interfaces (IMediaSeeking)
// to allow seeking to the start. In that case, just stop
// and restart for the same effect. This should not be
// necessary in most cases.
hr = mediaControl.Stop();
hr = mediaControl.Run();
}
}
else if (usePlayList)
{
CloseClip();
StartFromPlayList();
break;
}
}
}
}
public void HandleGraphEvent()
{
if (_mediaEventEx == null)
{
return;
}
int evCode, lParam1, lParam2;
while (DsHlp.SUCCEEDED(_mediaEventEx.GetEvent(out evCode, out lParam1, out lParam2, 0)))
{
HandleGraphEvent(evCode, lParam1, lParam2);
_mediaEventEx.FreeEventParams(evCode, lParam1, lParam2);
}
}
void ProcessGraphEvents()
{
if (_mediaEvent != null)
{
IMediaEventEx me = _mediaEvent;
/* Get all the queued events from the interface */
while (me.GetEvent(out EventCode code, out IntPtr param1, out IntPtr param2, 0) == 0)
{
/* Handle anything for this event code */
OnMediaEvent(code, param1, param2);
/* Free everything..we only need the code */
me.FreeEventParams(code, param1, param2);
}
}
}
//
//call to process WM_GRAPHNOTIFY message
//get out of the loop when GetEvent returns not 0
//
private void OnGraphNotify()
{
IntPtr p1, p2;
EventCode code;
if (mediaEvt == null)
{
return;
}
while (mediaEvt.GetEvent(out code, out p1, out p2, 0) == 0)
{
mediaEvt.FreeEventParams(code, p1, p2);
if (code == EventCode.Complete)
{
OnClipCompleted();
}
}
}
protected override void WndProc(ref Message m)
{
if (m.Msg == WM_GRAPHNOTIFY)
{
IMediaEventEx eventEx = (IMediaEventEx)graphBuilder;
EventCode evCode;
int param1, param2;
while (eventEx.GetEvent(out evCode, out param1, out param2, 0) == 0)
{
eventEx.FreeEventParams(evCode, param1, param2);
Debug.WriteLine("### Event : " + evCode.ToString());
}
}
base.WndProc(ref m);
}
protected virtual void OnMessageReceived(AsynchronousMessageQueue queue, SystemMessage message)
{
if (message.ChannelName == WindowsMessaging.CHANNEL)
{
Message m = (Message)message.MessageData[WindowsMessaging.MESSAGE];
if (m.LParam.Equals(_instancePtr))
{
if (m.Msg == WM_GRAPHNOTIFY)
{
IMediaEventEx eventEx = (IMediaEventEx)_graphBuilder;
EventCode evCode;
int param1, param2;
while (eventEx.GetEvent(out evCode, out param1, out param2, 0) == 0)
{
eventEx.FreeEventParams(evCode, param1, param2);
if (evCode == EventCode.Complete)
{
bool hasNextPart = _mediaItem != null && _mediaItem.ActiveResourceLocatorIndex < _mediaItem.MaximumResourceLocatorIndex;
if (hasNextPart)
{
// Request next item
FireNextItemRequest();
}
else if (_autoRepeat)
{
CurrentTime = TimeSpan.Zero;
}
else
{
_state = PlayerState.Ended;
ServiceRegistration.Get <ILogger>().Debug("{0}: Playback ended", PlayerTitle);
// TODO: RemoveResumeData();
FireEnded();
}
return;
}
}
}
}
}
}
private void OnGraphNotify()
{
int p1, p2, hr = 0;
EventCode code;
do
{
hr = mediaEvt.GetEvent(out code, out p1, out p2, 0);
if (hr < 0)
{
break;
}
hr = mediaEvt.FreeEventParams(code, p1, p2);
if (code == EventCode.Complete || code == EventCode.ErrorAbort)
{
MovieEnded(false);
}
} while (hr == 0);
}
private void OnGraphNotify()
{
int p1, p2;
int code;
try
{
do
{
if (ime == null)
{
return;
}
ime.GetEvent(out code, out p1, out p2, 0);
ime.FreeEventParams(code, p1, p2);
}while (true);
}
catch (Exception) { }
}
//デバッグ用イベント情報
private void HandleGraphEvent()
{
int hr = 0;
EventCode evCode = 0;
IntPtr evParam1 = IntPtr.Zero;
IntPtr evParam2 = IntPtr.Zero;
while (mediaEventEx != null && mediaEventEx.GetEvent(out evCode, out evParam1, out evParam2, 0) == 0)
{
// Free event parameters to prevent memory leaks associated with
// event parameter data. While this application is not interested
// in the received events, applications should always process them.
hr = mediaEventEx.FreeEventParams(evCode, evParam1, evParam2);
DsError.ThrowExceptionForHR(hr);
Console.WriteLine(evCode + " -evCode " + evParam1 + " " + evParam2);
// Insert event processing code here, if desired (see http://msdn2.microsoft.com/en-us/library/ms783649.aspx)
}
}
public void HandleGraphEvent()
{
EventCode evCode;
IntPtr evParam1, evParam2;
if (_mediaEventEx == null)
{
return;
}
while (_mediaEventEx.GetEvent(out evCode, out evParam1, out evParam2, 0) == 0)
{
// Free event parameters to prevent memory leaks associated with
// event parameter data. While this application is not interested
// in the received events, applications should always process them.
var hr = _mediaEventEx.FreeEventParams(evCode, evParam1, evParam2);
DsError.ThrowExceptionForHR(hr);
// Insert event processing code here, if desired
}
}
private void GraphNotifyEvent(ref Message m)
{
EventCode eventCode;
IntPtr p1, p2;
int hr;
//bool closeCam = false;
hr = mediaEvent.GetEvent(out eventCode, out p1, out p2, 0);
while (hr == 0)
{
// handle the event
if ((eventCode == EventCode.ErrorAbort) ||
(eventCode == EventCode.Complete))
{
Cursor.Current = Cursors.Default;
button1.Enabled = true;
//closeCam = true;
}
// Release parms
mediaEvent.FreeEventParams(eventCode, p1, p2);
// check for additional events
hr = mediaEvent.GetEvent(out eventCode, out p1, out p2, 0);
}
// you can dispose of the cam object here, but when you do, the display
// will disappear. if you attempt to dispose of the cam object in the
// loop above, you will cause an exception when a method in mediaEvent
// is invoked.
//
//if (closeCam)
//{
// cam.Dispose();
// cam = null;
//}
}
private void OnGraphNotify()
{
int p1, p2, hr = 0;
EventCode code;
do
{
hr = mediaEvt.GetEvent(out code, out p1, out p2, 0);
if (hr < 0)
{
break;
}
hr = mediaEvt.FreeEventParams(code, p1, p2);
if (code == EventCode.Complete || code == EventCode.ErrorAbort)
{
if (GUIGraphicsContext.VideoRenderer == GUIGraphicsContext.VideoRendererType.madVR)
{
try
{
Log.Debug("AudioPlayerVMR: EventCode.Complete: {0}", Enum.GetName(typeof(EventCode), code));
Log.Debug("AudioPlayerVMR: VMR9Util.g_vmr9.playbackTimer {0}", VMR9Util.g_vmr9.playbackTimer);
if (VMR9Util.g_vmr9.playbackTimer.Second != 0)
{
MovieEnded(false);
}
}
catch (Exception ex)
{
Log.Error("AudioPlayerVMR: OnGraphNotify exception: {0}", ex);
}
}
if (GUIGraphicsContext.VideoRenderer != GUIGraphicsContext.VideoRendererType.madVR)
{
Log.Debug("AudioPlayerVMR EventCode.Complete: {0}", Enum.GetName(typeof(EventCode), code));
MovieEnded(false);
}
}
} while (hr == 0);
}
private void ProcessGraphEvents()
{
Dispatcher.BeginInvoke((Action) delegate
{
if (m_mediaEvent != null)
{
IntPtr param1;
IntPtr param2;
EventCode code;
/* Get all the queued events from the interface */
while (m_mediaEvent.GetEvent(out code, out param1, out param2, 0) == 0)
{
/* Handle anything for this event code */
OnMediaEvent(code, param1, param2);
/* Free everything..we only need the code */
m_mediaEvent.FreeEventParams(code, param1, param2);
}
}
});
}
