public HResult Stop()
{
HResult hr = HResult.S_OK;
lock (_spSource)
{
hr = CheckShutdown();
if (MFError.Succeeded(hr))
{
if (_eSourceState == SourceState.SourceState_Started)
{
_eSourceState = SourceState.SourceState_Stopped;
_tokens.Clear();
_samples.Clear();
// Inform the client that we've stopped.
hr = QueueEvent(MediaEventType.MEStreamStopped, Guid.Empty, HResult.S_OK, null);
}
else
{
hr = HResult.MF_E_INVALID_STATE_TRANSITION;
}
}
if (MFError.Failed(hr))
{
HandleError(hr);
}
return(HResult.S_OK);
}
}
public HResult GetEvent(MFEventFlag dwFlags, out IMFMediaEvent ppEvent)
{
// NOTE:
// GetEvent can block indefinitely, so we don't hold the lock.
// This requires some juggling with the event queue pointer.
HResult hr = HResult.S_OK;
IMFMediaEventQueue spQueue = null;
ppEvent = null;
lock (_spSource)
{
// Check shutdown
hr = CheckShutdown();
// Get the pointer to the event queue.
if (MFError.Succeeded(hr))
{
spQueue = _spEventQueue;
}
}
// Now get the event.
if (MFError.Succeeded(hr))
{
hr = spQueue.GetEvent(dwFlags, out ppEvent);
}
return(hr);
}
public HResult Shutdown()
{
HResult hr = CheckShutdown();
if (MFError.Succeeded(hr))
{
if (_spEventQueue != null)
{
_spEventQueue.Shutdown();
}
if (_networkStreamAdapter != null)
{
_networkStreamAdapter.Close();
}
foreach (var stream in _streams)
{
(stream as MediaStream).Shutdown();
}
_eSourceState = SourceState.SourceState_Shutdown;
_streams.Clear();
_spEventQueue.Shutdown();
_networkStreamAdapter = null;
}
return(hr);
}
private void ThrowIfError(HResult hr)
{
if (!MFError.Succeeded(hr))
{
MFError.ThrowExceptionForHR(hr);
}
}
public HResult BeginGetEvent(IMFAsyncCallback pCallback, object punkState)
{
HResult hr = HResult.S_OK;
hr = CheckShutdown();
if (MFError.Succeeded(hr))
{
hr = _spEventQueue.BeginGetEvent(pCallback, punkState);
}
return(hr);
}
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);
}
public HResult GetCharacteristics(out MFMediaSourceCharacteristics pdwCharacteristics)
{
pdwCharacteristics = MFMediaSourceCharacteristics.None;
HResult hr = CheckShutdown();
if (MFError.Succeeded(hr))
{
pdwCharacteristics = MFMediaSourceCharacteristics.IsLive;
}
return(hr);
}
public HResult EndGetEvent(IMFAsyncResult pResult, out IMFMediaEvent ppEvent)
{
HResult hr = HResult.S_OK;
ppEvent = null;
hr = CheckShutdown();
if (MFError.Succeeded(hr))
{
hr = _spEventQueue.EndGetEvent(pResult, out ppEvent);
}
return(hr);
}
public HResult Start(IMFPresentationDescriptor pPresentationDescriptor, Guid pguidTimeFormat, ConstPropVariant pvarStartPos)
{
HResult hr = HResult.S_OK;
// Check parameters.
// Start position and presentation descriptor cannot be NULL.
if (pvarStartPos == null || pPresentationDescriptor == null)
{
return(HResult.E_INVALIDARG);
}
// Check the time format.
if ((pguidTimeFormat != null) && (pguidTimeFormat != Guid.Empty))
{
// Unrecognized time format GUID.
return(HResult.MF_E_UNSUPPORTED_TIME_FORMAT);
}
// Check the data type of the start position.
if (pvarStartPos.GetVariantType() != VariantType.None && pvarStartPos.GetVariantType() != VariantType.Int64)
{
return(HResult.MF_E_UNSUPPORTED_TIME_FORMAT);
}
if (_eSourceState != SourceState.SourceState_Stopped && _eSourceState != SourceState.SourceState_Started)
{
hr = HResult.MF_E_INVALIDREQUEST;
}
if (MFError.Succeeded(hr))
{
// Check if the presentation description is valid.
hr = ValidatePresentationDescriptor(pPresentationDescriptor);
}
if (MFError.Succeeded(hr))
{
CSourceOperation op = new CSourceOperation
{
Type = SourceOperationType.Operation_Start,
PresentationDescriptor = pPresentationDescriptor,
Data = pvarStartPos
};
doStart(op);
}
return(hr);
}
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 CreatePresentationDescriptor(out IMFPresentationDescriptor ppPresentationDescriptor)
{
ppPresentationDescriptor = null;
HResult hr = CheckShutdown();
if (MFError.Succeeded(hr) && (_eSourceState == SourceState.SourceState_Opening || _eSourceState == SourceState.SourceState_Invalid || null == _spPresentationDescriptor))
{
hr = HResult.MF_E_NOT_INITIALIZED;
}
if (MFError.Succeeded(hr))
{
hr = _spPresentationDescriptor.Clone(out ppPresentationDescriptor);
}
return(hr);
}
public HResult GetStreamDescriptor(out IMFStreamDescriptor ppStreamDescriptor)
{
HResult hr = HResult.S_OK;
ppStreamDescriptor = null;
lock (_spSource)
{
hr = CheckShutdown();
if (MFError.Succeeded(hr))
{
ppStreamDescriptor = _spStreamDescriptor;
}
return(hr);
}
}
public HResult GetMediaSource(out IMFMediaSource ppMediaSource)
{
HResult hr = HResult.S_OK;
ppMediaSource = null;
lock (_spSource)
{
hr = CheckShutdown();
if (MFError.Succeeded(hr))
{
ppMediaSource = _spSource;
}
return(hr);
}
}
public HResult EndCreateObject(IMFAsyncResult pResult,
out MFObjectType pObjectType,
out object ppObject)
{
pObjectType = MFObjectType.ByteStream;
HResult hr = pResult.GetObject(out ppObject);
if (MFError.Succeeded(hr))
{
IcyScheme icy = (IcyScheme)ppObject;
// Wait for the HttpWebRequest to finish connecting. This
// includes sending the request, and processing the response
// headers and caching some data (see m_FirstBlock).
hr = icy.WaitForConnect();
}
return(hr);
}
public HResult BeginRead(
IntPtr pb, int cb, IMFAsyncCallback pCallback, object pUnkState)
{
// For reasons beyond my understanding, sometime we are asked to
// return bytes at negative offsets. In these cases, we change
// the number of bytes requested to 0, which results in EndRead
// returning 0 bytes.
if (m_Position < 0)
{
cb = 0;
}
// This handles the case where SetCurrentPosition was called to
// rewind the stream.
if (m_Position == 0)
{
m_PositionReal = 0;
m_SinceLast = 0;
}
// Since BeginRead is async, caller could call GetCurrentPosition
// while the read is running. Spec says they get the new value.
m_Position += cb;
IMFAsyncResult pResult;
ReadParams rp = new ReadParams(pb, cb);
HResult hr = MFExtern.MFCreateAsyncResult(
rp, pCallback, pUnkState, out pResult);
// If 2 BeginReads are called consecutively, might the Workqueue
// run them concurrently? I don't know, but that would be bad.
if (MFError.Succeeded(hr))
{
hr = MFExtern.MFPutWorkItem(
(int)MFASYNC_WORKQUEUE_TYPE.StandardWorkqueue,
this, pResult);
}
return(hr);
}
public HResult Shutdown()
{
lock (_spSource)
{
HResult hr = CheckShutdown();
if (MFError.Succeeded(hr))
{
Flush();
if (null != _spEventQueue)
{
_spEventQueue.Shutdown();
}
_spStreamDescriptor = null;
_eSourceState = SourceState.SourceState_Shutdown;
}
return(hr);
}
}
internal HResult SetActive(bool fActive)
{
lock (_spSource)
{
HResult hr = CheckShutdown();
if (MFError.Succeeded(hr))
{
if (_eSourceState != SourceState.SourceState_Stopped && _eSourceState != SourceState.SourceState_Started)
{
hr = HResult.MF_E_INVALIDREQUEST;
}
}
if (MFError.Succeeded(hr))
{
_fActive = fActive;
}
return(hr);
}
}
public HResult EndRead(IMFAsyncResult pResult, out int pcbRead)
{
// In theory, pcbRead might be less than what was requested. However
// that seems to drive our caller nuts, so we only do that when
// m_Position < 0.
HResult hr;
object o;
hr = pResult.GetObject(out o);
if (MFError.Succeeded(hr))
{
ReadParams rp = (ReadParams)o;
pcbRead = rp.cb;
}
else
{
pcbRead = 0;
}
return(hr);
}
private HResult ValidatePresentationDescriptor(IMFPresentationDescriptor pPD)
{
HResult hr = HResult.S_OK;
bool fSelected = false;
int cStreams = 0;
if (_streams.Count == 0)
{
return(HResult.E_UNEXPECTED);
}
// The caller's PD must have the same number of streams as ours.
hr = pPD.GetStreamDescriptorCount(out cStreams);
if (MFError.Succeeded(hr))
{
if (cStreams != _streams.Count)
{
hr = HResult.E_INVALIDARG;
}
}
// The caller must select at least one stream.
if (MFError.Succeeded(hr))
{
for (int i = 0; i < cStreams; i++)
{
IMFStreamDescriptor spSD;
hr = pPD.GetStreamDescriptorByIndex(i, out fSelected, out spSD);
if (MFError.Failed(hr))
{
break;
}
}
}
return(hr);
}
