public static void RemoveAllFilters(IGraphBuilder graphBuilder)
{
int hr = 0;
IEnumFilters enumFilters;
var filtersArray = new ArrayList();
if (graphBuilder == null)
{
throw new ArgumentNullException("graphBuilder");
}
hr = graphBuilder.EnumFilters(out enumFilters);
DsError.ThrowExceptionForHR(hr);
try
{
var filters = new IBaseFilter[1];
IntPtr fetched = IntPtr.Zero;
while (enumFilters.Next(filters.Length, filters, fetched) == 0)
{
filtersArray.Add(filters[0]);
}
}
finally
{
Marshal.ReleaseComObject(enumFilters);
}
foreach (IBaseFilter filter in filtersArray)
{
hr = graphBuilder.RemoveFilter(filter);
Marshal.ReleaseComObject(filter);
}
}
protected virtual void SetupAudio()
{
int hr;
IEnumFilters enumFilters;
hr = _graph.EnumFilters(out enumFilters);
DsError.ThrowExceptionForHR(hr);
IBaseFilter[] filters = new IBaseFilter[1];
IntPtr fetched = new IntPtr();
while (enumFilters.Next(1, filters, fetched) == 0)
{
IBaseFilter filter = filters[0] as IBaseFilter;
IPin unconnectedPin = DsFindPin.ByConnectionStatus((IBaseFilter)filter, PinConnectedStatus.Unconnected, 0);
if (unconnectedPin != null)
{
PinDirection direction;
hr = unconnectedPin.QueryDirection(out direction);
DsError.ThrowExceptionForHR(hr);
if (direction == PinDirection.Output)
{
hr = _graph.Render(unconnectedPin);
DsError.ThrowExceptionForHR(hr);
SetupSampleGrabber();
}
}
}
}
public void RemoveAllFilters()
{
int hr = 0;
IEnumFilters enumFilters;
ArrayList filtersArray = new ArrayList();
hr = graph.EnumFilters(out enumFilters);
DsError.ThrowExceptionForHR(hr);
IBaseFilter[] filters = new IBaseFilter[1];
while (enumFilters.Next(filters.Length, filters, IntPtr.Zero) == 0)
{
filtersArray.Add(filters[0]);
}
foreach (IBaseFilter filter in filtersArray)
{
hr = graph.RemoveFilter(filter);
while (Marshal.ReleaseComObject(filter) > 0)
{
;
}
}
}
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);
}
}
/// <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));
}
public static void DisconnectAllPins(IGraphBuilder graphBuilder)
{
int hr = 0;
IEnumFilters enumFilters;
if (graphBuilder == null)
{
throw new ArgumentNullException("graphBuilder");
}
hr = graphBuilder.EnumFilters(out enumFilters);
DsError.ThrowExceptionForHR(hr);
try
{
var filters = new IBaseFilter[1];
IntPtr fetched = IntPtr.Zero;
while (enumFilters.Next(filters.Length, filters, fetched) == 0)
{
try
{
DisconnectPins(filters[0]);
}
catch (COMException)
{
}
Marshal.ReleaseComObject(filters[0]);
}
}
finally
{
Marshal.ReleaseComObject(enumFilters);
}
}
private void ResetGraph(IBaseFilter source)
{
IEnumFilters enumFilters;
var hr = graphBuilder.EnumFilters(out enumFilters);
DsError.ThrowExceptionForHR(hr);
var array = new IBaseFilter[1];
var filters = new List <IBaseFilter>();
while (enumFilters.Next(array.Length, array, IntPtr.Zero) == 0)
{
filters.Add(array[0]);
}
foreach (var filter in filters.Where(filter => filter != source))
{
hr = graphBuilder.RemoveFilter(filter);
DsError.ThrowExceptionForHR(hr);
Marshal.FinalReleaseComObject(filter);
// while (Marshal.ReleaseComObject(filter) > 0)
// {
// }
}
Marshal.ReleaseComObject(enumFilters);
}
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);
}
/// <summary>
/// Finds a pin that exists in a graph.
/// </summary>
/// <param name="majorOrMinorMediaType">The GUID of the major or minor type of the media</param>
/// <param name="pinDirection">The direction of the pin - in/out</param>
/// <param name="graph">The graph to search in</param>
/// <returns>Returns null if the pin was not found, or if a pin is found, returns the first instance of it</returns>
protected static IPin FindPinInGraphByMediaType(Guid majorOrMinorMediaType, PinDirection pinDirection, IGraphBuilder graph)
{
IEnumFilters enumFilters;
/* Get the filter enum */
graph.EnumFilters(out enumFilters);
/* Init our vars */
var filters = new IBaseFilter[1];
var fetched = IntPtr.Zero;
IPin pin = null;
IEnumMediaTypes mediaTypesEnum = null;
/* Loop over each filter in the graph */
while (enumFilters.Next(1, filters, fetched) == 0)
{
var filter = filters[0];
int i = 0;
/* Loop over each pin in the filter */
while ((pin = DsFindPin.ByDirection(filter, pinDirection, i)) != null)
{
/* Get the pin enumerator */
pin.EnumMediaTypes(out mediaTypesEnum);
var mediaTypesFetched = IntPtr.Zero;
var mediaTypes = new AMMediaType[1];
/* Enumerate the media types on the pin */
while (mediaTypesEnum.Next(1, mediaTypes, mediaTypesFetched) == 0)
{
/* See if the major or subtype meets our requirements */
if (mediaTypes[0].majorType.Equals(majorOrMinorMediaType) || mediaTypes[0].subType.Equals(majorOrMinorMediaType))
{
/* We found a match */
goto done;
}
}
i++;
}
}
done:
if (mediaTypesEnum != null)
{
mediaTypesEnum.Reset();
Marshal.ReleaseComObject(mediaTypesEnum);
}
enumFilters.Reset();
Marshal.ReleaseComObject(enumFilters);
return(pin);
}
/// <summary>
/// Removes all filters from a DirectShow graph
/// </summary>
/// <param name="graphBuilder">The DirectShow graph to remove all the filters from</param>
protected static void RemoveAllFilters(IGraphBuilder graphBuilder)
{
if (graphBuilder == null)
{
return;
}
IEnumFilters enumFilters;
/* The list of filters from the DirectShow graph */
var filtersArray = new List <IBaseFilter>();
if (graphBuilder == null)
{
throw new ArgumentNullException("graphBuilder");
}
/* Gets the filter enumerator from the graph */
int hr = graphBuilder.EnumFilters(out enumFilters);
DsError.ThrowExceptionForHR(hr);
try
{
/* This array is filled with reference to a filter */
var filters = new IBaseFilter[1];
IntPtr fetched = IntPtr.Zero;
/* Get reference to all the filters */
while (enumFilters.Next(filters.Length, filters, fetched) == 0)
{
/* Add the filter to our array */
filtersArray.Add(filters[0]);
}
}
finally
{
/* Enum filters is a COM, so release that */
Marshal.ReleaseComObject(enumFilters);
}
/* Loop over and release each COM */
for (int i = 0; i < filtersArray.Count; i++)
{
graphBuilder.RemoveFilter(filtersArray[i]);
while (Marshal.ReleaseComObject(filtersArray[i]) > 0)
{
}
}
}
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);
}
private HRESULT InitInterfaces()
{
CloseInterfaces();
HRESULT hr = E_FAIL;
try
{
m_GraphBuilder = (IGraphBuilder) new FilterGraph();
hr = OnInitInterfaces();
hr.Throw();
return(PreparePlayback());
}
catch (Exception _exception)
{
if (_exception is COMException)
{
hr = (HRESULT)((COMException)_exception).ErrorCode;
}
else
{
hr = E_UNEXPECTED;
}
}
finally
{
if (hr.Succeeded)
{
while (m_Filters.Count > 0)
{
DSFilter _filter = m_Filters[0];
m_Filters.RemoveAt(0);
_filter.Dispose();
}
IEnumFilters pEnum;
if (SUCCEEDED(m_GraphBuilder.EnumFilters(out pEnum)))
{
IBaseFilter[] aFilters = new IBaseFilter[1];
while (S_OK == pEnum.Next(1, aFilters, IntPtr.Zero))
{
m_Filters.Add(new DSFilter(aFilters[0]));
}
Marshal.ReleaseComObject(pEnum);
}
}
}
CloseInterfaces();
return(hr);
}
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);
}
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 void Dispose()
{
// Be goot - release the COM objects
IEnumFilters filters;
IntPtr fetched = IntPtr.Zero;
int hr = _gb.EnumFilters(out filters);
IBaseFilter[] baseFilters = new IBaseFilter[1];
while (filters.Next(baseFilters.Length, baseFilters, fetched) == 0)
{
FilterInfo info;
baseFilters[0].QueryFilterInfo(out info);
if (Marshal.IsComObject(baseFilters[0])) // Only release COM objects
{
Marshal.FinalReleaseComObject(baseFilters[0]);
}
}
Marshal.FinalReleaseComObject(_gb);
}
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>
/// The GetFilter method returns a given filter with a given name or portion of a name.
/// </summary>
/// <param name="ibuilder">Specifies the Graph Builder used to find the filter.</param>
/// <param name="strName">Specifies the filter name to look for.</param>
/// <param name="bExact">Optionally, specifies whether or not to look for the exact name, or just a portion of the name.</param>
/// <returns>If found, the filter is returned, otherwise <i>null</i> is returned.</returns>
public static IBaseFilter GetFilter(IGraphBuilder ibuilder, string strName, bool bExact = true)
{
IEnumFilters ienum;
int hr = ibuilder.EnumFilters(out ienum);
if (hr < 0)
{
Marshal.ThrowExceptionForHR(hr);
}
IBaseFilter ifilter;
uint nFetched;
while (ienum.Next(1, out ifilter, out nFetched) == 0)
{
FilterInfo fi = new FilterInfo();
hr = ifilter.QueryFilterInfo(fi);
if (hr < 0)
{
Marshal.ThrowExceptionForHR(hr);
}
#if DEBUG
Trace.WriteLine(fi.achName);
#endif
if ((bExact && fi.achName == strName) || (!bExact && fi.achName.Contains(strName)))
{
Marshal.ReleaseComObject(ienum);
return(ifilter);
}
Marshal.ReleaseComObject(ifilter);
}
Marshal.ReleaseComObject(ienum);
return(null);
}
public void DumpGraphInfo(string fileName, IGraphBuilder graph)
{
if (string.IsNullOrEmpty(fileName) || graph == null) return;
string filterOutputString = string.Empty;
IEnumFilters enumFilters;
int hr = graph.EnumFilters(out enumFilters);
DsError.ThrowExceptionForHR(hr);
IntPtr fetched = IntPtr.Zero;
IBaseFilter[] filters = { null };
int r = 0;
while (r == 0)
{
try
{
r = enumFilters.Next(filters.Length, filters, fetched);
DsError.ThrowExceptionForHR(r);
if (filters == null || filters.Length == 0 || filters[0] == null) continue;
FilterInfo filterInfo;
filters[0].QueryFilterInfo(out filterInfo);
filterOutputString += string.Format("{0:X8}", Marshal.GetIUnknownForObjectInContext(filters[0]).ToInt32()) + " ";
filterOutputString += filterInfo.achName + Environment.NewLine;
/* We will want to enum all the pins on the source filter */
IEnumPins pinEnum;
hr = filters[0].EnumPins(out pinEnum);
DsError.ThrowExceptionForHR(hr);
IntPtr fetched2 = IntPtr.Zero;
IPin[] pins = { null };
while (pinEnum.Next(pins.Length, pins, fetched2) == 0)
{
PinInfo pinInfo;
pins[0].QueryPinInfo(out pinInfo);
var prefix = "[In ] ";
if (pinInfo.dir == PinDirection.Output)
prefix = "[Out] ";
filterOutputString += string.Format("{0:X8}", Marshal.GetIUnknownForObjectInContext(pins[0]).ToInt32()) + " ";
filterOutputString += prefix + pinInfo.name + Environment.NewLine;
Marshal.ReleaseComObject(pins[0]);
}
Marshal.ReleaseComObject(pinEnum);
}
catch
{
r = 0;
continue;
}
}
Marshal.ReleaseComObject(enumFilters);
var file2 = System.IO.File.CreateText(fileName);
file2.AutoFlush = true;
file2.Write(filterOutputString);
file2.Close();
}
public void ReloadFilters()
{
log("reload filters..");
IEnumFilters ef;
ClearFiltersSelection();
ClearConnections();
filter_positions.Clear();
foreach (Filter f in filters)
{
filter_positions.Add(f.Name, f.Coords);
}
filters.Clear();
log("reload_filters 1");
try
{
int hr = graphBuilder.EnumFilters(out ef);
DsError.ThrowExceptionForHR(hr);
IBaseFilter[] fs = new IBaseFilter[1];
IntPtr fetched = Marshal.AllocHGlobal(4);
while ((hr = ef.Next(1, fs, fetched)) == 0)
{
log("reload_filters 2");
FilterInfo fi;
fs[0].QueryFilterInfo(out fi);
log("reload_filters: " + fi.achName);
Filter ff = FindFilterByName(fi.achName);
if (ff == null) //not found
{
ff = new Filter(fs[0]);
AddFilterHere(ff, false, null);
history.AddFilterIfNew(ff.filterProps, ff.Name, ff.srcFileName, ff.dstFileName, ff);
}
else
{
ff.ReloadPins();
}
log("reload_filters 3");
foreach (Pin pin in ff.Pins)
{
log("reload_filters 4: " + pin.Name);
IPin ip = pin.IPin, connected_ipin;
hr = ip.ConnectedTo(out connected_ipin);
if (hr != 0)
{
continue;
}
PinInfo cpi;
connected_ipin.QueryPinInfo(out cpi);
FilterInfo cfi;
cpi.filter.QueryFilterInfo(out cfi);
Filter connected_filter = FindFilterByName(cfi.achName);
if (connected_filter != null)
{
Pin cp = connected_filter.FindPinByName(connected_filter.Name + "." + cpi.name);
if (cp != null)
{
string con_uniqname = (pin.Direction == PinDirection.Input) ?
cp.UniqName + "-" + pin.UniqName : pin.UniqName + "-" + cp.UniqName;
PinConnection con = FindConnectionByName(con_uniqname);
if (con == null)
{
if (pin.Direction == PinDirection.Input)
{
Connect(cp, pin);
}
else
{
Connect(pin, cp);
}
}
}
}
DsUtils.FreePinInfo(cpi);
}
}
Marshal.FreeHGlobal(fetched);
if (hr < 0)
{
DsError.ThrowExceptionForHR(hr);
}
}
catch (COMException e)
{
ShowCOMException(e, "Error while enumerating filters in the graph");
return;
}
/*catch (Exception e)
* {
* MessageBox.Show(e.Message, "Error while enumerating filters in the graph");
* return;
* }*/
log("reload_filters: almost done");
history.CommitAdded();
log("reload_filters: done");
}
public static IBaseFilter FindFilterByClsid(IGraphBuilder graphBuilder, string filterClsid)
{
int hr = 0;
IBaseFilter filter = null;
IEnumFilters enumFilters = null;
Guid gClsid = new Guid(filterClsid);
if (graphBuilder == null)
throw new ArgumentNullException("graphBuilder");
hr = graphBuilder.EnumFilters(out enumFilters);
if (hr == 0)
{
while (true)
{
IBaseFilter[] filters = new IBaseFilter[1];
int fetched;
// Get the next filter
IntPtr d = Marshal.AllocCoTaskMem(4);
try
{
//int hr = emtDvr.Next(1, amtDvr, d);
hr = enumFilters.Next(1, filters, d);
DsError.ThrowExceptionForHR(hr);
fetched = Marshal.ReadInt32(d);
}
finally
{
Marshal.FreeCoTaskMem(d);
}
if (fetched > 0)
{
Guid clsid;
hr = filters[0].GetClassID(out clsid);
if ((hr == 0) && (clsid == gClsid))
{
filter = filters[0];
break;
}
Marshal.ReleaseComObject(filters[0]);
}
else
break;
}
Marshal.ReleaseComObject(enumFilters);
}
return filter;
}
public static IBaseFilter FindFilterByName(IGraphBuilder graphBuilder, string filterName)
{
IBaseFilter filter = null;
IEnumFilters enumFilters;
if (graphBuilder == null)
throw new ArgumentNullException("graphBuilder");
int hr = graphBuilder.EnumFilters(out enumFilters);
if (hr == 0)
{
IBaseFilter[] filters = new IBaseFilter[1];
int fetched;
while (enumFilters.Next(filters.Length, filters, out fetched) == 0)
{
if (GetFilterName(filters[0]).Equals(filterName))
{
filter = filters[0];
break;
}
}
Release.ComObject(enumFilters);
}
return filter;
}
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);
}
}
}
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);
System.Diagnostics.Trace.WriteLine("Remove filter from graph: {0}", info.achName);
}
}
else
{
DisconnectAllPins(graphBuilder, filter);
hr = graphBuilder.RemoveFilter(filter);
DsError.ThrowExceptionForHR(hr);
int i = Marshal.ReleaseComObject(filter);
System.Diagnostics.Trace.WriteLine(string.Format("Remove filter from graph: {0} {1}", info.achName, i));
}
}
catch (Exception error)
{
System.Diagnostics.Trace.TraceError("Remove of filter: {0}, failed with code (HR): {1}, explanation: {2}", info.achName, hr.ToString(),
error.Message);
}
}
}
catch (Exception)
{
return;
}
finally
{
if (enumFilters != null)
{
Marshal.ReleaseComObject(enumFilters);
}
}
}
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)
{
var filters = new IBaseFilter[1];
IntPtr fetched = IntPtr.Zero;
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]);
}
Marshal.ReleaseComObject(enumFilters);
}
return filter;
}
public static void DisconnectAllPins(IGraphBuilder graphBuilder)
{
int hr = 0;
IEnumFilters enumFilters;
if (graphBuilder == null)
throw new ArgumentNullException("graphBuilder");
hr = graphBuilder.EnumFilters(out enumFilters);
DsError.ThrowExceptionForHR(hr);
try
{
var filters = new IBaseFilter[1];
IntPtr fetched = IntPtr.Zero;
while (enumFilters.Next(filters.Length, filters, fetched) == 0)
{
try
{
DisconnectPins(filters[0]);
}
catch (COMException)
{
}
Marshal.ReleaseComObject(filters[0]);
}
}
finally
{
Marshal.ReleaseComObject(enumFilters);
}
}
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);
}
/// <summary>
/// Finds a pin that exists in a graph.
/// </summary>
/// <param name="majorOrMinorMediaType">The GUID of the major or minor type of the media</param>
/// <param name="pinDirection">The direction of the pin - in/out</param>
/// <param name="graph">The graph to search in</param>
/// <returns>Returns null if the pin was not found, or if a pin is found, returns the first instance of it</returns>
protected static IPin FindPinInGraphByMediaType(Guid majorOrMinorMediaType, PinDirection pinDirection, IGraphBuilder graph)
{
IEnumFilters enumFilters;
/* Get the filter enum */
graph.EnumFilters(out enumFilters);
/* Init our vars */
var filters = new IBaseFilter[1];
var fetched = IntPtr.Zero;
IPin pin = null;
IEnumMediaTypes mediaTypesEnum = null;
/* Loop over each filter in the graph */
while (enumFilters.Next(1, filters, fetched) == 0)
{
var filter = filters[0];
int i = 0;
/* Loop over each pin in the filter */
while ((pin = DsFindPin.ByDirection(filter, pinDirection, i)) != null)
{
/* Get the pin enumerator */
pin.EnumMediaTypes(out mediaTypesEnum);
var mediaTypesFetched = IntPtr.Zero;
var mediaTypes = new AMMediaType[1];
/* Enumerate the media types on the pin */
while (mediaTypesEnum.Next(1, mediaTypes, mediaTypesFetched) == 0)
{
/* See if the major or subtype meets our requirements */
if (mediaTypes[0].majorType.Equals(majorOrMinorMediaType) || mediaTypes[0].subType.Equals(majorOrMinorMediaType))
{
/* We found a match */
goto done;
}
}
i++;
}
}
done:
if (mediaTypesEnum != null)
{
mediaTypesEnum.Reset();
Marshal.ReleaseComObject(mediaTypesEnum);
}
enumFilters.Reset();
Marshal.ReleaseComObject(enumFilters);
return pin;
}
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();
}
}
}
//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();
}
//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);
}
}
public static void RemoveAllFilters(IGraphBuilder graphBuilder)
{
if (graphBuilder == null)
throw new ArgumentNullException("graphBuilder");
IEnumFilters enumFilters = null;
System.Collections.ArrayList filtersArray = new System.Collections.ArrayList();
try
{
int hr = graphBuilder.EnumFilters(out enumFilters);
DsError.ThrowExceptionForHR(hr);
IBaseFilter[] filters = new IBaseFilter[1];
int fetched;
while (enumFilters.Next(filters.Length, filters, out fetched) == 0)
{
filtersArray.Add(filters[0]);
}
foreach (IBaseFilter filter in filtersArray)
{
FilterInfo info;
filter.QueryFilterInfo(out info);
Log.Log.Write("Remove filter from graph: {0}", info.achName);
graphBuilder.RemoveFilter(filter);
while (Release.ComObject(filter) > 0) ;
}
}
catch (Exception)
{
Log.Log.Write("Remove filter error!");
return;
}
finally
{
if (enumFilters != null)
{
Release.ComObject(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);
}
}
// 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 static bool CheckFilterIsLoaded(IGraphBuilder graphBuilder, String name)
{
int hr;
bool ret = false;
IEnumFilters enumFilters;
graphBuilder.EnumFilters(out enumFilters);
do
{
int ffetched;
IBaseFilter[] filters = new IBaseFilter[1];
hr = enumFilters.Next(1, filters, out ffetched);
if (hr == 0 && ffetched > 0)
{
FilterInfo info;
filters[0].QueryFilterInfo(out info);
ReleaseComObject(info.pGraph);
string filtername = info.achName;
ReleaseComObject(filters[0]);
if (filtername.Equals(name))
{
ret = true;
break;
}
}
else
{
break;
}
} while (true);
ReleaseComObject(enumFilters);
return ret;
}
public static void DisconnectAllPins(IGraphBuilder graphBuilder)
{
IEnumFilters enumFilters;
if (graphBuilder == null)
throw new ArgumentNullException("graphBuilder");
int hr = graphBuilder.EnumFilters(out enumFilters);
DsError.ThrowExceptionForHR(hr);
try
{
IBaseFilter[] filters = new IBaseFilter[1];
int fetched;
while (enumFilters.Next(filters.Length, filters, out fetched) == 0)
{
try
{
DisconnectPins(filters[0]);
}
catch (Exception ex)
{
Log.Log.WriteFile("Error while disconnecting all pins: ", ex);
}
Release.ComObject(filters[0]);
}
}
finally
{
Release.ComObject(enumFilters);
}
}
/// <summary>
/// Try to sort the Filters that are currently loaded by Intermediate -> Renderer
/// and then by Merit, desc.
///
/// </summary>
/// <param name="graphBuilder"></param>
/// <returns></returns>
private static ArrayList GetFilters(IGraphBuilder graphBuilder)
{
//Sources+Intermediates
ArrayList allMerits = new ArrayList();
ArrayList allFilters = new ArrayList();
//Renderers
ArrayList allMeritsR = new ArrayList();
ArrayList allFiltersR = new ArrayList();
IEnumFilters enumFilters;
graphBuilder.EnumFilters(out enumFilters);
for (;;)
{
int ffetched;
IBaseFilter[] filters = new IBaseFilter[1];
int hr = enumFilters.Next(1, filters, out ffetched);
if (hr == 0 && ffetched > 0)
{
uint m = (uint)GetMerit(filters[0]);
//substract merit from uint.maxvalue to get reverse ordering from highest merit to lowest merit
if (IsRenderer(filters[0]))
{
allMeritsR.Add(uint.MaxValue - m);
allFiltersR.Add(filters[0]);
}
else
{
allMerits.Add(uint.MaxValue - m);
allFilters.Add(filters[0]);
}
}
else
{
break;
}
}
ReleaseComObject(enumFilters);
//if someone has a better way to sort the filters by their merits, PLEASE change the following
//(i know there must be something more elegant)
Array aM = allMerits.ToArray(typeof (uint));
Array aF = allFilters.ToArray(typeof (IBaseFilter));
Array aMR = allMeritsR.ToArray(typeof (uint));
Array aFR = allFiltersR.ToArray(typeof (IBaseFilter));
Array.Sort(aM, aF);
Array.Sort(aMR, aFR);
ArrayList ret = new ArrayList();
//add all itermediate+sources first, then add renderers
ret.AddRange(aF);
ret.AddRange(aFR);
LogFilters(ret);
return ret;
}
public static void SetSyncSource(IGraphBuilder graphBuilder, IReferenceClock clock)
{
int hr = 0;
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)
{
hr = filters[0].SetSyncSource(clock);
DsError.ThrowExceptionForHR(hr);
Marshal.ReleaseComObject(filters[0]);
}
Marshal.ReleaseComObject(enumFilters);
}
}
public static void RenderGraphBuilderOutputPins(IGraphBuilder graphBuilder, IBaseFilter baseFilter)
{
if (graphBuilder == null)
return;
if (baseFilter != null)
RenderUnconnectedOutputPins(graphBuilder, baseFilter);
int hr = 0;
IEnumFilters enumFilters = null;
ArrayList filtersArray = new ArrayList();
hr = graphBuilder.EnumFilters(out enumFilters);
DsError.ThrowExceptionForHR(hr);
IBaseFilter[] filters = new IBaseFilter[1];
int fetched;
while (enumFilters.Next(filters.Length, filters, out fetched) == 0)
{
filtersArray.Add(filters[0]);
}
foreach (IBaseFilter filter in filtersArray)
{
if (filter != baseFilter)
{
RenderUnconnectedOutputPins(graphBuilder, filter);
}
else
{
break;
}
}
ReleaseComObject(enumFilters);
}
public static void SetGraphOutputFile(IGraphBuilder graphBuilder, string OutputFile)
{
int hr = 0;
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;
IFileSinkFilter fsf = filters[0] as IFileSinkFilter;
if (fsf != null)
{
hr = fsf.SetFileName(OutputFile, null);
Marshal.ReleaseComObject(filters[0]);
break;
}
Marshal.ReleaseComObject(filters[0]);
}
Marshal.ReleaseComObject(enumFilters);
}
}
public static IBaseFilter AddAudioRendererToGraph(IGraphBuilder graphBuilder, string strFilterName,
bool setAsReferenceClock)
{
try
{
IPin pinOut = null;
IBaseFilter NewFilter = null;
IEnumFilters enumFilters;
HResult hr = new HResult(graphBuilder.EnumFilters(out enumFilters));
Log.Info("DirectShowUtils: First try to insert new audio renderer {0} ", strFilterName);
// next add the new one...
foreach (Filter filter in Filters.AudioRenderers)
{
if (String.Compare(filter.Name, strFilterName, true) == 0)
{
Log.Info("DirectShowUtils: Found audio renderer");
NewFilter = (IBaseFilter)Marshal.BindToMoniker(filter.MonikerString);
hr.Set(graphBuilder.AddFilter(NewFilter, strFilterName));
if (hr < 0)
{
Log.Error("DirectShowUtils: unable to add filter:{0} to graph", strFilterName);
NewFilter = null;
}
else
{
Log.Debug("DirectShowUtils: added filter:{0} to graph", strFilterName);
if (pinOut != null)
{
hr.Set(graphBuilder.Render(pinOut));
if (hr == 0)
{
Log.Info(" pinout rendererd");
}
else
{
Log.Error(" failed: pinout render");
}
}
if (setAsReferenceClock)
{
hr.Set((graphBuilder as IMediaFilter).SetSyncSource(NewFilter as IReferenceClock));
if (hr != 0)
{
Log.Warn("setAsReferenceClock sync source " + hr.ToDXString());
}
}
return NewFilter;
}
} //if (String.Compare(filter.Name,strFilterName,true) ==0)
} //foreach (Filter filter in filters.AudioRenderers)
if (NewFilter == null)
{
Log.Error("DirectShowUtils: failed filter {0} not found", strFilterName);
}
}
catch {}
Log.Info("DirectShowUtils: First try to insert new audio renderer {0} failed ", strFilterName);
try
{
IPin pinOut = null;
IBaseFilter NewFilter = null;
Log.Info("add filter:{0} to graph clock:{1}", strFilterName, setAsReferenceClock);
//check first if audio renderer exists!
bool bRendererExists = false;
foreach (Filter filter in Filters.AudioRenderers)
{
if (String.Compare(filter.Name, strFilterName, true) == 0)
{
bRendererExists = true;
Log.Info("DirectShowUtils: found renderer - {0}", filter.Name);
}
}
if (!bRendererExists)
{
Log.Error("FAILED: audio renderer:{0} doesnt exists", strFilterName);
return null;
}
// first remove all audio renderers
bool bAllRemoved = false;
bool bNeedAdd = true;
IEnumFilters enumFilters;
HResult hr = new HResult(graphBuilder.EnumFilters(out enumFilters));
if (hr >= 0 && enumFilters != null)
{
int iFetched;
enumFilters.Reset();
while (!bAllRemoved)
{
IBaseFilter[] pBasefilter = new IBaseFilter[2];
hr.Set(enumFilters.Next(1, pBasefilter, out iFetched));
if (hr < 0 || iFetched != 1 || pBasefilter[0] == null)
{
break;
}
foreach (Filter filter in Filters.AudioRenderers)
{
Guid classId1;
Guid classId2;
pBasefilter[0].GetClassID(out classId1);
//Log.Info("Filter Moniker string - " + filter.Name);
if (filter.Name == "ReClock Audio Renderer")
{
Log.Warn(
"Reclock is installed - if this method fails, reinstall and regsvr32 /u reclock and then uninstall");
// return null;
}
try
{
NewFilter = (IBaseFilter)Marshal.BindToMoniker(filter.MonikerString);
if (NewFilter == null)
{
Log.Info("NewFilter = null");
continue;
}
}
catch (Exception e)
{
Log.Info("Exception in BindToMoniker({0}): {1}", filter.MonikerString, e.Message);
continue;
}
NewFilter.GetClassID(out classId2);
ReleaseComObject(NewFilter);
NewFilter = null;
if (classId1.Equals(classId2))
{
if (filter.Name == strFilterName)
{
Log.Info("filter already in graph");
if (setAsReferenceClock)
{
hr.Set((graphBuilder as IMediaFilter).SetSyncSource(pBasefilter[0] as IReferenceClock));
if (hr != 0)
{
Log.Warn("setAsReferenceClock sync source " + hr.ToDXString());
}
}
ReleaseComObject(pBasefilter[0]);
pBasefilter[0] = null;
bNeedAdd = false;
break;
}
else
{
Log.Info("remove " + filter.Name + " from graph");
pinOut = FindSourcePinOf(pBasefilter[0]);
graphBuilder.RemoveFilter(pBasefilter[0]);
bAllRemoved = true;
break;
}
} //if (classId1.Equals(classId2))
} //foreach (Filter filter in filters.AudioRenderers)
if (pBasefilter[0] != null)
{
ReleaseComObject(pBasefilter[0]);
}
} //while(!bAllRemoved)
ReleaseComObject(enumFilters);
} //if (hr>=0 && enumFilters!=null)
Log.Info("DirectShowUtils: Passed removing audio renderer");
if (!bNeedAdd)
{
return null;
}
// next add the new one...
foreach (Filter filter in Filters.AudioRenderers)
{
if (String.Compare(filter.Name, strFilterName, true) == 0)
{
Log.Info("DirectShowUtils: Passed finding Audio Renderer");
NewFilter = (IBaseFilter)Marshal.BindToMoniker(filter.MonikerString);
hr.Set(graphBuilder.AddFilter(NewFilter, strFilterName));
if (hr < 0)
{
Log.Error("failed:unable to add filter:{0} to graph", strFilterName);
NewFilter = null;
}
else
{
Log.Debug("added filter:{0} to graph", strFilterName);
if (pinOut != null)
{
hr.Set(graphBuilder.Render(pinOut));
if (hr == 0)
{
Log.Info(" pinout rendererd");
}
else
{
Log.Error(" failed: pinout render");
}
}
if (setAsReferenceClock)
{
hr.Set((graphBuilder as IMediaFilter).SetSyncSource(NewFilter as IReferenceClock));
if (hr != 0)
{
Log.Warn("setAsReferenceClock sync source " + hr.ToDXString());
}
}
return NewFilter;
}
} //if (String.Compare(filter.Name,strFilterName,true) ==0)
} //foreach (Filter filter in filters.AudioRenderers)
if (NewFilter == null)
{
Log.Error("failed filter:{0} not found", strFilterName);
}
}
catch (Exception ex)
{
Log.Error("DirectshowUtil. Failed to add filter:{0} to graph :{1} {2} {3}",
strFilterName, ex.Message, ex.Source, ex.StackTrace);
}
return null;
}
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);
}
}
private static IBaseFilter GetFilter(IGraphBuilder graph,string mask) {
IBaseFilter filter = null;
IEnumFilters filters;
FilterInfo info;
int hr = 0;
System.IntPtr count = (System.IntPtr) 0;
hr = graph.EnumFilters(out filters);
DsError.ThrowExceptionForHR(hr);
IBaseFilter[] f = new IBaseFilter[1];
while (filters.Next(1, f,count) == 0)
{
hr = f[0].QueryFilterInfo(out info);
DsError.ThrowExceptionForHR(hr);
if (info.achName.ToLower().EndsWith(mask))
{
filter = f[0];
break;
}
}
return filter;
}
/// <summary>
/// Removes all filters from a DirectShow graph
/// </summary>
/// <param name="graphBuilder">The DirectShow graph to remove all the filters from</param>
protected static void RemoveAllFilters(IGraphBuilder graphBuilder)
{
if (graphBuilder == null)
return;
IEnumFilters enumFilters;
/* The list of filters from the DirectShow graph */
var filtersArray = new List<IBaseFilter>();
if (graphBuilder == null)
throw new ArgumentNullException("graphBuilder");
/* Gets the filter enumerator from the graph */
int hr = graphBuilder.EnumFilters(out enumFilters);
DsError.ThrowExceptionForHR(hr);
try
{
/* This array is filled with reference to a filter */
var filters = new IBaseFilter[1];
IntPtr fetched = IntPtr.Zero;
/* Get reference to all the filters */
while (enumFilters.Next(filters.Length, filters, fetched) == 0)
{
/* Add the filter to our array */
filtersArray.Add(filters[0]);
}
}
finally
{
/* Enum filters is a COM, so release that */
Marshal.ReleaseComObject(enumFilters);
}
/* Loop over and release each COM */
for (int i = 0; i < filtersArray.Count; i++)
{
graphBuilder.RemoveFilter(filtersArray[i]);
while (Marshal.ReleaseComObject(filtersArray[i]) > 0)
{}
}
}
public static void RemoveUnusedFiltersFromGraph(IGraphBuilder graphBuilder)
{
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];
int fetched;
while (enumFilters.Next(filters.Length, filters, out fetched) == 0)
{
filtersArray.Add(filters[0]);
}
foreach (IBaseFilter filter in filtersArray)
{
FilterInfo info;
filter.QueryFilterInfo(out info);
Log.Debug("Check graph connections for: {0}", info.achName);
IEnumPins pinEnum;
hr = filter.EnumPins(out pinEnum);
DsError.ThrowExceptionForHR(hr);
if (hr == 0 && pinEnum != null)
{
bool filterUsed = false;
bool hasOut = false;
bool hasIn = false;
pinEnum.Reset();
IPin[] pins = new IPin[1];
while (pinEnum.Next(1, pins, out fetched) == 0)
{
if (fetched > 0)
{
PinDirection pinDir;
hr = pins[0].QueryDirection(out pinDir);
DsError.ThrowExceptionForHR(hr);
if (pinDir == PinDirection.Output)
hasOut = true;
else
hasIn = true;
if (HasConnection(pins[0]))
{
filterUsed = true;
break;
}
}
}
ReleaseComObject(pinEnum);
if (!filterUsed && hasOut && hasIn)
{
hr = graphBuilder.RemoveFilter(filter);
DsError.ThrowExceptionForHR(hr);
if (hr == 0)
Log.Debug(" - remove done");
}
}
ReleaseComObject(info.pGraph);
ReleaseComObject(filter);
}
}
catch (Exception error)
{
Log.Error("DirectShowUtil: Remove unused filters failed - {0}", error.Message);
}
ReleaseComObject(enumFilters);
}
public void DumpGraphInfo(string fileName, IGraphBuilder graph)
{
if (string.IsNullOrEmpty(fileName) || graph == null)
{
return;
}
string filterOutputString = string.Empty;
IEnumFilters enumFilters;
int hr = graph.EnumFilters(out enumFilters);
DsError.ThrowExceptionForHR(hr);
IntPtr fetched = IntPtr.Zero;
IBaseFilter[] filters = { null };
int r = 0;
while (r == 0)
{
try
{
r = enumFilters.Next(filters.Length, filters, fetched);
DsError.ThrowExceptionForHR(r);
if (filters == null || filters.Length == 0 || filters[0] == null)
{
continue;
}
FilterInfo filterInfo;
filters[0].QueryFilterInfo(out filterInfo);
filterOutputString += string.Format("{0:X8}", Marshal.GetIUnknownForObjectInContext(filters[0]).ToInt32()) + " ";
filterOutputString += filterInfo.achName + Environment.NewLine;
/* We will want to enum all the pins on the source filter */
IEnumPins pinEnum;
hr = filters[0].EnumPins(out pinEnum);
DsError.ThrowExceptionForHR(hr);
IntPtr fetched2 = IntPtr.Zero;
IPin[] pins = { null };
while (pinEnum.Next(pins.Length, pins, fetched2) == 0)
{
PinInfo pinInfo;
pins[0].QueryPinInfo(out pinInfo);
var prefix = "[In ] ";
if (pinInfo.dir == PinDirection.Output)
{
prefix = "[Out] ";
}
filterOutputString += string.Format("{0:X8}", Marshal.GetIUnknownForObjectInContext(pins[0]).ToInt32()) + " ";
filterOutputString += prefix + pinInfo.name + Environment.NewLine;
Marshal.ReleaseComObject(pins[0]);
}
Marshal.ReleaseComObject(pinEnum);
}
catch
{
r = 0;
continue;
}
}
Marshal.ReleaseComObject(enumFilters);
var file2 = System.IO.File.CreateText(fileName);
file2.AutoFlush = true;
file2.Write(filterOutputString);
file2.Close();
}
/// <summary>
/// Find the overlay mixer and/or the VMR9 windowless filters
/// and tell them we dont want a fixed Aspect Ratio
/// Mediaportal handles AR itself
/// </summary>
/// <param name="graphBuilder"></param>
public static void SetARMode(IGraphBuilder graphBuilder, AspectRatioMode ARRatioMode)
{
int hr;
IBaseFilter overlay;
graphBuilder.FindFilterByName("Overlay Mixer2", out overlay);
if (overlay != null)
{
IPin iPin;
overlay.FindPin("Input0", out iPin);
if (iPin != null)
{
IMixerPinConfig pMC = iPin as IMixerPinConfig;
if (pMC != null)
{
AspectRatioMode mode;
hr = pMC.SetAspectRatioMode(ARRatioMode);
hr = pMC.GetAspectRatioMode(out mode);
//ReleaseComObject(pMC);
}
ReleaseComObject(iPin);
}
ReleaseComObject(overlay);
}
IEnumFilters enumFilters;
hr = graphBuilder.EnumFilters(out enumFilters);
if (hr >= 0 && enumFilters != null)
{
int iFetched;
enumFilters.Reset();
IBaseFilter[] pBasefilter = new IBaseFilter[2];
do
{
pBasefilter = null;
hr = enumFilters.Next(1, pBasefilter, out iFetched);
if (hr == 0 && iFetched == 1 && pBasefilter[0] != null)
{
IVMRAspectRatioControl pARC = pBasefilter[0] as IVMRAspectRatioControl;
if (pARC != null)
{
pARC.SetAspectRatioMode(VMRAspectRatioMode.None);
}
IVMRAspectRatioControl9 pARC9 = pBasefilter[0] as IVMRAspectRatioControl9;
if (pARC9 != null)
{
pARC9.SetAspectRatioMode(VMRAspectRatioMode.None);
}
IEnumPins pinEnum;
hr = pBasefilter[0].EnumPins(out pinEnum);
if ((hr == 0) && (pinEnum != null))
{
pinEnum.Reset();
IPin[] pins = new IPin[1];
int f;
do
{
// Get the next pin
hr = pinEnum.Next(1, pins, out f);
if (f == 1 && hr == 0 && pins[0] != null)
{
IMixerPinConfig pMC = pins[0] as IMixerPinConfig;
if (null != pMC)
{
pMC.SetAspectRatioMode(ARRatioMode);
}
ReleaseComObject(pins[0]);
}
} while (f == 1);
ReleaseComObject(pinEnum);
}
ReleaseComObject(pBasefilter[0]);
}
} while (iFetched == 1 && pBasefilter[0] != null);
ReleaseComObject(enumFilters);
}
}
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)
{
var filters = new IBaseFilter[1];
IntPtr fetched = IntPtr.Zero;
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]);
}
Marshal.ReleaseComObject(enumFilters);
}
return filter;
}
public static IBaseFilter GetFilterByName(IGraphBuilder graphBuilder, string name)
{
int hr = 0;
IEnumFilters ienumFilt = null;
IBaseFilter[] foundfilter = new IBaseFilter[2];
int iFetched = 0;
try
{
hr = graphBuilder.EnumFilters(out ienumFilt);
if (hr == 0 && ienumFilt != null)
{
ienumFilt.Reset();
do
{
hr = ienumFilt.Next(1, foundfilter, out iFetched);
if (hr == 0 && iFetched == 1)
{
FilterInfo filter_infos = new FilterInfo();
foundfilter[0].QueryFilterInfo(out filter_infos);
ReleaseComObject(filter_infos.pGraph);
Log.Debug("GetFilterByName: {0}, {1}", name, filter_infos.achName);
if (filter_infos.achName.LastIndexOf(name) != -1)
{
ReleaseComObject(ienumFilt);
ienumFilt = null;
return foundfilter[0];
}
ReleaseComObject(foundfilter[0]);
}
} while (iFetched == 1 && hr == 0);
if (ienumFilt != null)
{
ReleaseComObject(ienumFilt);
}
ienumFilt = null;
}
}
catch (Exception) {}
finally
{
if (ienumFilt != null)
{
ReleaseComObject(ienumFilt);
}
}
return null;
}
public static void RemoveAllFilters(IGraphBuilder graphBuilder)
{
int hr = 0;
IEnumFilters enumFilters;
var filtersArray = new ArrayList();
if (graphBuilder == null)
throw new ArgumentNullException("graphBuilder");
hr = graphBuilder.EnumFilters(out enumFilters);
DsError.ThrowExceptionForHR(hr);
try
{
var filters = new IBaseFilter[1];
IntPtr fetched = IntPtr.Zero;
while (enumFilters.Next(filters.Length, filters, fetched) == 0)
{
filtersArray.Add(filters[0]);
}
}
finally
{
Marshal.ReleaseComObject(enumFilters);
}
foreach (IBaseFilter filter in filtersArray)
{
hr = graphBuilder.RemoveFilter(filter);
Marshal.ReleaseComObject(filter);
}
}
public static void FindFilterByClassID(IGraphBuilder m_graphBuilder, Guid classID, out IBaseFilter filterFound)
{
filterFound = null;
if (m_graphBuilder == null)
{
return;
}
IEnumFilters ienumFilt = null;
try
{
int hr = m_graphBuilder.EnumFilters(out ienumFilt);
if (hr == 0 && ienumFilt != null)
{
int iFetched;
IBaseFilter[] filter = new IBaseFilter[2];
ienumFilt.Reset();
do
{
hr = ienumFilt.Next(1, filter, out iFetched);
if (hr == 0 && iFetched == 1)
{
Guid filterGuid;
filter[0].GetClassID(out filterGuid);
if (filterGuid == classID)
{
filterFound = filter[0];
return;
}
ReleaseComObject(filter[0]);
filter[0] = null;
}
} while (iFetched == 1 && hr == 0);
if (ienumFilt != null)
{
ReleaseComObject(ienumFilt);
}
ienumFilt = null;
}
}
catch (Exception) {}
finally
{
if (ienumFilt != null)
{
ReleaseComObject(ienumFilt);
}
}
return;
}
/// <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);
}
}
private HRESULT InitInterfaces()
{
CloseInterfaces();
HRESULT hr = E_FAIL;
try
{
m_GraphBuilder = (IGraphBuilder)new FilterGraph();
hr = OnInitInterfaces();
hr.Throw();
return PreparePlayback();
}
catch (Exception _exception)
{
if (_exception is COMException)
{
hr = (HRESULT)((COMException)_exception).ErrorCode;
}
else
{
hr = E_UNEXPECTED;
}
}
finally
{
if (hr.Succeeded)
{
while (m_Filters.Count > 0)
{
DSFilter _filter = m_Filters[0];
m_Filters.RemoveAt(0);
_filter.Dispose();
}
IEnumFilters pEnum;
if (SUCCEEDED(m_GraphBuilder.EnumFilters(out pEnum)))
{
IBaseFilter[] aFilters = new IBaseFilter[1];
while(S_OK == pEnum.Next(1,aFilters,IntPtr.Zero))
{
m_Filters.Add(new DSFilter(aFilters[0]));
}
Marshal.ReleaseComObject(pEnum);
}
}
}
CloseInterfaces();
return hr;
}
