private void TestGroupCount()
{
int hr;
int c;
IAMTimelineObj pGroup;
hr = m_pTimeline.GetGroupCount(out c);
DESError.ThrowExceptionForHR(hr);
Debug.Assert(c == 1, "GetGroupCount");
hr = m_pTimeline.ClearAllGroups();
DESError.ThrowExceptionForHR(hr);
hr = m_pTimeline.GetGroupCount(out c);
DESError.ThrowExceptionForHR(hr);
Debug.Assert(c == 0, "ClearAllGroups");
hr = m_pTimeline.AddGroup((IAMTimelineObj)m_pVideoGroup);
DESError.ThrowExceptionForHR(hr);
hr = m_pTimeline.GetGroup(out pGroup, 0);
DESError.ThrowExceptionForHR(hr);
hr = m_pTimeline.RemGroupFromList((IAMTimelineObj)pGroup);
DESError.ThrowExceptionForHR(hr);
hr = m_pTimeline.GetGroupCount(out c);
DESError.ThrowExceptionForHR(hr);
Debug.Assert(c == 0, "RemGroupFromList");
}
/// <summary>
/// Configure the graph to output the results to a video window.
/// </summary>
/// <remarks>
/// The callback routines are invoked once for each sample. This allows for additional processing to
/// be performed on the video or audio buffers.
/// </remarks>
/// <param name="hWnd">Window handle to render to, or IntPtr.Zero to render to its own window</param>
/// <param name="pVideoCallback">Callback routine to be called for each video frame or null for no callback</param>
/// <param name="pAudioCallback">Callback routine to be called for each audio frame or null for no callback</param>
/// <param name="video">Render only video</param>
/// <param name="audio">Render only audio</param>
private void RenderToWindow(IntPtr hWnd, IDESCombineCB pVideoCallback, IDESCombineCB pAudioCallback, bool video, bool audio)
{
int hr;
IPin pPin;
IVideoWindow pVidWindow;
IAMTimelineObj pGroup;
// Perform initialization common to all render routines
RenderCommon();
// Contains useful routines for creating the graph
ICaptureGraphBuilder2 icgb = (ICaptureGraphBuilder2) new CaptureGraphBuilder2();
try
{
hr = icgb.SetFiltergraph(m_pGraph);
DESError.ThrowExceptionForHR(hr);
int NumGroups;
hr = m_pTimeline.GetGroupCount(out NumGroups);
DESError.ThrowExceptionForHR(hr);
// Walk the groups. For DESCombine, there is one group that
// contains all the video, and a second group for the audio.
for (int i = 0; i < NumGroups; i++)
{
hr = m_pTimeline.GetGroup(out pGroup, i);
DESError.ThrowExceptionForHR(hr);
try
{
// Inform the graph we will be previewing (rather than writing to disk)
IAMTimelineGroup pTLGroup = (IAMTimelineGroup)pGroup;
hr = pTLGroup.SetPreviewMode(true);
DESError.ThrowExceptionForHR(hr);
}
finally
{
// Release the group
Marshal.ReleaseComObject(pGroup);
}
// Get the IPin for the current group
hr = m_pRenderEngine.GetGroupOutputPin(i, out pPin);
DESError.ThrowExceptionForHR(hr);
try
{
// If this is the video pin
if (video && IsVideo(pPin))
{
// Get a video renderer
IBaseFilter ibfVideoRenderer = (IBaseFilter) new VideoRenderer();
try
{
// Create a sample grabber, add it to the graph and connect it all up
AVCallback mcb = new AVCallback(m_Video, pVideoCallback, (IMediaEventSink)m_pGraph, EC_VideoFileComplete);
RenderWindowHelper(icgb, mcb, "Video", pPin, ibfVideoRenderer);
}
finally
{
Marshal.ReleaseComObject(ibfVideoRenderer);
}
}
else if (audio)
{
// Get an audio renderer
IBaseFilter ibfAudioRenderer = (IBaseFilter) new AudioRender();
try
{
// Create a sample grabber, add it to the graph and connect it all up
AVCallback mcb = new AVCallback(m_Audio, pAudioCallback, (IMediaEventSink)m_pGraph, EC_AudioFileComplete);
RenderWindowHelper(icgb, mcb, "Audio", pPin, ibfAudioRenderer);
}
finally
{
Marshal.ReleaseComObject(ibfAudioRenderer);
}
}
}
finally
{
Marshal.ReleaseComObject(pPin);
}
}
if (video)
{
// Configure the video window
pVidWindow = (IVideoWindow)m_pGraph;
// If a window handle was supplied, use it
if (hWnd != IntPtr.Zero)
{
hr = pVidWindow.put_Owner(hWnd);
DESError.ThrowExceptionForHR(hr);
}
else
{
// Use our own window
hr = pVidWindow.put_Caption("Video Rendering Window");
DESError.ThrowExceptionForHR(hr);
// since no user interaction is allowed, remove
// system menu and maximize/minimize buttons
WindowStyle lStyle = 0;
hr = pVidWindow.get_WindowStyle(out lStyle);
DESError.ThrowExceptionForHR(hr);
lStyle &= ~(WindowStyle.MinimizeBox | WindowStyle.MaximizeBox | WindowStyle.SysMenu);
hr = pVidWindow.put_WindowStyle(lStyle);
DESError.ThrowExceptionForHR(hr);
}
}
}
finally
{
Marshal.ReleaseComObject(icgb);
}
}
protected void RenderGroups(ICaptureGraphBuilder2 graphBuilder, IBaseFilter audioCompressor,
IBaseFilter videoCompressor,
IBaseFilter audioDestination, IBaseFilter videoDestination,
ICallbackParticipant[] audioParticipants,
ICallbackParticipant[] videoParticipants)
{
int hr = 0;
if (audioCompressor != null)
{
_cleanup.Add(audioCompressor);
}
if (videoCompressor != null)
{
_cleanup.Add(videoCompressor);
}
if (audioDestination != null)
{
_cleanup.Add(audioDestination);
}
if ((videoDestination != null) && (audioDestination != videoDestination))
{
_cleanup.Add(videoDestination);
}
IAMTimeline desTimeline = _timeline.DesTimeline;
int groupCount;
hr = desTimeline.GetGroupCount(out groupCount);
DESError.ThrowExceptionForHR(hr);
// Walk the groups. For this class, there is one group that
// contains all the video, and a second group for the audio.
for (int i = (groupCount - 1); i >= 0; i--)
{
IAMTimelineObj group;
hr = desTimeline.GetGroup(out group, i);
DESError.ThrowExceptionForHR(hr);
try
{
// Inform the graph we will be writing to disk (rather than previewing)
var timelineGroup = (IAMTimelineGroup)group;
hr = timelineGroup.SetPreviewMode(false);
DESError.ThrowExceptionForHR(hr);
}
finally
{
Marshal.ReleaseComObject(group);
}
IPin pPin;
// Get the IPin for the current group
hr = _renderEngine.GetGroupOutputPin(i, out pPin);
_cleanup.Add(pPin);
DESError.ThrowExceptionForHR(hr);
try
{
if (FilterGraphTools.IsVideo(pPin))
{
// Create a sample grabber, add it to the graph and connect it all up
var mcb =
new CallbackHandler(videoParticipants);
RenderHelper(graphBuilder, mcb, "Video", pPin, videoCompressor, videoDestination);
}
else
{
// Create a sample grabber, add it to the graph and connect it all up
var mcb =
new CallbackHandler(audioParticipants);
RenderHelper(graphBuilder, mcb, "Audio", pPin, audioCompressor, audioDestination);
}
}
finally
{
Marshal.ReleaseComObject(pPin);
}
}
}
protected void RenderGroups(ICaptureGraphBuilder2 icgb, IBaseFilter audioCompressor, IBaseFilter videoCompressor,
IBaseFilter audioDest, IBaseFilter videoDest, IDESCombineCB pAudioCallback,
IDESCombineCB pVideoCallback)
{
int hr = 0;
if (audioCompressor != null)
{
_dc.Add(audioCompressor);
}
if (videoCompressor != null)
{
_dc.Add(videoCompressor);
}
if (audioDest != null)
{
_dc.Add(audioDest);
}
if ((videoDest != null) && (audioDest != videoDest))
{
_dc.Add(videoDest);
}
IAMTimeline desTimeline = _timeline.DesTimeline;
int NumGroups;
hr = desTimeline.GetGroupCount(out NumGroups);
DESError.ThrowExceptionForHR(hr);
// Walk the groups. For this class, there is one group that
// contains all the video, and a second group for the audio.
for (int i = (NumGroups - 1); i >= 0; i--)
{
IAMTimelineObj pGroup;
hr = desTimeline.GetGroup(out pGroup, i);
DESError.ThrowExceptionForHR(hr);
try
{
// Inform the graph we will be writing to disk (rather than previewing)
IAMTimelineGroup pTLGroup = (IAMTimelineGroup)pGroup;
hr = pTLGroup.SetPreviewMode(false);
DESError.ThrowExceptionForHR(hr);
}
finally
{
Marshal.ReleaseComObject(pGroup);
}
IPin pPin;
// Get the IPin for the current group
hr = _renderEngine.GetGroupOutputPin(i, out pPin);
_dc.Add(pPin);
DESError.ThrowExceptionForHR(hr);
try
{
if (PinUtils.IsVideo(pPin))
{
// Create a sample grabber, add it to the graph and connect it all up
CallbackHandler mcb =
new CallbackHandler(_firstVideoGroup, pVideoCallback, (IMediaEventSink)_graph,
EC_VideoFileComplete);
RenderHelper(icgb, mcb, "Video", pPin, videoCompressor, videoDest);
}
else
{
// Create a sample grabber, add it to the graph and connect it all up
CallbackHandler mcb =
new CallbackHandler(_firstAudioGroup, pAudioCallback, (IMediaEventSink)_graph,
EC_AudioFileComplete);
RenderHelper(icgb, mcb, "Audio", pPin, audioCompressor, audioDest);
}
}
finally
{
Marshal.ReleaseComObject(pPin);
}
}
}
/// <summary>
/// Configure the graph to output the results to a video window.
/// </summary>
/// <remarks>
/// The callback routines are invoked once for each sample. This allows for additional processing to
/// be performed on the video or audio buffers.
/// </remarks>
/// <param name="windowHandle">Window handle to render to, or IntPtr.Zero to render to its own window</param>
/// <param name="videoParticipants">Callback routine to be called for each video frame or null for no callback</param>
/// <param name="audioParticipants">Callback routine to be called for each audio frame or null for no callback</param>
private void RenderToWindow(IntPtr windowHandle, ICallbackParticipant[] videoParticipants,
ICallbackParticipant[] audioParticipants)
{
int hr;
IPin pin;
IVideoWindow videoWindow;
IAMTimelineObj group;
IAMTimeline desTimeline = Timeline.DesTimeline;
// Contains useful routines for creating the graph
var graphBuilder = (ICaptureGraphBuilder2) new CaptureGraphBuilder2();
try
{
hr = graphBuilder.SetFiltergraph(Graph);
DESError.ThrowExceptionForHR(hr);
int NumGroups;
hr = desTimeline.GetGroupCount(out NumGroups);
DESError.ThrowExceptionForHR(hr);
// Walk the groups. For DESCombine, there is one group that
// contains all the video, and a second group for the audio.
for (int i = 0; i < NumGroups; i++)
{
hr = desTimeline.GetGroup(out group, i);
DESError.ThrowExceptionForHR(hr);
try
{
// Inform the graph we will be previewing (rather than writing to disk)
var pTLGroup = (IAMTimelineGroup)group;
hr = pTLGroup.SetPreviewMode(true);
DESError.ThrowExceptionForHR(hr);
}
finally
{
// Release the group
Marshal.ReleaseComObject(group);
}
// Get the IPin for the current group
hr = RenderEngine.GetGroupOutputPin(i, out pin);
DESError.ThrowExceptionForHR(hr);
try
{
// If this is the video pin
if (FilterGraphTools.IsVideo(pin))
{
// Get a video renderer
var ibfVideoRenderer = (IBaseFilter) new VideoRenderer();
try
{
// Create a sample grabber, add it to the graph and connect it all up
var mcb =
new CallbackHandler(videoParticipants);
RenderWindowHelper(graphBuilder, mcb, "Video", pin, ibfVideoRenderer);
}
finally
{
Marshal.ReleaseComObject(ibfVideoRenderer);
}
}
else
{
// Get an audio renderer
var ibfAudioRenderer = (IBaseFilter) new AudioRender();
try
{
// Create a sample grabber, add it to the graph and connect it all up
var mcb =
new CallbackHandler(audioParticipants);
RenderWindowHelper(graphBuilder, mcb, "Audio", pin, ibfAudioRenderer);
}
finally
{
Marshal.ReleaseComObject(ibfAudioRenderer);
}
}
}
finally
{
Marshal.ReleaseComObject(pin);
}
}
// Configure the video window
videoWindow = (IVideoWindow)Graph;
// If a window handle was supplied, use it
if (windowHandle != IntPtr.Zero)
{
hr = videoWindow.put_Owner(windowHandle);
DESError.ThrowExceptionForHR(hr);
}
else
{
// Use our own window
hr = videoWindow.put_Caption(Resources.DefaultVideoRenderingWindowCaption);
DESError.ThrowExceptionForHR(hr);
// since no user interaction is allowed, remove
// system menu and maximize/minimize buttons
WindowStyle lStyle = 0;
hr = videoWindow.get_WindowStyle(out lStyle);
DESError.ThrowExceptionForHR(hr);
lStyle &= ~(WindowStyle.MinimizeBox | WindowStyle.MaximizeBox | WindowStyle.SysMenu);
hr = videoWindow.put_WindowStyle(lStyle);
DESError.ThrowExceptionForHR(hr);
}
}
finally
{
Marshal.ReleaseComObject(graphBuilder);
}
}
