///////////////////////////////////////////////////////////////////////
// Name: EndEnableContent
// Description: Completes the enable action.
/////////////////////////////////////////////////////////////////////////
public HResult EndEnableContent(IMFAsyncResult pResult)
{
// Make sure we *never* leave this entry point with an exception
try
{
Debug.WriteLine("ContentProtectionManager::EndEnableContent");
if (pResult == null)
{
throw new COMException("NULL IMFAsyncResult", (int)HResult.E_POINTER);
}
// Release interfaces, so that we're ready to accept another call
// to BeginEnableContent.
SafeRelease(m_pEnabler);
SafeRelease(m_pMEG);
SafeRelease(m_punkState);
SafeRelease(m_pCallback);
m_pEnabler = null;
m_pMEG = null;
m_pCallback = null;
m_punkState = null;
return(m_hrStatus);
}
catch (Exception e)
{
return((HResult)Marshal.GetHRForException(e));
}
}
public unsafe void BeginWrite(byte[] bRef, int offset, uint count, IMFAsyncCallback callback, object?context = default)
{
fixed(void *ptr = &bRef[offset])
{
BeginWrite((IntPtr)ptr, count, callback, context != null ? Marshal.GetIUnknownForObject(context) : IntPtr.Zero);
}
}
public static extern void MFBeginCreateFile(
[In] MFFileAccessMode AccessMode,
[In] MFFileOpenMode OpenMode,
[In] MFFileFlags fFlags,
[In, MarshalAs(UnmanagedType.LPWStr)] string pwszFilePath,
[In] IMFAsyncCallback pCallback,
[In][MarshalAs(UnmanagedType.IUnknown)] object pState,
[MarshalAs(UnmanagedType.IUnknown)] out object ppCancelCookie);
public HResult BeginGetEvent(IMFAsyncCallback pCallback, object o)
{
HResult hr;
hr = m_events.BeginGetEvent(pCallback, o);
return(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 int BeginWrite(IntPtr pb, int cb, IMFAsyncCallback pCallback, object pUnkState)
{
mWebServer.sendRawData(pb, cb);
AsyncWriteData lAsyncWriteData = new AsyncWriteData()
{
cb = cb, pCallback = pCallback, punkState = pUnkState
};
ThreadPool.QueueUserWorkItem(lAsyncWriteData.execute);
return(0);
}
public void Dispose()
{
Debug.WriteLine("ContentProtectionManager::Dispose");
SafeRelease(m_pEnabler);
SafeRelease(m_pMEG);
SafeRelease(m_pCallback);
SafeRelease(m_punkState);
m_pEnabler = null;
m_pMEG = null;
m_pCallback = null;
m_punkState = null;
}
public HResult BeginCreateObject(
IMFByteStream pByteStream,
string pwszURL,
MFResolution dwFlags,
IPropertyStore pProps, // Can be NULL.
out object ppIUnknownCancelCookie, // Can be NULL.
IMFAsyncCallback pCallback,
object punkState // Can be NULL
)
{
// Make sure we *never* leave this entry point with an exception
try
{
HResult hr;
m_Log.WriteLine("BeginCreateObject");
ppIUnknownCancelCookie = null; // We don't return a cancellation cookie.
if ((pByteStream == null) || (pwszURL == null) || (pCallback == null))
{
throw new COMException("bad stream, url, or callback", (int)HResult.E_INVALIDARG);
}
IMFAsyncResult pResult = null;
WavSource pSource = new WavSource();
pSource.Open(pByteStream);
hr = MFExtern.MFCreateAsyncResult(pSource as IMFMediaSource, pCallback, punkState, out pResult);
MFError.ThrowExceptionForHR(hr);
hr = MFExtern.MFInvokeCallback(pResult);
MFError.ThrowExceptionForHR(hr);
if (pResult != null)
{
Marshal.ReleaseComObject(pResult);
}
return(HResult.S_OK);
}
catch (Exception e)
{
ppIUnknownCancelCookie = null;
return((HResult)Marshal.GetHRForException(e));
}
}
public HResult BeginCreateObject(string pwszURL,
MFResolution dwFlags,
IPropertyStore pProps,
out object ppIUnknownCancelCookie,
IMFAsyncCallback pCallback,
object pUnkState)
{
// The constructor launches an async connect to the url.
IcyScheme ice = new IcyScheme(pwszURL);
IMFAsyncResult pResult;
MFError hrthrowonerror = MFExtern.MFCreateAsyncResult(
ice, pCallback, pUnkState, out pResult);
ppIUnknownCancelCookie = ice;
hrthrowonerror = MFExtern.MFInvokeCallback(pResult);
return(HResult.S_OK);
}
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);
}
///////////////////////////////////////////////////////////////////////
// Name: BeginEnableContent
// Description: Called by the PMP session to start the enable action.
/////////////////////////////////////////////////////////////////////////
public HResult BeginEnableContent(
IMFActivate pEnablerActivate,
IMFTopology pTopo,
IMFAsyncCallback pCallback,
object punkState
)
{
// Make sure we *never* leave this entry point with an exception
try
{
Debug.WriteLine("ContentProtectionManager::BeginEnableContent");
if (m_pEnabler != null)
{
throw new COMException("A previous call is still pending", (int)HResult.E_FAIL);
}
HResult hr;
// Save so we can create an async result later
m_pCallback = pCallback;
m_punkState = punkState;
// Create the enabler from the IMFActivate pointer.
object o;
hr = pEnablerActivate.ActivateObject(typeof(IMFContentEnabler).GUID, out o);
MFError.ThrowExceptionForHR(hr);
m_pEnabler = o as IMFContentEnabler;
// Notify the application. The application will call DoEnable from the app thread.
m_state = Enabler.Ready; // Reset the state.
PostMessage(m_hwnd, WM_APP_CONTENT_ENABLER, IntPtr.Zero, IntPtr.Zero);
return(HResult.S_OK);
}
catch (Exception e)
{
return((HResult)Marshal.GetHRForException(e));
}
}
///////////////////////////////////////////////////////////////////////
// Name: BeginEnableContent
// Description: Called by the PMP session to start the enable action.
/////////////////////////////////////////////////////////////////////////
public int BeginEnableContent(
IMFActivate pEnablerActivate,
IMFTopology pTopo,
IMFAsyncCallback pCallback,
object punkState
)
{
// Make sure we *never* leave this entry point with an exception
try
{
Debug.WriteLine("ContentProtectionManager::BeginEnableContent");
if (m_pEnabler != null)
{
throw new COMException("A previous call is still pending", E_Fail);
}
int hr;
// Save so we can create an async result later
m_pCallback = pCallback;
m_punkState = punkState;
// Create the enabler from the IMFActivate pointer.
object o;
hr = pEnablerActivate.ActivateObject(typeof(IMFContentEnabler).GUID, out o);
MFError.ThrowExceptionForHR(hr);
m_pEnabler = o as IMFContentEnabler;
// Notify the application. The application will call DoEnable from the app thread.
m_state = Enabler.Ready; // Reset the state.
PostMessage(m_hwnd, WM_APP_CONTENT_ENABLER, IntPtr.Zero, IntPtr.Zero);
return S_Ok;
}
catch (Exception e)
{
return Marshal.GetHRForException(e);
}
}
public int BeginWrite(IntPtr pb, int cb, IMFAsyncCallback pCallback, object pUnkState)
{
++h;
//if(++h == 10)
//{
// Thread.Sleep(2000);
//}
//else
{
mWebServer.sendRawData(pb, cb);
}
AsyncWriteData lAsyncWriteData = new AsyncWriteData()
{
cb = cb, pCallback = pCallback, punkState = pUnkState
};
ThreadPool.QueueUserWorkItem(lAsyncWriteData.execute);
return(0);
}
public int BeginRead(IntPtr pb, int cb, IMFAsyncCallback pCallback, object pUnkState)
{
throw new NotImplementedException();
}
public static extern void MFCreateAsyncResult(
[MarshalAs(UnmanagedType.IUnknown)] object punkObject,
IMFAsyncCallback pCallback,
[MarshalAs(UnmanagedType.IUnknown)] object punkState,
out IMFAsyncResult ppAsyncResult
);
public static extern void MFBeginUnregisterWorkQueueWithMMCSS(
int dwWorkQueueId,
[In] IMFAsyncCallback pDoneCallback,
[In][MarshalAs(UnmanagedType.IUnknown)] object pDoneState);
public static extern void MFBeginRegisterWorkQueueWithMMCSS(
int dwWorkQueueId,
[In, MarshalAs(UnmanagedType.LPWStr)] string wszClass,
int dwTaskId,
[In] IMFAsyncCallback pDoneCallback,
[In][MarshalAs(UnmanagedType.IUnknown)] object pDoneState);
public static extern void MFScheduleWorkItem(
IMFAsyncCallback pCallback,
[MarshalAs(UnmanagedType.IUnknown)] object pState,
long Timeout,
long pKey);
public static extern void MFPutWorkItem(
int dwQueue,
IMFAsyncCallback pCallback,
[MarshalAs(UnmanagedType.IUnknown)] object pState);
public int BeginCreateObject(
IMFByteStream pByteStream,
string pwszURL,
MFResolution dwFlags,
IPropertyStore pProps, // Can be NULL.
out object ppIUnknownCancelCookie, // Can be NULL.
IMFAsyncCallback pCallback,
object punkState // Can be NULL
)
{
// Make sure we *never* leave this entry point with an exception
try
{
int hr;
m_Log.WriteLine("BeginCreateObject");
ppIUnknownCancelCookie = null; // We don't return a cancellation cookie.
if ((pByteStream == null) || (pwszURL == null) || (pCallback == null))
{
throw new COMException("bad stream, url, or callback", E_InvalidArgument);
}
IMFAsyncResult pResult = null;
WavSource pSource = new WavSource();
pSource.Open(pByteStream);
hr = MFExtern.MFCreateAsyncResult(pSource as IMFMediaSource, pCallback, punkState, out pResult);
MFError.ThrowExceptionForHR(hr);
hr = MFExtern.MFInvokeCallback(pResult);
MFError.ThrowExceptionForHR(hr);
if (pResult != null)
{
Marshal.ReleaseComObject(pResult);
}
return S_Ok;
}
catch (Exception e)
{
ppIUnknownCancelCookie = null;
return Marshal.GetHRForException(e);
}
}
//-------------------------------------------------------------------
// Name: Finalize
// Description: Starts the async finalize operation.
//-------------------------------------------------------------------
public void Finalize(IMFAsyncCallback pCallback, object punkState)
{
int hr;
lock (this)
{
ValidateOperation(CAsyncOperation.StreamOperation.OpFinalize);
if (m_pFinalizeResult != null)
{
throw new COMException("The operation is already pending.", MFError.MF_E_INVALIDREQUEST);
}
// Create and store the async result object.
hr = MFExtern.MFCreateAsyncResult(null, pCallback, punkState, out m_pFinalizeResult);
MFError.ThrowExceptionForHR(hr);
m_state = State.Finalized;
QueueAsyncOperation(CAsyncOperation.StreamOperation.OpFinalize);
}
}
public HResult BeginWrite(IntPtr pb,
int cb, IMFAsyncCallback pCallback, object pUnkState)
{
throw new NotImplementedException();
}
public void Dispose()
{
Debug.WriteLine("ContentProtectionManager::Dispose");
SafeRelease(m_pEnabler);
SafeRelease(m_pMEG);
SafeRelease(m_pCallback);
SafeRelease(m_punkState);
m_pEnabler = null;
m_pMEG = null;
m_pCallback = null;
m_punkState = null;
}
///////////////////////////////////////////////////////////////////////
// Name: EndEnableContent
// Description: Completes the enable action.
/////////////////////////////////////////////////////////////////////////
public int EndEnableContent(IMFAsyncResult pResult)
{
// Make sure we *never* leave this entry point with an exception
try
{
Debug.WriteLine("ContentProtectionManager::EndEnableContent");
if (pResult == null)
{
throw new COMException("NULL IMFAsyncResult", E_Pointer);
}
// Release interfaces, so that we're ready to accept another call
// to BeginEnableContent.
SafeRelease(m_pEnabler);
SafeRelease(m_pMEG);
SafeRelease(m_punkState);
SafeRelease(m_pCallback);
m_pEnabler = null;
m_pMEG = null;
m_pCallback = null;
m_punkState = null;
return m_hrStatus;
}
catch (Exception e)
{
return Marshal.GetHRForException(e);
}
}
//-------------------------------------------------------------------
// Name: BeginFinalize
// Description: Starts the asynchronous finalize operation.
//
// Note: We use the Finalize operation to write the RIFF headers.
//-------------------------------------------------------------------
public int BeginFinalize(
IMFAsyncCallback pCallback,
object punkState)
{
// Make sure we *never* leave this entry point with an exception
try
{
TRACE("CWavSink::BeginFinalize");
lock (this)
{
CheckShutdown();
// Tell the stream to finalize.
m_pStream.Finalize(pCallback, punkState);
}
return S_Ok;
}
catch (Exception e)
{
return Marshal.GetHRForException(e);
}
}
// All of the IMFMediaEventGenerator methods do the following:
// 1. Check for shutdown status.
// 2. Call the event generator helper object.
public int BeginGetEvent(IMFAsyncCallback pCallback, object punkState)
{
// Make sure we *never* leave this entry point with an exception
try
{
int hr;
m_Log.WriteLine("-BeginGetEvent");
lock (this)
{
CheckShutdown();
hr = m_pEventQueue.BeginGetEvent(pCallback, punkState);
MFError.ThrowExceptionForHR(hr);
}
return S_Ok;
}
catch (Exception e)
{
return Marshal.GetHRForException(e);
}
}
