Added shadows and vtables for callback interfaces.

Source/SharpDX.MediaFoundation/CaptureEngineOnEventCallback.cs

@@ -0,0 +1,16 @@
+#if DESKTOP_APP
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SharpDX.MediaFoundation
+{
+    [Shadow(typeof(CaptureEngineOnEventCallbackShadow))]
+    internal partial interface CaptureEngineOnEventCallback
+    {
+        void OnEvent(MediaEvent mediaEvent);
+    }
+}
+#endif

Source/SharpDX.MediaFoundation/CaptureEngineOnEventCallbackShadow.cs

@@ -0,0 +1,54 @@
+#if DESKTOP_APP
+using System;
+using System.Runtime.InteropServices;
+
+namespace SharpDX.MediaFoundation
+{
+    internal class CaptureEngineOnEventCallbackShadow : SharpDX.ComObjectShadow
+    {
+        private static readonly CaptureEngineOnEventCallbackVtbl Vtbl = new CaptureEngineOnEventCallbackVtbl();
+
+        /// <summary>
+        /// Return a pointer to the unmanaged version of this callback.
+        /// </summary>
+        /// <param name="callback">The callback.</param>
+        /// <returns>A pointer to a shadow c++ callback</returns>
+        public static IntPtr ToIntPtr(CaptureEngineOnEventCallback callback)
+        {
+            return ToCallbackPtr<CaptureEngineOnEventCallback>(callback);
+        }
+
+        public class CaptureEngineOnEventCallbackVtbl : ComObjectVtbl
+        {
+            public CaptureEngineOnEventCallbackVtbl() : base(1)
+            {
+                AddMethod(new OnEventCallback(OnEventImpl));
+            }
+
+            /// <unmanaged>HRESULT IMFCaptureEngineOnEventCallback::OnEvent([In] IMFMediaEvent* pEvent)</unmanaged>	
+            [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+            private delegate int OnEventCallback(IntPtr thisPtr, IntPtr mediaEvent);
+            private static int OnEventImpl(IntPtr thisPtr, IntPtr mediaEvent)
+            {
+                try
+                {
+                    var shadow = ToShadow<MediaEngineNotifyShadow>(thisPtr);
+                    var callback = (CaptureEngineOnEventCallback)shadow.Callback;
+                    var eventRef = new MediaEvent(mediaEvent);
+                    callback.OnEvent(eventRef);
+                }
+                catch (Exception exception)
+                {
+                    return (int)SharpDX.Result.GetResultFromException(exception);
+                }
+                return Result.Ok.Code;
+            }
+        }
+
+        protected override CppObjectVtbl GetVtbl
+        {
+            get { return Vtbl; }
+        }
+    }
+}
+#endif

Source/SharpDX.MediaFoundation/CaptureEngineOnSampleCallback.cs

@@ -0,0 +1,16 @@
+#if DESKTOP_APP
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SharpDX.MediaFoundation
+{
+    [Shadow(typeof(CaptureEngineOnSampleCallbackShadow))]
+    public partial interface CaptureEngineOnSampleCallback
+    {
+        void OnSample(Sample sample);
+    }
+}
+#endif

Source/SharpDX.MediaFoundation/CaptureEngineOnSampleCallback2.cs

@@ -0,0 +1,16 @@
+#if DESKTOP_APP
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SharpDX.MediaFoundation
+{
+    [Shadow(typeof(CaptureEngineOnSampleCallback2Shadow))]
+    public partial interface CaptureEngineOnSampleCallback2
+    {
+        void OnSynchronizedEvent(MediaEvent mediaEvent);
+    }
+}
+#endif

Source/SharpDX.MediaFoundation/CaptureEngineOnSampleCallback2Shadow.cs

@@ -0,0 +1,50 @@
+#if DESKTOP_APP
+using System;
+using System.Runtime.InteropServices;
+
+namespace SharpDX.MediaFoundation
+{
+    internal class CaptureEngineOnSampleCallback2Shadow : ComObjectShadow
+    {
+        private static readonly CaptureEngineOnSampleCallback2Vtbl Vtbl = new CaptureEngineOnSampleCallback2Vtbl();
+
+        public class CaptureEngineOnSampleCallback2Vtbl : CaptureEngineOnSampleCallbackShadow.CaptureEngineOnSampleCallbackVtbl
+        {
+            public CaptureEngineOnSampleCallback2Vtbl()
+                :base(1)
+            {
+                AddMethod(new OnSynchronizedEventCallback(OnSynchronizedEventImpl));
+            }
+
+            /// <unmanaged>HRESULT IMFCaptureEngineOnEventCallback::OnEvent([In] IMFMediaEvent* pEvent)</unmanaged>	
+            [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+            private delegate int OnSynchronizedEventCallback(IntPtr thisPtr, IntPtr mediaEvent);
+            private static int OnSynchronizedEventImpl(IntPtr thisPtr, IntPtr mediaEvent)
+            {
+                try
+                {
+                    var shadow = ToShadow<CaptureEngineOnSampleCallback2Shadow>(thisPtr);
+                    var callback = (CaptureEngineOnSampleCallback2)shadow.Callback;
+                    var eventRef = new MediaEvent(mediaEvent);
+                    callback.OnSynchronizedEvent(eventRef);
+                }
+                catch (Exception exception)
+                {
+                    return (int)SharpDX.Result.GetResultFromException(exception);
+                }
+                return Result.Ok.Code;
+            }
+        }
+
+
+        protected override CppObjectVtbl GetVtbl
+        {
+            get
+            {
+                return Vtbl;
+            }
+        }
+
+    }
+}
+#endif

Source/SharpDX.MediaFoundation/CaptureEngineOnSampleCallbackShadow.cs

@@ -0,0 +1,54 @@
+#if DESKTOP_APP
+using System;
+using System.Runtime.InteropServices;
+
+namespace SharpDX.MediaFoundation
+{
+    internal class CaptureEngineOnSampleCallbackShadow : ComObjectShadow
+    {
+        private static readonly CaptureEngineOnSampleCallbackVtbl Vtbl = new CaptureEngineOnSampleCallbackVtbl(0);
+
+        /// <summary>
+        /// Return a pointer to the unmanaged version of this callback.
+        /// </summary>
+        /// <param name="callback">The callback.</param>
+        /// <returns>A pointer to a shadow c++ callback</returns>
+        public static IntPtr ToIntPtr(CaptureEngineOnSampleCallback callback)
+        {
+            return ToCallbackPtr<CaptureEngineOnSampleCallback>(callback);
+        }
+
+        public class CaptureEngineOnSampleCallbackVtbl : ComObjectVtbl
+        {
+            public CaptureEngineOnSampleCallbackVtbl(int numberOfMethods) : base(numberOfMethods + 1)
+            {
+                AddMethod(new OnSampleCallback(OnSampleImpl));
+            }
+
+            /// <unmanaged>HRESULT IMFCaptureEngineOnEventCallback::OnEvent([In] IMFMediaEvent* pEvent)</unmanaged>	
+            [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+            private delegate int OnSampleCallback(IntPtr thisPtr, IntPtr sample);
+            private static int OnSampleImpl(IntPtr thisPtr, IntPtr sample)
+            {
+                try
+                {
+                    var shadow = ToShadow<CaptureEngineOnSampleCallbackShadow>(thisPtr);
+                    var callback = (CaptureEngineOnSampleCallback)shadow.Callback;
+                    var sampleRef = new Sample(sample);
+                    callback.OnSample(sampleRef);
+                }
+                catch (Exception exception)
+                {
+                    return (int)SharpDX.Result.GetResultFromException(exception);
+                }
+                return Result.Ok.Code;
+            }
+        }
+
+        protected override CppObjectVtbl GetVtbl
+        {
+            get { return Vtbl; }
+        }
+    }
+}
+#endif

Source/SharpDX.MediaFoundation/Mapping-core.xml

@@ -759,11 +759,14 @@
     <map param="IMFMediaEngineClassFactory::CreateInstance::dwFlags" type="MF_MEDIA_ENGINE_CREATEFLAGS" name="flags"/>
 
     <map interface="IMFMediaEngineNotify" callback="true" visibility="internal"/>
+    <map interface="IMFCaptureEngineOnEventCallback" callback="true" visibility="internal" />
 
     <map interface="IMFClockStateSink" callback="true"/>
     <map interface="IMFSampleGrabberSinkCallback" callback="true"/>
     <map interface="IMFSampleGrabberSinkCallback2" callback="true"/>
     <map interface="IMFVideoPresenter" callback="true"/>
+    <map interface="IMFCaptureEngineOnSampleCallback" callback="true"/>
+    <map interface="IMFCaptureEngineOnSampleCallback2" callback="true"/>
 
     <map method="IMFDXGIDeviceManager::ResetDevice" visibility="internal"/>
     <map param="IMFDXGIDeviceManager::OpenDeviceHandle::phDevice" return="true"/>

Source/SharpDX.MediaFoundation/SharpDX.MediaFoundation.csproj

@@ -22,6 +22,12 @@
     <Compile Include="AudioDecoder.cs" />
     <Compile Include="ByteStream.cs" />
     <Compile Include="AsyncCallbackShadow.cs" />
+    <Compile Include="CaptureEngineOnEventCallback.cs" />
+    <Compile Include="CaptureEngineOnEventCallbackShadow.cs" />
+    <Compile Include="CaptureEngineOnSampleCallback.cs" />
+    <Compile Include="CaptureEngineOnSampleCallback2.cs" />
+    <Compile Include="CaptureEngineOnSampleCallback2Shadow.cs" />
+    <Compile Include="CaptureEngineOnSampleCallbackShadow.cs" />
     <Compile Include="ClockStateSink.cs" />
     <Compile Include="ClockStateSinkShadow.cs" />
     <Compile Include="MediaTypeHandler.cs" />