/// <summary>
/// 任意のインターフェースの取得
/// </summary>
/// <param name="graph">対象のグラフ</param>
/// <returns>
/// 取得したインターフェースを返します。
/// </returns>
public static TI GetInterface <TI>(IGraphBuilder graph)
{
if (graph == null)
{
return(default(TI));
}
IEnumFilters pEnum = null;
graph.EnumFilters(ref pEnum);
if (pEnum == null)
{
return(default(TI));
}
while (true)
{
IBaseFilter filter = null;
int fetched = 0;
int status = pEnum.Next(1, ref filter, ref fetched);
if (status != 0)
{
break;
}
if (filter is TI)
{
return((TI)filter);
}
}
return(default(TI));
}
private void GetBaseFilter(IGraphBuilder pGraphBuilder)
{
IEnumFilters pEnum = null;
IBaseFilter pFilter;
int cFetched;
int hr = pGraphBuilder.EnumFilters(out pEnum);
if (DsHlp.SUCCEEDED(hr))
{
while (pEnum.Next(1, out pFilter, out cFetched) == DsHlp.S_OK)
{
Guid clsid;
if (pFilter.GetClassID(out clsid) == DsHlp.S_OK && clsid == RendererID)
{
BaseFilter = pFilter;
break;
}
else
{
Marshal.ReleaseComObject(pFilter);
}
}
Marshal.ReleaseComObject(pEnum);
}
}
private IBaseFilter findFilter(string name)
{
int hr = 0;
IEnumFilters eFilters = null;
hr = (this.graph as IGraphBuilder).EnumFilters(out eFilters);
checkHR(hr, "Couldn't enumerate filters in graph");
IntPtr pFiltersFetched = Marshal.AllocCoTaskMem(4);
IBaseFilter[] pFilter = new IBaseFilter[1];
while (eFilters.Next(1, pFilter, pFiltersFetched) == 0)
{
FilterInfo pInfo;
pFilter[0].QueryFilterInfo(out pInfo);
bool found = (pInfo.achName == name);
if (found)
{
return(pFilter[0]);
}
}
return(null);
}
public void TestClone()
{
int hr = 0;
IEnumFilters clone = null;
IBaseFilter[] filters = new IBaseFilter[1];
int filterCount1 = 0;
int filterCount2 = 0;
// Reset enumeration to be sure we are at the begining
hr = this.enumFilters.Reset();
DsError.ThrowExceptionForHR(hr);
// Clone our enumeration object
hr = this.enumFilters.Clone(out clone);
DsError.ThrowExceptionForHR(hr);
// Count how many filters are in this enumearation
while (this.enumFilters.Next(1, filters, IntPtr.Zero) == 0)
{
Marshal.ReleaseComObject(filters[0]);
filterCount1++;
}
// Count how many filters are in this enumearation
while (clone.Next(1, filters, IntPtr.Zero) == 0)
{
Marshal.ReleaseComObject(filters[0]);
filterCount2++;
}
// both enumeration should have equal items number
// 6 filters for me
Debug.Assert(filterCount1 == filterCount2, "IEnumFilters.Clone");
}
/// <summary>
/// Log the filters in the graph.
/// </summary>
protected void LogFilters()
{
LogMessage("Logging filters");
IEnumFilters enumFilters = null;
IBaseFilter[] filters = new IBaseFilter[1];
reply = graphBuilder.EnumFilters(out enumFilters);
DsError.ThrowExceptionForHR(reply);
while (enumFilters.Next(filters.Length, filters, IntPtr.Zero) == 0)
{
FilterInfo filterInfo;
reply = filters[0].QueryFilterInfo(out filterInfo);
DsError.ThrowExceptionForHR(reply);
LogMessage("Filter: " + filterInfo.achName);
logPins(filters[0]);
if (filterInfo.pGraph != null)
{
Marshal.ReleaseComObject(filterInfo.pGraph);
}
Marshal.ReleaseComObject(filters[0]);
}
Marshal.ReleaseComObject(enumFilters);
LogMessage("All filters logged");
}
public static IBaseFilter FindFilterByClsid(IGraphBuilder graphBuilder, Guid filterClsid)
{
int hr = 0;
IBaseFilter filter = null;
IEnumFilters enumFilters = null;
if (graphBuilder == null)
{
throw new ArgumentNullException("graphBuilder");
}
hr = graphBuilder.EnumFilters(out enumFilters);
if (hr == 0)
{
IBaseFilter[] filters = new IBaseFilter[1];
while (enumFilters.Next(filters.Length, filters, IntPtr.Zero) == 0)
{
Guid clsid;
hr = filters[0].GetClassID(out clsid);
if ((hr == 0) && (clsid == filterClsid))
{
filter = filters[0];
break;
}
Marshal.ReleaseComObject(filters[0]);
}
Marshal.ReleaseComObject(enumFilters);
}
return(filter);
}
public void TestEnumFilters()
{
int hr = 0;
IEnumFilters enumFilters = null;
hr = this.filterGraph.EnumFilters(out enumFilters);
Marshal.ThrowExceptionForHR(hr);
Debug.Assert(enumFilters != null, "IFilterGraph.EnumFilters");
Marshal.ReleaseComObject(enumFilters);
}
private static IPin GetPinByMediaType(IGraphBuilder pGraph, PinDirection pinDir, bool bConnected, Guid type, bool isSubType)
{
IEnumFilters pEnumFilters = null;
IBaseFilter pFilter = null;
int cFetched;
int hr = pGraph.EnumFilters(out pEnumFilters);
if (DsHlp.FAILED(hr))
{
return(null);
}
IPin pPin = null;
var found = false;
while ((pEnumFilters.Next(1, out pFilter, out cFetched) == DsHlp.S_OK))
{
pPin = GetPin(pFilter, pinDir, bConnected, 0);
if (pPin != null)
{
if (isSubType && IsSubTypeSupported(pPin, type) == 0)
{
found = true;
}
else if (!isSubType && IsMediaTypeSupported(pPin, type) == 0)
{
found = true;
}
if (!found)
{
Marshal.ReleaseComObject(pPin);
pPin = null;
}
}
Marshal.ReleaseComObject(pFilter);
if (found)
{
break;
}
}
Marshal.ReleaseComObject(pEnumFilters);
return(pPin);
}
public static IBaseFilter FindFilterByName(IGraphBuilder graphBuilder, string filterName)
{
int hr = 0;
IBaseFilter filter = null;
IEnumFilters enumFilters = null;
if (graphBuilder == null)
{
throw new ArgumentNullException("graphBuilder");
}
hr = graphBuilder.EnumFilters(out enumFilters);
if (hr == 0)
{
IBaseFilter[] filters = new IBaseFilter[1];
IntPtr fetched = Marshal.AllocCoTaskMem(4);
try
{
while (enumFilters.Next(filters.Length, filters, fetched) == 0)
{
FilterInfo filterInfo;
hr = filters[0].QueryFilterInfo(out filterInfo);
if (hr == 0)
{
if (filterInfo.pGraph != null)
{
Marshal.ReleaseComObject(filterInfo.pGraph);
}
if (filterInfo.achName.Equals(filterName))
{
filter = filters[0];
break;
}
}
Marshal.ReleaseComObject(filters[0]);
}
}
finally
{
Marshal.ReleaseComObject(enumFilters);
Marshal.FreeCoTaskMem(fetched);
}
}
return(filter);
}
public static int TraceFilterGraph(IGraphBuilder pGraph)
{
IEnumFilters pEnum = null;
IBaseFilter pFilter;
int cFetched;
int hr = pGraph.EnumFilters(out pEnum);
if (DsHlp.FAILED(hr))
{
return(hr);
}
Trace.WriteLine("Tracing filter graph...");
while (pEnum.Next(1, out pFilter, out cFetched) == DsHlp.S_OK)
{
string filterName;
FilterInfo fInfo = new FilterInfo();
hr = pFilter.QueryFilterInfo(out fInfo);
if (DsHlp.FAILED(hr))
{
filterName = "Unknown filter";
}
else
{
filterName = fInfo.achName;
}
// The FILTER_INFO structure holds a pointer to the Filter Graph
// Manager, with a reference count that must be released.
if (fInfo.pGraph != null)
{
Marshal.ReleaseComObject(fInfo.pGraph);
}
Trace.WriteLine(String.Format("Filter: {0}", filterName));
Trace.Indent();
TraceFilter(pFilter);
Trace.Unindent();
Marshal.ReleaseComObject(pFilter);
}
Marshal.ReleaseComObject(pEnum);
return(DsHlp.S_OK);
}
public static IBaseFilter FindFilterByClsid(IGraphBuilder graphBuilder, Guid filterClsid)
{
int hr = 0;
IBaseFilter filter = null;
IEnumFilters enumFilters = null;
if (graphBuilder == null)
{
throw new ArgumentNullException("graphBuilder");
}
hr = graphBuilder.EnumFilters(out enumFilters);
if (hr == 0)
{
IBaseFilter[] filters = new IBaseFilter[1];
IntPtr fetched = Marshal.AllocCoTaskMem(4);
try
{
while (enumFilters.Next(filters.Length, filters, fetched) == 0)
{
Guid clsid;
hr = filters[0].GetClassID(out clsid);
if ((hr == 0) && (clsid == filterClsid))
{
filter = filters[0];
break;
}
Marshal.ReleaseComObject(filters[0]);
}
}
finally
{
Marshal.FreeCoTaskMem(fetched);
Marshal.ReleaseComObject(enumFilters);
}
}
return(filter);
}
public static IBaseFilter FindFilterByName(IGraphBuilder graphBuilder, string filterName)
{
int hr = 0;
IBaseFilter filter = null;
IEnumFilters enumFilters = null;
if (graphBuilder == null)
{
throw new ArgumentNullException("graphBuilder");
}
hr = graphBuilder.EnumFilters(out enumFilters);
if (hr == 0)
{
IBaseFilter[] filters = new IBaseFilter[1];
//22 int fetched;
//22 while(enumFilters.Next(filters.Length, filters, out fetched) == 0)
while (enumFilters.Next(filters.Length, filters, IntPtr.Zero) == 0)
{
FilterInfo filterInfo;
hr = filters[0].QueryFilterInfo(out filterInfo);
if (hr == 0)
{
if (filterInfo.pGraph != null)
{
Marshal.ReleaseComObject(filterInfo.pGraph);
}
if (filterInfo.achName.Equals(filterName))
{
filter = filters[0];
break;
}
}
Marshal.ReleaseComObject(filters[0]);
}
Marshal.ReleaseComObject(enumFilters);
}
return(filter);
}
private void CleanUpGraph(IGraphBuilder graphBuilder)
{
int hr = 0;
IEnumFilters enumFilters = null;
IBaseFilter[] filters = new IBaseFilter[1];
hr = graphBuilder.EnumFilters(out enumFilters);
Marshal.ThrowExceptionForHR(hr);
while (enumFilters.Next(1, filters, IntPtr.Zero) == 0)
{
hr = graphBuilder.RemoveFilter(filters[0]);
Marshal.ThrowExceptionForHR(hr);
Marshal.ReleaseComObject(filters[0]);
enumFilters.Reset();
}
Marshal.ReleaseComObject(enumFilters);
}
public static int EnumFilters(IGraphBuilder pGraph, out IEnumerable <string> aFilters) // just getting their names here
{
aFilters = null;
IEnumFilters pEnum = null;
IBaseFilter pFilter;
int cFetched;
int hr = pGraph.EnumFilters(out pEnum);
if (DsHlp.FAILED(hr))
{
return(hr);
}
var result = new List <string>();
while (pEnum.Next(1, out pFilter, out cFetched) == DsHlp.S_OK)
{
FilterInfo fInfo = new FilterInfo();
hr = pFilter.QueryFilterInfo(out fInfo);
if (DsHlp.FAILED(hr))
{
result.Add("Could not get the filter info");
continue; // Maybe the next one will work.
}
result.Add(fInfo.achName);
// The FILTER_INFO structure holds a pointer to the Filter Graph
// Manager, with a reference count that must be released.
if (fInfo.pGraph != null)
{
Marshal.ReleaseComObject(fInfo.pGraph);
}
Marshal.ReleaseComObject(pFilter);
}
Marshal.ReleaseComObject(pEnum);
aFilters = result;
return(DsHlp.S_OK);
}
/// <summary>
/// 指定されたフィルタグラフから IAMVideoControl インターフェースを取得します。
/// </summary>
/// <param name="graph">検査対象のフィルタグラフ</param>
/// <returns>
/// 指定されたグラフに含まれるソースフィルタを IAMVideoControl にキャストして返します。
/// サポートしていない場合は null を返します。
/// </returns>
internal static IAMVideoControl GetInterface(IxDSGraphBuilderProvider graph)
{
if (graph == null)
{
return(null);
}
if (graph.GraphBuilder == null)
{
return(null);
}
IEnumFilters pEnum = null;
graph.GraphBuilder.EnumFilters(ref pEnum);
if (pEnum == null)
{
return(null);
}
while (true)
{
IBaseFilter filter = null;
int fetched = 0;
int status = pEnum.Next(1, ref filter, ref fetched);
if (status != 0)
{
break;
}
if (filter is IAMVideoControl)
{
return((IAMVideoControl)filter);
}
}
return(null);
}
protected override void DoStopInternal(object state)
{
IFilterGraph graph = mediaControl as IFilterGraph;
if (graph != null)
{
if (mediaControl != null)
{
int hr = mediaControl.Stop();
DsError.ThrowExceptionForHR(hr);
mediaControl = null;
}
IEnumFilters pEnum = null;
if (COMHelper.SUCCEEDED(graph.EnumFilters(out pEnum)) && pEnum != null)
{
List <IBaseFilter> allFilters = new List <IBaseFilter>();
IBaseFilter[] aFilters = new IBaseFilter[1];
while (COMHelper.S_OK == pEnum.Next(1, aFilters, IntPtr.Zero))
{
allFilters.Add(aFilters[0]);
}
Marshal.ReleaseComObject(pEnum);
foreach (var f in allFilters)
{
if (f != null)
{
graph.RemoveFilter(f);
}
}
}
}
base.DoStopInternal(state);
}
//The following is called for building the PREVIEW graph
#region PREVIEW ONLY
public void Init()
{
Debug.WriteLine("VIDEO FOR PREVIEW");
pGraph = graph;
int hr = 0;
hr = pGraphBuilder.SetFiltergraph(pGraph);
DsError.ThrowExceptionForHR(hr);
pUSB = FindCaptureDevice();
hr = pGraph.AddFilter(pUSB, "WebCamControl Video");
DsError.ThrowExceptionForHR(hr);
hr = pGraph.AddFilter(pSampleGrabber as IBaseFilter, "SampleGrabber");
checkHR(hr, "Can't add SampleGrabber to graph");
i_grabber = (ISampleGrabber)pSampleGrabber;
i_grabber.SetBufferSamples(true);
IVMRAspectRatioControl9 ratioControl9 = (IVMRAspectRatioControl9)renderFilter;
hr = ratioControl9.SetAspectRatioMode(VMRAspectRatioMode.LetterBox);
DsError.ThrowExceptionForHR(hr);
hr = pGraph.AddFilter(renderFilter, "My Render Filter");
DsError.ThrowExceptionForHR(hr);
//SetFormat();
hr = pGraphBuilder.RenderStream(PinCategory.Preview, MediaType.Video, pUSB, (IBaseFilter)pSampleGrabber, renderFilter);
DsError.ThrowExceptionForHR(hr);
Debug.WriteLine(DsError.GetErrorText(hr) + " is error in rendering");
IEnumFilters enumFilters = null;
IBaseFilter[] baseFilters = { null };
IntPtr fetched = IntPtr.Zero;
hr = pGraph.EnumFilters(out enumFilters);
int r = 0;
while (r == 0)
{
try
{
r = enumFilters.Next(baseFilters.Length, baseFilters, fetched);
DsError.ThrowExceptionForHR(hr);
baseFilters[0].QueryFilterInfo(out FilterInfo filterInfo);
Debug.WriteLine(filterInfo.achName + " -filtername");
}
catch
{
r = 1;
continue;
}
}
SafeReleaseComObject(pUSB);
SafeReleaseComObject(pAVIMux);
SafeReleaseComObject(pGraph);
SafeReleaseComObject(pGraphBuilder);
SafeReleaseComObject(pSampleGrabber);
//SafeReleaseComObject(sampleGrabber);
SafeReleaseComObject(pSmartTee);
SafeReleaseComObject(renderFilter);
SafeReleaseComObject(nullRender);
SafeReleaseComObject(mediaEventEx);
SafeReleaseComObject(ratioControl9);
SafeReleaseComObject(streamConfig);
SafeReleaseComObject(mediaControl);
//SafeReleaseComObject(format);
//SafeReleaseComObject(i_grabber);
SafeReleaseComObject(graph);
SetupVideoWindow();
}
// this function should be called AFTER the video stream has been rendered
// but before rendering the audio streams
// however, it will try to find the splitter even if video wasn't rendered
private bool FindSplitter(IGraphBuilder pGraphBuilder)
{
if (_splitterFilter != null)
{
DsUtils.RemoveRedundantFilters(_sourceFilter, pGraphBuilder);
return(true);
}
IEnumFilters pEnumFilters = null;
IBaseFilter pFilter = null;
int cFetched;
bool bSplitterFound = false;
int hr = pGraphBuilder.EnumFilters(out pEnumFilters);
if (DsHlp.FAILED(hr))
{
return(false);
}
IPin pPin;
int nFilters = 0;
bool bCanRelease;
while ((pEnumFilters.Next(1, out pFilter, out cFetched) == DsHlp.S_OK))
{
nFilters++;
bCanRelease = true;
pPin = DsUtils.GetPin(pFilter, PinDirection.Output, false, 0);
if (pPin != null)
{
if (DsUtils.IsMediaTypeSupported(pPin, MediaType.Audio) == 0 ||
DsUtils.IsMediaTypeSupported(pPin, MediaType.Subtitle) == 0)
{
//this unconnected pin supports audio or subpicture type!
bSplitterFound = true;
bCanRelease = false;
_splitterFilter = pFilter;
}
Marshal.ReleaseComObject(pPin);
}
//let's have a look at another filter
if (bCanRelease)
{
Marshal.ReleaseComObject(pFilter);
}
if (bSplitterFound)
{
break;
}
}
Marshal.ReleaseComObject(pEnumFilters);
if (!bSplitterFound)
{
if (nFilters > 3)
{
pPin = DsUtils.GetPin(_sourceFilter, PinDirection.Output, true, 0);
if (pPin != null)
{
IPin pInputPin;
hr = pPin.ConnectedTo(out pInputPin);
if (hr == DsHlp.S_OK)
{
PinInfo info = new PinInfo();
hr = pInputPin.QueryPinInfo(out info);
if (hr == DsHlp.S_OK)
{
_splitterFilter = info.pFilter;
bSplitterFound = true;
}
Marshal.ReleaseComObject(pInputPin);
}
Marshal.ReleaseComObject(pPin);
}
}
else
{
_splitterFilter = _sourceFilter;
bSplitterFound = true;
}
}
StripSplitter(pGraphBuilder);
return(bSplitterFound);
}
//private void EnablePlaybackMenu(bool bEnable, MediaType nMediaType)
//{
// // Enable/disable menu items related to playback (pause, stop, mute)
// menuFilePause.Enabled = bEnable;
// menuFileStop.Enabled = bEnable;
// menuFileMute.Enabled = bEnable;
// menuRateIncrease.Enabled = bEnable;
// menuRateDecrease.Enabled = bEnable;
// menuRateNormal.Enabled = bEnable;
// menuRateHalf.Enabled = bEnable;
// menuRateDouble.Enabled = bEnable;
// // Enable/disable menu items related to video size
// bool isVideo = (nMediaType == MediaType.Video) ? true : false;
// menuSingleStep.Enabled = isVideo;
// menuFileSizeHalf.Enabled = isVideo;
// menuFileSizeDouble.Enabled = isVideo;
// menuFileSizeNormal.Enabled = isVideo;
// menuFileSizeThreeQuarter.Enabled = isVideo;
// menuFileFullScreen.Enabled = isVideo;
//}
#endregion //PRIVATEMETHODS
///////////////////////////////////////////////////////////////////////////////
// Small helping Methods //
///////////////////////////////////////////////////////////////////////////////
#region HELPER
private void EnableAudio(bool enable)
{
try
{
if (this.isAudioOnly)
{
return;
}
if (this.mediaControl == null)
{
return;
}
//Need to stop replay, otherwise removing of filters will crash
this.mediaControl.Stop();
int hr = 0;
bool isAudio = false;
if (!enable)
{
// All audio filters should be removed,
// so iterate through all filters, find each with a audio pin
// and remove it from the graph
IEnumFilters enumFilters = null;
if (graphBuilder == null)
{
throw new ArgumentNullException("graphBuilder");
}
hr = graphBuilder.EnumFilters(out enumFilters);
if (hr == 0)
{
IBaseFilter[] filters = new IBaseFilter[1];
while (enumFilters.Next(filters.Length, filters, IntPtr.Zero) == 0)
{
FilterInfo filterInfo;
hr = filters[0].QueryFilterInfo(out filterInfo);
if (hr == 0)
{
if (filterInfo.pGraph != null)
{
Marshal.ReleaseComObject(filterInfo.pGraph);
}
IEnumPins pins;
filters[0].EnumPins(out pins);
IPin[] pin = new IPin[1];
while (pins.Next(1, pin, IntPtr.Zero) == 0)
{
AMMediaType media = new AMMediaType();
pin[0].ConnectionMediaType(media);
if (media.majorType == MediaType.Audio)
{
isAudio = true;
break;
}
}
if (isAudio)
{
hr = this.graphBuilder.RemoveFilter(filters[0]);
DsError.ThrowExceptionForHR(hr);
}
}
}
if (filters[0] != null)
{
Marshal.ReleaseComObject(filters[0]);
}
}
Marshal.ReleaseComObject(enumFilters);
}
else
{
//Recreate whole replay graph, disposing any old values first.
LoadMovie(this.filename);
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
private static RendererBase TryGetUnknownRenderer(IGraphBuilder pGraphBuilder)
{
// this is the last resort
RendererBase renderer = null;
IEnumFilters pEnum = null;
IBaseFilter pFilter;
int cFetched;
int hr = pGraphBuilder.EnumFilters(out pEnum);
if (DsHlp.SUCCEEDED(hr))
{
bool bFound = false;
while (!bFound && pEnum.Next(1, out pFilter, out cFetched) == DsHlp.S_OK)
{
IPin pPin = null;
// there should be no output pins
if ((pPin = DsUtils.GetPin(pFilter, PinDirection.Output, false)) != null)
{
// there is an unconnected output pin, this is not a renderer
Marshal.ReleaseComObject(pPin);
}
else if ((pPin = DsUtils.GetPin(pFilter, PinDirection.Output, true)) != null)
{
// there is a connected output pin, this is not a renderer
Marshal.ReleaseComObject(pPin);
}
else
{
// let's check the input pins: there must be at least one connected of type 'video'
int nSkip = 0;
while ((pPin = DsUtils.GetPin(pFilter, PinDirection.Input, true, nSkip)) != null)
{
if (DsUtils.IsMediaTypeSupported(pPin, MediaType.Video) == 0)
{
// there is connected input pin of type 'video'; this looks like a renderer
Marshal.ReleaseComObject(pPin);
renderer = GetRenderer(Renderer.VR); // let's just default it VR
renderer.BaseFilter = pFilter;
bFound = true;
break;
}
else
{
nSkip++;
Marshal.ReleaseComObject(pPin);
}
}
}
if (!bFound)
{
Marshal.ReleaseComObject(pFilter);
}
}
Marshal.ReleaseComObject(pEnum);
}
return(renderer);
}
public static void RemoveRedundantFilters(IBaseFilter sourceFilter, IGraphBuilder graphBuilder)
{
IEnumFilters pEnumFilters = null;
IBaseFilter pFilter = null;
int cFetched;
int hr;
bool bCallAgain = false;
// get information about the source filter (its name)
FilterInfo fSourceInfo = new FilterInfo();
if (sourceFilter != null)
{
hr = sourceFilter.QueryFilterInfo(out fSourceInfo);
if (DsHlp.SUCCEEDED(hr))
{
if (fSourceInfo.pGraph != null)
{
Marshal.ReleaseComObject(fSourceInfo.pGraph);
}
}
else
{
fSourceInfo.achName = null;
}
}
// let's start enumerating filters
hr = graphBuilder.EnumFilters(out pEnumFilters);
if (DsHlp.FAILED(hr))
{
return;
}
while ((pEnumFilters.Next(1, out pFilter, out cFetched) == DsHlp.S_OK))
{
FilterInfo fInfo = new FilterInfo();
hr = pFilter.QueryFilterInfo(out fInfo);
if (DsHlp.FAILED(hr))
{
Marshal.ReleaseComObject(pFilter);
continue; // don't touch this one
}
// The FILTER_INFO structure holds a pointer to the Filter Graph
// Manager, with a reference count that must be released.
if (fInfo.pGraph != null)
{
Marshal.ReleaseComObject(fInfo.pGraph);
}
if (fInfo.achName == null || fSourceInfo.achName == null)
{
Marshal.ReleaseComObject(pFilter);
continue;
}
if (fInfo.achName == fSourceInfo.achName) // source filter
{
Marshal.ReleaseComObject(pFilter);
continue;
}
IPin pPin = DsUtils.GetPin(pFilter, PinDirection.Input, true, 0);
if (pPin == null)
{
// this filter does not have connected input pins
graphBuilder.RemoveFilter(pFilter);
Marshal.ReleaseComObject(pFilter);
bCallAgain = true;
break;
}
else
{
// this filter is connected, let's try another one
Marshal.ReleaseComObject(pPin);
Marshal.ReleaseComObject(pFilter);
}
}
Marshal.ReleaseComObject(pEnumFilters);
if (bCallAgain)
{
RemoveRedundantFilters(sourceFilter, graphBuilder);
}
}
internal static IRenderer GetExistingRenderer(IGraphBuilder pGraphBuilder, IntPtr hMediaWindow)
{
// this method is to be called to create a wrapper for a renderer that is already in the graph (added by intelligent connect)
// at the momemnt it is assumed that this is a Windowed Renderer (compatability assumption)
RendererBase renderer = null;
try
{
IEnumFilters pEnum = null;
IBaseFilter pFilter;
int cFetched;
int hr = pGraphBuilder.EnumFilters(out pEnum);
if (DsHlp.SUCCEEDED(hr))
{
while (pEnum.Next(1, out pFilter, out cFetched) == DsHlp.S_OK)
{
Guid clsid;
if (pFilter.GetClassID(out clsid) == DsHlp.S_OK)
{
renderer = GetRenderer(clsid);
if (renderer != null)
{
renderer.BaseFilter = pFilter;
break;
}
else
{
Marshal.ReleaseComObject(pFilter);
}
}
else
{
Marshal.ReleaseComObject(pFilter);
}
}
Marshal.ReleaseComObject(pEnum);
}
if (renderer == null)
{
renderer = TryGetUnknownRenderer(pGraphBuilder); // last resort
}
if (renderer == null)
{
throw new FilterGraphBuilderException(GraphBuilderError.VideoRenderer); // we've tried hard enough, there is no point to continue
}
if (!renderer.IsDelayedInitialize)
{
renderer.Initialize(pGraphBuilder, hMediaWindow);
}
renderer.GraphBuilder = pGraphBuilder;
renderer.MediaWindowHandle = hMediaWindow;
renderer._ready = true;
return(renderer);
}
finally
{
if (renderer != null && !renderer._ready)
{
renderer.Close();
}
}
}
public static void RemoveFilters(IGraphBuilder graphBuilder, string filterName)
{
if (graphBuilder == null)
{
return;
}
int hr = 0;
IEnumFilters enumFilters = null;
ArrayList filtersArray = new ArrayList();
try
{
hr = graphBuilder.EnumFilters(out enumFilters);
DsError.ThrowExceptionForHR(hr);
IBaseFilter[] filters = new IBaseFilter[1];
IntPtr fetched = IntPtr.Zero;
while (enumFilters.Next(filters.Length, filters, fetched) == 0)
{
filtersArray.Add(filters[0]);
}
foreach (IBaseFilter filter in filtersArray)
{
FilterInfo info;
filter.QueryFilterInfo(out info);
Marshal.ReleaseComObject(info.pGraph);
try
{
if (!String.IsNullOrEmpty(filterName))
{
if (String.Equals(info.achName, filterName))
{
DisconnectAllPins(graphBuilder, filter);
hr = graphBuilder.RemoveFilter(filter);
DsError.ThrowExceptionForHR(hr);
Marshal.ReleaseComObject(filter);
log.Debug("Remove filter from graph: {0}", info.achName);
}
}
else
{
DisconnectAllPins(graphBuilder, filter);
hr = graphBuilder.RemoveFilter(filter);
DsError.ThrowExceptionForHR(hr);
int i = Marshal.ReleaseComObject(filter);
log.Debug(string.Format("Remove filter from graph: {0} {1}", info.achName, i));
}
}
catch (Exception ex)
{
log.Error(ex, "Remove of filter failed with code (HR): {0}, explanation: {1}", info.achName, hr.ToString());
}
}
}
catch (Exception)
{
return;
}
finally
{
if (enumFilters != null)
{
Marshal.ReleaseComObject(enumFilters);
}
}
}
/// <summary>
/// デバッグ
/// </summary>
/// <param name="graph"></param>
private void DebugPrint(IGraphBuilder graph)
{
IEnumFilters filters = null;
IBaseFilter filter = null;
int fetched = 0;
int hr = graph.EnumFilters(ref filters);
while (filters.Next(1, ref filter, ref fetched) == (int)DSLab.HRESULT.S_OK)
{
if (fetched == 0)
{
break;
}
FILTER_INFO info = new FILTER_INFO();
hr = filter.QueryFilterInfo(info);
Console.WriteLine("{0}", info.achName);
// フィルタ解放.
Marshal.ReleaseComObject(filter);
filter = null;
}
// 解放.
Marshal.ReleaseComObject(filters);
// サンプルグラバフィルタの入力形式設定.
// majortype: http://msdn.microsoft.com/ja-jp/library/cc370108.aspx
// subtype : http://msdn.microsoft.com/ja-jp/library/cc371040.aspx
AM_MEDIA_TYPE media_type = new AM_MEDIA_TYPE();
SampleGrabber.GetConnectedMediaType(media_type);
Debug.WriteLine("{0}:{1}", "majortype", media_type.majortype);
Debug.WriteLine("{0}:{1}", "subtype", media_type.subtype);
Debug.WriteLine("{0}:{1}", "formattype", media_type.formattype);
Debug.WriteLine("{0}:{1}", "bFixedSizeSamples", media_type.bFixedSizeSamples);
Debug.WriteLine("{0}:{1}", "bTemporalCompression", media_type.bTemporalCompression);
Debug.WriteLine("{0}:{1}", "cbFormat", media_type.cbFormat);
Debug.WriteLine("{0}:{1}", "lSampleSize", media_type.lSampleSize);
Debug.WriteLine("{0}:{1}", "pbFormat", media_type.pbFormat);
Debug.WriteLine("{0}:{1}", "pUnk", media_type.pUnk);
// 映像形式の場合、サイズを取得する.
if (GUID.Compare(media_type.formattype.ToString(), GUID.FORMAT_VideoInfo))
{
VIDEOINFOHEADER vinfo = new VIDEOINFOHEADER();
vinfo = (VIDEOINFOHEADER)Marshal.PtrToStructure(media_type.pbFormat, typeof(VIDEOINFOHEADER));
Debug.WriteLine("{0}:{1}", "Width", vinfo.bmiHeader.biWidth);
Debug.WriteLine("{0}:{1}", "Height", vinfo.bmiHeader.biHeight);
Debug.WriteLine("{0}:{1}", "BitCount", vinfo.bmiHeader.biBitCount);
Debug.WriteLine("{0}:{1}", "Size", vinfo.bmiHeader.biSize);
Debug.WriteLine("{0}:{1}", "ImageSize", vinfo.bmiHeader.biSizeImage);
Debug.WriteLine("{0}:{1}", "ClrImportant", vinfo.bmiHeader.biClrImportant);
Debug.WriteLine("{0}:{1}", "ClrUsed", vinfo.bmiHeader.biClrUsed);
Debug.WriteLine("{0}:{1}", "Compression", vinfo.bmiHeader.biCompression);
Debug.WriteLine("{0}:{1}", "Planes", vinfo.bmiHeader.biPlanes);
Debug.WriteLine("{0}:{1}", "XPelsPerMeter", vinfo.bmiHeader.biXPelsPerMeter);
Debug.WriteLine("{0}:{1}", "YPelsPerMeter", vinfo.bmiHeader.biYPelsPerMeter);
}
}
/// <summary>
/// Build the graph and connect filters
/// </summary>
private void BuildGraph()
{
///Create a graph builder.
this._graphBuilder = (IGraphBuilder) new FilterGraph();
///Create a sample grabber filter. Sample grabber filter provides callback
///for application to grab video frames on the fly.
this._sampleGrabber = (ISampleGrabber) new SampleGrabber();
///Configure the sample grabber
this.ConfigureSampleGrabber(this._sampleGrabber);
///Create the file reader filter.
this._fileReaderFilter = ComGuids.GetFilterFromGuid(ComGuids.FileReaderFilterGuid);
///Add the filter to graph. This function only adds filter to graph but
///do not connect it
this._graphBuilder.AddFilter(this._fileReaderFilter, "File Source");
///Get source filter, this will let you load an AVI file
IFileSourceFilter sourceFilter = this._fileReaderFilter as IFileSourceFilter;
///Load the file
sourceFilter.Load(this._srcFile, null);
///Create AVI splitter. This filter splits the AVI file into video and audio or other
///components that form the video (e.g text)
this._aviSplitter = ComGuids.GetFilterFromGuid(ComGuids.AviSplitterGuid);
///Add the filter to graph
this._graphBuilder.AddFilter(this._aviSplitter, "AVI Splitter");
///Add the sample grabber filter to graph
this._graphBuilder.AddFilter((IBaseFilter)this._sampleGrabber, "SampleGrabber");
///Create AVI mux filter. This filter will combine the audio and video in one stream.
///We will use this filter to combine audio and video streams after hiding
///data in ISampleGrabber's BufferCB callback.
this._aviMultiplexer = ComGuids.GetFilterFromGuid(ComGuids.AviMultiplexerGuid);
///Add filter to graph
this._graphBuilder.AddFilter(this._aviMultiplexer, "AVI multiplexer");
///Create a file writer filter. This filter will be used to write the AVI stream
///to a file
this._rendererFilter = ComGuids.GetFilterFromGuid(ComGuids.FileWriterFilterGuid);
///Add renderer filter to graph
this._graphBuilder.AddFilter(this._rendererFilter, "File writer");
///Get the file sink filter
IFileSinkFilter sinkFilter = this._rendererFilter as IFileSinkFilter;
///Set the output file name
sinkFilter.SetFileName(this._dcFile, null);
///Connect the filter that are added to graph
DirectShowUtil.ConnectFilters(this._graphBuilder, this._fileReaderFilter, this._aviSplitter);
DirectShowUtil.ConnectFilters(this._graphBuilder, this._aviSplitter, (IBaseFilter)this._sampleGrabber);
DirectShowUtil.ConnectFilters(this._graphBuilder, (IBaseFilter)this._sampleGrabber, this._aviMultiplexer);
DirectShowUtil.ConnectFilters(this._graphBuilder, this._aviMultiplexer, this._rendererFilter);
IEnumFilters enu = null;
_graphBuilder.EnumFilters(out enu);
if (enu != null)
{
IBaseFilter[] filters = new IBaseFilter[1];
while (enu.Next(1, filters, IntPtr.Zero) == 0)
{
FilterInfo info;
filters[0].QueryFilterInfo(out info);
if (info.achName.Equals("AVI multiplexer", StringComparison.OrdinalIgnoreCase))
{
IBaseFilter temp = filters[0];
IEnumPins penum;
IPin[] pins = new IPin[1];
temp.EnumPins(out penum);
while (penum.Next(1, pins, IntPtr.Zero) == 0)
{
PinDirection direction;
PinInfo pinfo;
FilterInfo finfo;
IEnumMediaTypes enuM;
AMMediaType[] types = new AMMediaType[1];
pins[0].QueryDirection(out direction);
pins[0].EnumMediaTypes(out enuM);
while (enuM.Next(1, types, IntPtr.Zero) == 0)
{
}
pins[0].QueryPinInfo(out pinfo);
IBaseFilter pinFilter = pinfo.filter;
pinFilter.QueryFilterInfo(out finfo);
}
}
string name = info.achName;
}
}
}
