private void SelectStreams(IMFPresentationDescriptor pPD)
{
for (int nStream = 0; nStream < _streams.Count; ++nStream)
{
IMFStreamDescriptor spSD;
MediaStream spStream;
int nStreamId;
bool fSelected;
// Get next stream descriptor
ThrowIfError(pPD.GetStreamDescriptorByIndex(nStream, out fSelected, out spSD));
// Get stream id
ThrowIfError(spSD.GetStreamIdentifier(out nStreamId));
// Get simple net media stream
ThrowIfError(GetStreamById(nStreamId, out spStream));
// Remember if stream was selected
bool fWasSelected = spStream.IsActive;
ThrowIfError(spStream.SetActive(fSelected));
if (fSelected)
{
// Choose event type to send
MediaEventType met = fWasSelected ? MediaEventType.MEUpdatedStream : MediaEventType.MENewStream;
ThrowIfError(_spEventQueue.QueueEventParamUnk(met, Guid.Empty, HResult.S_OK, spStream));
// Start the stream. The stream will send the appropriate event.
ThrowIfError(spStream.Start());
}
}
}
public static extern void MFCreateMediaEvent(
MediaEventType met,
[In, MarshalAs(UnmanagedType.LPStruct)] Guid guidExtendedType,
int hrStatus,
[In, MarshalAs(UnmanagedType.LPStruct)] ConstPropVariant pvValue,
out IMFMediaEvent ppEvent
);
private void SendEvent(MediaEventType met)
{
IMFMediaEvent pEvent;
MFError throwonhr = MFExtern.MFCreateMediaEvent(
met,
Guid.Empty, HResult.S_OK, null, out pEvent);
throwonhr = m_events.QueueEvent(pEvent);
}
public HResult QueueEvent(MediaEventType met, Guid guidExtendedType, HResult hrStatus, ConstPropVariant pvValue)
{
HResult hr = HResult.S_OK;
hr = CheckShutdown();
if (MFError.Succeeded(hr))
{
hr = _spEventQueue.QueueEventParamVar(met, guidExtendedType, hrStatus, pvValue);
}
return(hr);
}
/// +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=
/// <summary>
/// Handles topology status changes reported by the media session TantaAsyncCallbackHandler
/// </summary>
/// <param name="sender">the object sending the event</param>
/// <param name="mediaEvent">the event generated by the media session. Do NOT release this here.</param>
/// <param name="mediaEventType">the eventType</param>
/// <param name="topoStatus">the topology status flag</param>
/// <history>
/// 01 Nov 18 Cynic - Originally Written
/// </history>
private void HandleTopologyStatusChanged(IMFMediaEvent mediaEvent, MediaEventType mediaEventType, MFTopoStatus topoStatus)
{
LogMessage("HandleTopologyStatusChanged event type: " + mediaEventType.ToString() + ", topoStatus=" + topoStatus.ToString());
if (topoStatus == MFTopoStatus.Ready)
{
MediaSessionTopologyNowReady(mediaEvent);
}
else
{
// we are not interested in any other status changes
return;
}
}
public HResult QueueEvent(MediaEventType met,
Guid guidExtendedType, HResult hrStatus, ConstPropVariant pvValue)
{
IMFMediaEvent pEvent;
HResult hr;
hr = MFExtern.MFCreateMediaEvent(met,
Guid.Empty, HResult.S_OK, null, out pEvent);
if (MFError.Succeeded(hr))
{
hr = m_events.QueueEvent(pEvent);
}
return(hr);
}
public HResult QueueEvent(MediaEventType met, Guid guidExtendedType, HResult hrStatus, ConstPropVariant pvValue)
{
Debug.WriteLine("StreamSink:QueueEvent");
HResult hr;
lock (this)
{
hr = CheckShutdown();
if (Failed(hr))
{
return(hr);
}
GenEventQueue();
hr = EventQueue.QueueEventParamVar(met, guidExtendedType, hrStatus, pvValue);
LogIfFailed(hr);
}
return(hr);
}
void IMFAsyncCallback.Invoke(IMFAsyncResult pResult)
{
IMFMediaEvent pEvent = null;
MediaEventType meType = MediaEventType.MEUnknown; // Event type
int hrStatus = 0; // Event status
MFTopoStatus TopoStatus = MFTopoStatus.Invalid; // Used with MESessionTopologyStatus event.
try
{
// Get the event from the event queue.
m_pSession.EndGetEvent(pResult, out pEvent);
// Get the event type.
pEvent.GetType(out meType);
// Get the event status. If the operation that triggered the event did
// not succeed, the status is a failure code.
pEvent.GetStatus(out hrStatus);
TRACE(string.Format("Media event: " + meType.ToString()));
// Check if the async operation succeeded.
if (Succeeded(hrStatus))
{
// Switch on the event type. Update the internal state of the CPlayer as needed.
switch (meType)
{
case MediaEventType.MESessionTopologyStatus:
// Get the status code.
int i;
pEvent.GetUINT32(MFAttributesClsid.MF_EVENT_TOPOLOGY_STATUS, out i);
TopoStatus = (MFTopoStatus)i;
switch (TopoStatus)
{
case MFTopoStatus.Ready:
OnTopologyReady(pEvent);
break;
default:
// Nothing to do.
break;
}
break;
case MediaEventType.MESessionStarted:
OnSessionStarted(pEvent);
break;
case MediaEventType.MESessionPaused:
OnSessionPaused(pEvent);
break;
case MediaEventType.MESessionClosed:
OnSessionClosed(pEvent);
break;
case MediaEventType.MEEndOfPresentation:
OnPresentationEnded(pEvent);
break;
}
}
else
{
// The async operation failed. Notify the application
NotifyError(hrStatus);
}
}
finally
{
// Request another event.
if (meType != MediaEventType.MESessionClosed)
{
m_pSession.BeginGetEvent(this, null);
}
SafeRelease(pEvent);
}
}
///////////////////////////////////////////////////////////////////////
// Name: RunMediaSession
// Description:
// Queues the specified topology on the media session and runs the
// media session until the MESessionEnded event is received.
///////////////////////////////////////////////////////////////////////
static void RunMediaSession(IMFTopology pTopology)
{
HResult hr;
IMFMediaSession pSession;
bool bGetAnotherEvent = true;
PropVariant varStartPosition = new PropVariant();
hr = MFExtern.MFCreateMediaSession(null, out pSession);
MFError.ThrowExceptionForHR(hr);
try
{
hr = pSession.SetTopology(0, pTopology);
MFError.ThrowExceptionForHR(hr);
while (bGetAnotherEvent)
{
HResult hrStatus = 0;
IMFMediaEvent pEvent;
MediaEventType meType = MediaEventType.MEUnknown;
int TopoStatus = (int)MFTopoStatus.Invalid; // Used with MESessionTopologyStatus event.
hr = pSession.GetEvent(MFEventFlag.None, out pEvent);
MFError.ThrowExceptionForHR(hr);
try
{
hr = pEvent.GetStatus(out hrStatus);
MFError.ThrowExceptionForHR(hr);
hr = pEvent.GetType(out meType);
MFError.ThrowExceptionForHR(hr);
if (hrStatus >= 0)
{
switch (meType)
{
case MediaEventType.MESessionTopologySet:
Debug.WriteLine("MESessionTopologySet");
break;
case MediaEventType.MESessionTopologyStatus:
// Get the status code.
hr = pEvent.GetUINT32(MFAttributesClsid.MF_EVENT_TOPOLOGY_STATUS, out TopoStatus);
MFError.ThrowExceptionForHR(hr);
switch ((MFTopoStatus)TopoStatus)
{
case MFTopoStatus.Ready:
Debug.WriteLine("MESessionTopologyStatus: MF_TOPOSTATUS_READY");
pSession.Start(Guid.Empty, varStartPosition);
break;
case MFTopoStatus.Ended:
Debug.WriteLine("MESessionTopologyStatus: MF_TOPOSTATUS_ENDED");
break;
}
break;
case MediaEventType.MESessionStarted:
Debug.WriteLine("MESessionStarted");
break;
case MediaEventType.MESessionEnded:
Debug.WriteLine("MESessionEnded");
hr = pSession.Stop();
break;
case MediaEventType.MESessionStopped:
Debug.WriteLine("MESessionStopped");
Console.WriteLine("Attempting to close the media session.");
hr = pSession.Close();
MFError.ThrowExceptionForHR(hr);
break;
case MediaEventType.MESessionClosed:
Debug.WriteLine("MESessionClosed");
bGetAnotherEvent = false;
break;
default:
Debug.WriteLine(string.Format("Media session event: {0}", meType));
break;
}
}
else
{
Debug.WriteLine(string.Format("HRStatus: {0}", hrStatus));
bGetAnotherEvent = false;
}
}
finally
{
if (pEvent != null)
{
Marshal.ReleaseComObject(pEvent);
}
}
}
Debug.WriteLine("Shutting down the media session.");
hr = pSession.Shutdown();
MFError.ThrowExceptionForHR(hr);
}
finally
{
if (pSession != null)
{
Marshal.ReleaseComObject(pSession);
}
}
}
/// +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=
/// <summary>
/// Part of the IMFAsyncCallback interface. This is called when an
/// asynchronous operation is completed.
/// </summary>
/// <param name="pResult">Pointer to the IMFAsyncResult interface. </param>
/// <returns>S_OK for success, others for fail</returns>
/// <history>
/// 01 Nov 18 Cynic - Originally Written
/// </history>
HResult IMFAsyncCallback.Invoke(IMFAsyncResult pResult)
{
HResult hr;
IMFMediaEvent eventObj = null;
MediaEventType meType = MediaEventType.MEUnknown; // Event type
HResult hrStatus = 0; // Event status
lock (this)
{
try
{
if (MediaSession == null)
{
return(HResult.S_OK);
}
// Complete the asynchronous request this is tied to the previous BeginGetEvent call
// and MUST be done. The output here is a pointer to the IMFMediaEvent interface describing
// this event. Note we MUST release this interface
hr = MediaSession.EndGetEvent(pResult, out eventObj);
if (hr != HResult.S_OK)
{
throw new Exception("IMFAsyncCallback.Invoke call to MediaSession.EndGetEvent failed. Err=" + hr.ToString());
}
if (eventObj == null)
{
throw new Exception("IMFAsyncCallback.Invoke call to MediaSession.EndGetEvent failed. eventObj == null");
}
// Get the event type. The event type indicates what happened to trigger the event.
// It also defines the meaning of the event value.
hr = eventObj.GetType(out meType);
if (hr != HResult.S_OK)
{
throw new Exception("IMFAsyncCallback.Invoke call to IMFMediaEvent.GetType failed. Err=" + hr.ToString());
}
// Get the event status. If the operation that generated the event was successful,
// the value is a success code. A failure code means that an error condition triggered the event.
hr = eventObj.GetStatus(out hrStatus);
if (hr != HResult.S_OK)
{
throw new Exception("IMFAsyncCallback.Invoke call to IMFMediaEvent.GetStatus failed. Err=" + hr.ToString());
}
// Check if we are being told that the the async event succeeded.
if (hrStatus != HResult.S_OK)
{
// The async operation failed. Notify the application
if (MediaSessionAsyncCallBackError != null)
{
MediaSessionAsyncCallBackError(this, "Error Code =" + hrStatus.ToString(), null);
}
}
else
{
// we are being told the operation succeeded and therefore the event contents are meaningful.
// Switch on the event type.
switch (meType)
{
// we let the app handle all of these. There is not really much we can do here
default:
MediaSessionAsyncCallBackEvent(this, eventObj, meType);
break;
}
}
}
catch (Exception ex)
{
// The async operation failed. Notify the application
if (MediaSessionAsyncCallBackError != null)
{
MediaSessionAsyncCallBackError(this, ex.Message, ex);
}
}
finally
{
// Request another event if we are still operational.
if (((meType == MediaEventType.MESessionClosed) || (meType == MediaEventType.MEEndOfPresentation)) == false)
{
// Begins an asynchronous request for the next event in the queue
hr = MediaSession.BeginGetEvent(this, null);
if (hr != HResult.S_OK)
{
throw new Exception("IMFAsyncCallback.Invoke call to MediaSession.BeginGetEvent failed. Err=" + hr.ToString());
}
}
// release the event we just processed
if (eventObj != null)
{
Marshal.ReleaseComObject(eventObj);
}
}
} // bottom of lock(this)
return(HResult.S_OK);
}
public void QueueNews(string newsConcentrate, string outcome = null, bool highlight = false, MediaEventType eventType = MediaEventType.Mundane)
{
string formattedReason = string.Format(newsConcentrate, this.Name);
string[] parts = formattedReason.Split('\n');
if (parts.Length < 2)
{
parts = new string[] { formattedReason, "Ha, the editor is on vacation and I can say whatever I want" }
}
;
QueueNews(parts[0], parts[1], outcome, highlight, eventType);
}
///////////////////////////////////////////////////////////////////////
// Name: Invoke
// Description: Callback for asynchronous BeginGetEvent method.
//
// pAsyncResult: Pointer to the result.
/////////////////////////////////////////////////////////////////////////
HResult IMFAsyncCallback.Invoke(IMFAsyncResult pAsyncResult)
{
// Make sure we *never* leave this entry point with an exception
try
{
HResult hr;
IMFMediaEvent pEvent;
MediaEventType meType = MediaEventType.MEUnknown; // Event type
PropVariant varEventData = new PropVariant(); // Event data
// Get the event from the event queue.
hr = m_pMEG.EndGetEvent(pAsyncResult, out pEvent);
MFError.ThrowExceptionForHR(hr);
// Get the event type.
hr = pEvent.GetType(out meType);
MFError.ThrowExceptionForHR(hr);
// Get the event status. If the operation that triggered the event did
// not succeed, the status is a failure code.
hr = pEvent.GetStatus(out m_hrStatus);
MFError.ThrowExceptionForHR(hr);
if ((int)m_hrStatus == 862022) // NS_S_DRM_MONITOR_CANCELLED
{
m_hrStatus = HResult.MF_E_OPERATION_CANCELLED;
m_state = Enabler.Complete;
}
// Get the event data.
hr = pEvent.GetValue(varEventData);
MFError.ThrowExceptionForHR(hr);
// For the MEEnablerCompleted action, notify the application.
// Otherwise, request another event.
Debug.WriteLine(string.Format("Content enabler event: {0}", meType.ToString()));
if (meType == MediaEventType.MEEnablerCompleted)
{
PostMessage(m_hwnd, WM_APP_CONTENT_ENABLER, IntPtr.Zero, IntPtr.Zero);
}
else
{
if (meType == MediaEventType.MEEnablerProgress)
{
if (varEventData.GetVariantType() == PropVariant.VariantType.String)
{
Debug.WriteLine(string.Format("Progress: {0}", varEventData.GetString()));
}
}
hr = m_pMEG.BeginGetEvent(this, null);
MFError.ThrowExceptionForHR(hr);
}
// Clean up.
varEventData.Clear();
SafeRelease(pEvent);
return(HResult.S_OK);
}
catch (Exception e)
{
return((HResult)Marshal.GetHRForException(e));
}
}
public int QueueEvent(MediaEventType met, Guid guidExtendedType, int hrStatus, ConstPropVariant pvValue)
{
int hr;
TRACE(string.Format("CWavStream::QueueEvent ({0})", met.ToString()));
lock (this)
{
CheckShutdown();
hr = m_pEventQueue.QueueEventParamVar(met, guidExtendedType, hrStatus, pvValue);
MFError.ThrowExceptionForHR(hr);
}
return S_Ok;
}
/// +=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=
/// <summary>
/// Handles events reported by the media session TantaAsyncCallbackHandler
/// </summary>
/// <param name="sender">the object sending the event</param>
/// <param name="mediaEvent">the event generated by the media session. Do NOT release this here.</param>
/// <param name="mediaEventType">the eventType, this is just an enum</param>
/// <history>
/// 01 Nov 18 Cynic - Originally Written
/// </history>
private void HandleMediaSessionAsyncCallBackEvent(object sender, IMFMediaEvent pEvent, MediaEventType mediaEventType)
{
LogMessage("Media Event Type " + mediaEventType.ToString());
switch (mediaEventType)
{
case MediaEventType.MESessionTopologyStatus:
// Raised by the Media Session when the status of a topology changes.
// Get the topology changed status code. This is an enum in the event
int i;
HResult hr = pEvent.GetUINT32(MFAttributesClsid.MF_EVENT_TOPOLOGY_STATUS, out i);
if (hr != HResult.S_OK)
{
throw new Exception("HandleMediaSessionAsyncCallBackEvent call to pEvent to get the status code failed. Err=" + hr.ToString());
}
// the one we are most interested in is i == MFTopoStatus.Ready
// which we get then the Topology is built and ready to run
HandleTopologyStatusChanged(pEvent, mediaEventType, (MFTopoStatus)i);
break;
case MediaEventType.MESessionStarted:
// Raised when the IMFMediaSession::Start method completes asynchronously.
// PlayerState = TantaEVRPlayerStateEnum.Started;
break;
case MediaEventType.MESessionPaused:
// Raised when the IMFMediaSession::Pause method completes asynchronously.
// PlayerState = TantaEVRPlayerStateEnum.Paused;
break;
case MediaEventType.MESessionStopped:
// Raised when the IMFMediaSession::Stop method completes asynchronously.
break;
case MediaEventType.MESessionClosed:
// Raised when the IMFMediaSession::Close method completes asynchronously.
break;
case MediaEventType.MESessionCapabilitiesChanged:
// Raised by the Media Session when the session capabilities change.
// You can use IMFMediaEvent::GetValue to figure out what they are
break;
case MediaEventType.MESessionTopologySet:
// Raised after the IMFMediaSession::SetTopology method completes asynchronously.
// The Media Session raises this event after it resolves the topology into a full topology and queues the topology for playback.
break;
case MediaEventType.MESessionNotifyPresentationTime:
// Raised by the Media Session when a new presentation starts.
// This event indicates when the presentation will start and the offset between the presentation time and the source time.
break;
case MediaEventType.MEEndOfPresentation:
// Raised by a media source when a presentation ends. This event signals that all streams
// in the presentation are complete. The Media Session forwards this event to the application.
// we cannot sucessfully .Finalize_ on the SinkWriter
// if we call CloseAllMediaDevices directly from this thread
// so we use an asynchronous method
Task taskA = Task.Run(() => CloseAllMediaDevices());
// we have to be on the form thread to update the screen
ThreadSafeScreenUpdate(this, false, "Done");
break;
case MediaEventType.MESessionRateChanged:
// Raised by the Media Session when the playback rate changes. This event is sent after the
// IMFRateControl::SetRate method completes asynchronously.
break;
default:
LogMessage("Unhandled Media Event Type " + mediaEventType.ToString());
break;
}
}
private void HandleTopologyStatusChanged(MediaEventType mediaEventType, MFTopoStatus topoStatus)
{
Console.WriteLine("HandleTopologyStatusChanged event type: " + mediaEventType.ToString() + ", topoStatus=" + topoStatus.ToString());
// we currently arent paying attention to these
return;
}
//////////////////////////////////////////////////////////////////////////
// Name: CPlayer::Invoke
// Description:
// Implementation of CAsyncCallback::Invoke.
// Callback for asynchronous BeginGetEvent method.
// Parameter:
// pAsyncResult: Pointer to the result.
//
/////////////////////////////////////////////////////////////////////////
HResult IMFAsyncCallback.Invoke(IMFAsyncResult pAsyncResult)
{
MediaEventType eventType = MediaEventType.MEUnknown;
IMFMediaEvent pEvent;
PropVariant eventData = null;
Exception excpt = null;
HResult hr = HResult.S_OK;
try
{
HResult eventStatus = 0; // Event status
eventData = new PropVariant(); // Event data
// Get the event from the event queue.
hr = m_pMediaSession.EndGetEvent(pAsyncResult, out pEvent);
MFError.ThrowExceptionForHR(hr);
// Get the event type.
hr = pEvent.GetType(out eventType);
MFError.ThrowExceptionForHR(hr);
// Get the event data
hr = pEvent.GetValue(eventData);
MFError.ThrowExceptionForHR(hr);
// Get the event status. If the operation that triggered the event
// did not succeed, the status is a failure code.
hr = pEvent.GetStatus(out eventStatus);
MFError.ThrowExceptionForHR(hr);
// Switch on the event type. Update the internal state of the CPlayer
// as needed.
switch (eventType)
{
// Session events
case MediaEventType.MESessionStarted:
{
Debug.WriteLine(string.Format("{0}: MESessionStarted, Status: 0x{1:x}", eventType.ToString(), eventStatus));
m_State = PlayerState.Playing;
PostMessage(m_hWnd, Form1.WM_NOTIFY_APP, new IntPtr((int)eventType), new IntPtr((int)m_State));
break;
}
case MediaEventType.MESessionPaused:
{
Debug.WriteLine(string.Format("{0}: MESessionPaused, Status: 0x{1:x}", eventType.ToString(), eventStatus));
m_State = PlayerState.Paused;
PostMessage(m_hWnd, Form1.WM_NOTIFY_APP, new IntPtr((int)eventType), new IntPtr((int)m_State));
break;
}
case MediaEventType.MESessionStopped:
{
Debug.WriteLine(string.Format("{0}: MESessionStopped, Status: 0x{1:x}", eventType.ToString(), eventStatus));
m_State = PlayerState.Stopped;
PostMessage(m_hWnd, Form1.WM_NOTIFY_APP, new IntPtr((int)eventType), new IntPtr((int)m_State));
break;
}
case MediaEventType.MESessionTopologyStatus:
{
Debug.WriteLine(string.Format("{0}: MESessionTopologyStatus, Status: 0x{1:x}", eventType.ToString(), eventStatus));
int value = 0;
hr = pEvent.GetUINT32(MFAttributesClsid.MF_EVENT_TOPOLOGY_STATUS, out value);
MFError.ThrowExceptionForHR(hr);
int SegmentID = 0;
long ID;
//Get information about the new segment
IMFTopology pTopology;
pTopology = (IMFTopology)eventData.GetIUnknown();
try
{
hr = pTopology.GetTopologyID(out ID);
MFError.ThrowExceptionForHR(hr);
m_Segments.GetSegmentIDByTopoID(ID, out SegmentID);
topostat.iTopologyStatusType = (MFTopoStatus)value;
topostat.iSegmentId = SegmentID;
switch (topostat.iTopologyStatusType)
{
case MFTopoStatus.StartedSource:
m_ActiveSegment = SegmentID;
break;
case MFTopoStatus.Ended:
m_ActiveSegment = -1;
break;
}
GCHandle gc = GCHandle.Alloc(topostat);
PostMessage(m_hWnd, Form1.WM_NOTIFY_APP, new IntPtr((int)MediaEventType.MESessionTopologyStatus), GCHandle.ToIntPtr(gc));
}
finally
{
SafeRelease(pTopology);
}
break;
}
case MediaEventType.MENewPresentation:
{
Debug.WriteLine(string.Format("{0}: MENewPresentation, Status: 0x{1:x}", eventType.ToString(), eventStatus));
IMFPresentationDescriptor pPresentationDescriptor;
int SegmentId = 0;
pPresentationDescriptor = (IMFPresentationDescriptor)eventData.GetIUnknown();
try
{
//Queue the next segment on the media session
QueueNextSegment(pPresentationDescriptor, out SegmentId);
}
finally
{
SafeRelease(pPresentationDescriptor);
}
PostMessage(m_hWnd, Form1.WM_NOTIFY_APP, new IntPtr((int)eventType), new IntPtr(SegmentId));
break;
}
case MediaEventType.MEEndOfPresentation:
{
Debug.WriteLine(string.Format("{0}: MEEndOfPresentation, Status: 0x{1:x}", eventType.ToString(), eventStatus));
int value = 0;
try
{
hr = pEvent.GetUINT32(MFAttributesClsid.MF_EVENT_SOURCE_TOPOLOGY_CANCELED, out value);
MFError.ThrowExceptionForHR(hr);
}
catch { }
PostMessage(m_hWnd, Form1.WM_NOTIFY_APP, new IntPtr((int)eventType), new IntPtr(value));
break;
}
case MediaEventType.MEEndOfPresentationSegment:
{
Debug.WriteLine(string.Format("{0}: MEEndOfPresentationSegment, Status: 0x{1:x}", eventType.ToString(), eventStatus));
int value = 0;
try
{
hr = pEvent.GetUINT32(MFAttributesClsid.MF_EVENT_SOURCE_TOPOLOGY_CANCELED, out value);
MFError.ThrowExceptionForHR(hr);
}
catch { }
PostMessage(m_hWnd, Form1.WM_NOTIFY_APP, new IntPtr((int)eventType), new IntPtr(value));
break;
}
case MediaEventType.MESessionNotifyPresentationTime:
{
Debug.WriteLine(string.Format("{0}: MESessionNotifyPresentationTime, Status: 0x{1:x}", eventType.ToString(), eventStatus));
HandleNotifyPresentationTime(pEvent);
break;
}
case MediaEventType.MESessionClosed:
{
Debug.WriteLine(string.Format("{0}: MESessionClosed, Status: 0x{1:x}", eventType.ToString(), eventStatus));
m_hCloseEvent.Set();
break;
}
default:
Debug.WriteLine(string.Format("{0}: Event", eventType.ToString()));
break;
}
}
catch (Exception e)
{
excpt = e;
}
finally
{
if (eventData != null)
{
eventData.Clear();
}
}
// Request another event.
if (eventType != MediaEventType.MESessionClosed)
{
hr = m_pMediaSession.BeginGetEvent(this, null);
MFError.ThrowExceptionForHR(hr);
}
if (excpt == null)
{
hr = HResult.S_OK;
}
else
{
hr = (HResult)Marshal.GetHRForException(excpt);
}
return(hr);
}
private static HResult RunMediaSession(IMFMediaSession mediaSession)
{
HResult hr = S_OK;
bool receiveSessionEvent = true;
while (receiveSessionEvent)
{
HResult hrStatus = S_OK;
IMFMediaEvent mediaEvent = null;
MediaEventType eventType = MediaEventType.MEUnknown;
MFTopoStatus topoStatus = MFTopoStatus.Invalid;
hr = mediaSession.GetEvent(MFEventFlag.None, out mediaEvent);
if (Succeeded(hr))
{
hr = mediaEvent.GetStatus(out hrStatus);
}
if (Succeeded(hr))
{
hr = mediaEvent.GetType(out eventType);
}
if (Succeeded(hr) && Succeeded(hrStatus))
{
switch (eventType)
{
case MediaEventType.MESessionTopologySet:
Debug.WriteLine("MediaSession:TopologySetEvent");
break;
case MediaEventType.MESessionTopologyStatus:
Debug.WriteLine("MediaSession:TopologStatusEvent");
hr = mediaEvent.GetUINT32(MF_EVENT_TOPOLOGY_STATUS, out int topoStatusInt);
if (Succeeded(hr))
{
topoStatus = (MFTopoStatus)topoStatusInt;
switch (topoStatus)
{
case MFTopoStatus.Ready:
Debug.WriteLine("MediaSession:TopologyStatus: MFTopoStatus.Ready");
hr = mediaSession.Start();
break;
default:
Debug.WriteLine("MediaSession:TopologyStatus: MFTopoStatus." + topoStatus);
break;
}
}
break;
case MediaEventType.MESessionClosed:
Debug.WriteLine("MediaSession:SessionClosedEvent");
receiveSessionEvent = false;
break;
case MediaEventType.MESessionStopped:
Debug.WriteLine("MediaSession:SesssionStoppedEvent");
hr = mediaSession.Stop();
break;
default:
Debug.WriteLine("MediaSession:Event: " + eventType);
break;
}
mediaEvent = null;
if (Failed(hr) || Failed(hrStatus))
{
receiveSessionEvent = false;
}
}
}
return(hr);
}
// News
public void QueueNews(string blurb, string subBlurb, string outcome, bool highlight = false, MediaEventType eventType = MediaEventType.Mundane)
{
MediaEvent me = new MediaEvent(this, blurb, subBlurb, outcome, highlight);
me.EventType = eventType;
Parent.NextRoundNews.Add(me);
}
public HResult Invoke(IMFAsyncResult result)
{
IMFMediaEvent mediaEvent = null;
MediaEventType mediaEventType = MediaEventType.MEUnknown;
bool getNext = true;
try
{
_basePlayer.mf_MediaSession.EndGetEvent(result, out mediaEvent);
mediaEvent.GetType(out mediaEventType);
mediaEvent.GetStatus(out HResult errorCode);
if (_basePlayer._playing)
{
if (mediaEventType == MediaEventType.MEError ||
(_basePlayer._webcamMode && mediaEventType == MediaEventType.MEVideoCaptureDeviceRemoved) ||
(_basePlayer._micMode && mediaEventType == MediaEventType.MECaptureAudioSessionDeviceRemoved))
//if (errorCode < 0)
{
_basePlayer._lastError = errorCode;
errorCode = Player.NO_ERROR;
getNext = false;
}
if (errorCode >= 0)
{
if (!getNext || mediaEventType == MediaEventType.MESessionEnded)
{
if (getNext)
{
_basePlayer._lastError = Player.NO_ERROR;
if (!_basePlayer._repeat)
{
getNext = false;
}
}
Control control = _basePlayer._display;
if (control == null)
{
FormCollection forms = Application.OpenForms;
if (forms != null && forms.Count > 0)
{
control = forms[0];
}
}
if (control != null)
{
control.BeginInvoke(CallEndOfMedia);
}
else
{
_basePlayer.AV_EndOfMedia();
}
}
}
else
{
_basePlayer._lastError = errorCode;
}
}
else
{
_basePlayer._lastError = errorCode;
}
}
finally
{
if (getNext && mediaEventType != MediaEventType.MESessionClosed)
{
_basePlayer.mf_MediaSession.BeginGetEvent(this, null);
}
if (mediaEvent != null)
{
Marshal.ReleaseComObject(mediaEvent);
}
if (_basePlayer.mf_AwaitCallback)
{
_basePlayer.mf_AwaitCallback = false;
_basePlayer.WaitForEvent.Set();
}
_basePlayer.mf_AwaitDoEvents = false;
}
return(0);
}
public int QueueEvent(MediaEventType met, Guid guidExtendedType, int hrStatus, ConstPropVariant pvValue)
{
// Make sure we *never* leave this entry point with an exception
try
{
int hr;
m_Log.WriteLine("-QueueEvent");
lock (this)
{
CheckShutdown();
hr = m_pEventQueue.QueueEventParamVar(met, guidExtendedType, hrStatus, pvValue);
MFError.ThrowExceptionForHR(hr);
}
return S_Ok;
}
catch (Exception e)
{
return Marshal.GetHRForException(e);
}
}
