/// <summary>
/// Beendet die Nutzung dieser Instanz endgültig.
/// </summary>
public override void Dispose()
{
// Stop and raw TS dump
StopDump();
// Stop all
Stop();
// Forward to injectors
using (Injector ts = m_TSInjector)
if (ts != null)
{
// Forget
m_TSInjector = null;
// Shut down
ts.Inject(null, 0, 0, true, null);
}
// Clear AV
SetAudioType(null);
SetVideoType(null);
// Forward to input pin
using (var pin = m_Pin)
m_Pin = null;
// Forget the graph
BDAEnvironment.Release(ref m_Graph);
// Forward
base.Dispose();
}
/// <summary>
/// Ermittelt alle Filter einer bestimmten Art.
/// </summary>
/// <param name="category">Die gewünschte Art.</param>
/// <returns>Liste der Namen.</returns>
private List <FilterInformation> FindFiltersByCategory(Guid category)
{
// Result
var names = new List <FilterInformation>();
// Create system device enumerator
var devEnum = (ICreateDevEnum)Activator.CreateInstance(Type.GetTypeFromCLSID(BDAEnvironment.SystemDeviceEnumeratorClassIdentifier));
try
{
// Get the enumerator
IEnumMoniker monikers;
if (devEnum.CreateClassEnumerator(ref category, out monikers, 0) == 0)
{
LoadFromEnumeration(category, "DevicePath", names, monikers);
}
}
finally
{
// Back to COM
BDAEnvironment.Release(ref devEnum);
}
// Report
return(names);
}
/// <summary>
/// Ermittelt zu einem Filter einen ausgangsseitigen Steuerknoten der Topologie.
/// </summary>
/// <typeparam name="T">Die Art der benötigten Schnittstelle.</typeparam>
/// <param name="filter">Ein Filter.</param>
/// <param name="nodeType">Die Art des Knotens.</param>
/// <returns>Der gewünschte Knoten.</returns>
public static T GetOutputControlNode <T>(this TypedComIdentity <IBaseFilter> filter, uint nodeType) where T : class
{
// Validate
if (filter == null)
{
throw new ArgumentNullException("filter");
}
// Attach to alternate interface
using (var instance = filter.MarshalToManaged())
{
// Change type
var topology = instance.Object as IBDATopology;
if (topology == null)
{
return(null);
}
// Load
var node = topology.GetControlNode(0, 1, nodeType);
var result = node as T;
// Cleanup
if (result == null)
{
BDAEnvironment.Release(ref node);
}
// Report
return(result);
}
}
/// <summary>
/// Leitet die Daten zu einem Endpunkt um.
/// </summary>
/// <param name="receivePin">Der Endpunkt, der die Daten empfangen soll.</param>
/// <param name="mediaType">Die Art der zu übertragenden Daten.</param>
public void Connect(IntPtr receivePin, IntPtr mediaType)
{
// Inform partner
var receiver = Marshal.GetObjectForIUnknown(receivePin);
try
{
// Change type
var pin = (IPin)receiver;
// We can choose
if (mediaType == IntPtr.Zero)
{
// Use ours
mediaType = m_Types[0].GetReference();
// Ask partner
if (pin.QueryAccept(mediaType) != 0)
{
throw new COMException("mediaType", unchecked ((int)0x80040207));
}
}
// Forward
ReceiveConnection(receivePin, mediaType);
// Forward
pin.ReceiveConnection(Interface, mediaType);
}
finally
{
// Cleanup
BDAEnvironment.Release(ref receiver);
}
}
/// <summary>
/// Liest eine bestimmte Eigenschaft eines eindeutigen Namens.
/// </summary>
/// <param name="moniker">Der eindeutige Name.</param>
/// <param name="property">Name der gewünschten Eigenschaft.</param>
/// <returns>Wert der Eigenschaft.</returns>
public static string ReadProperty(this IMoniker moniker, string property)
{
// Validate
if (moniker == null)
{
return(null);
}
// Guid for reference
Guid propBag = new Guid("55272a00-42cb-11ce-8135-00aa004bb851");
// Prepare for errors
try
{
// Change interface
var props = moniker.BindToStorage(null, null, ref propBag);
try
{
// Report
return(((IPropertyBag)props).Get <string>(property));
}
finally
{
// Cleanup
BDAEnvironment.Release(ref props);
}
}
catch
{
// Do nothing in case of ANY error
return(null);
}
}
/// <summary>
/// Gibt alle sekundären Ressourcen zu dieser Formatbeschreibung
/// frei.
/// <seealso cref="CopyTo"/>
/// </summary>
public void FreeMemory()
{
// Check for holder
BDAEnvironment.Release(ref Holder);
// Reset
Format = null;
}
/// <summary>
/// Ändert die zu verwendende Speicherverwaltung.
/// </summary>
/// <param name="allocator">Die neue Speicherverwaltung.</param>
/// <param name="bReadOnly">Gesetzt, wenn auf die Speicherverwaltung nur lesend zugegriffen werden darf.</param>
public void NotifyAllocator(IMemAllocator allocator, bool bReadOnly)
{
// Cleanup
BDAEnvironment.Release(ref m_Allocator);
// Remember
m_AllocatorReadOnly = bReadOnly;
m_Allocator = allocator;
}
/// <summary>
/// Trennt den Endpunkt von anderen.
/// </summary>
public void Disconnect()
{
// Detach all helper
m_NotifySink = null;
m_MemSink = null;
// Release
BDAEnvironment.Release(ref m_MemPin);
BDAEnvironment.Release(ref m_Connected);
// Reset
m_ConnectType.Dispose();
m_ConnectType = new MediaType();
}
/// <summary>
/// Legt die Referenzuhr für diesen Filter fest.
/// </summary>
/// <param name="clock">Die neue Referenzuhr.</param>
public void SetSyncSource(IntPtr clock)
{
// Proper cleanup
BDAEnvironment.Release(ref m_Clock);
// Remember
m_Clock = clock;
// Proper lock
if (m_Clock != IntPtr.Zero)
{
Marshal.AddRef(m_Clock);
}
}
/// <summary>
/// Füllt eine Liste mit Filterinformationen aus einer Auflistung.
/// </summary>
/// <param name="category">Die Art des Filters.</param>
/// <param name="uniqueProp">Die Eigenschaft, die als eindeutige Kennung verwendet werden soll.</param>
/// <param name="list">Die Informationen.</param>
/// <param name="monikers">Die Auflistung.</param>
public void LoadFromEnumeration(Guid category, string uniqueProp, List <FilterInformation> list, IEnumMoniker monikers)
{
// Nothing to do
if (monikers == null)
{
return;
}
// With cleanup
try
{
// Process all
for (; ;)
{
using (var array = new COMArray(1))
{
// Load
uint count;
if (monikers.Next(1, array.Address, out count) != 0)
{
break;
}
// Load object
if (count != 1)
{
continue;
}
// Load the one
var moniker = array.GetObject <IMoniker>(0);
try
{
// Remember
list.Add(new FilterInformation(category, moniker.ReadProperty("FriendlyName"), moniker.ReadProperty(uniqueProp), m_MediaDevices));
}
finally
{
// Cleanup
BDAEnvironment.Release(ref moniker);
}
}
}
}
finally
{
// Cleanup
BDAEnvironment.Release(ref monikers);
}
}
/// <summary>
/// Erzeugt eine neue Instanz.
/// </summary>
/// <typeparam name="DataType">Die Art der Daten.</typeparam>
/// <param name="interface">Die zu verwendende Schnittstelle.</param>
/// <returns>Eine neue Zugriffsinstanz.</returns>
public static IKsPropertySet <DataType> Create <DataType>(IntPtr @interface)
where DataType : struct
{
// None
if (@interface == null)
{
return(null);
}
// Try to access the interface
var com = ComIdentity.TryQueryInterface(@interface, typeof(IKsPropertySet));
if (com == IntPtr.Zero)
{
return(null);
}
// Be safe
try
{
// Create the wrapper
using (var typed = new TypedComIdentity <IKsPropertySet>(com))
{
// No longer needed to release
com = IntPtr.Zero;
// Create wrapper
var wrapper = typed.MarshalToManaged();
try
{
// Safe process
return(new Typed <DataType>(wrapper));
}
catch
{
// Cleanup
wrapper.Dispose();
// Forward
throw;
}
}
}
finally
{
// Cleanup
BDAEnvironment.Release(ref com);
}
}
/// <summary>
/// Trennt diesen Endpunkt von allen anderen.
/// </summary>
public void Disconnect()
{
// Release
BDAEnvironment.Release(ref m_Allocator);
BDAEnvironment.Release(ref m_Connected);
// Release
m_ConnectType.Dispose();
m_ConnectType = new MediaType();
// Reset
m_AllocatorReadOnly = false;
m_Connected = IntPtr.Zero;
m_Allocator = null;
}
/// <summary>
/// Beendet die Nutzung dieser Instanz endgültig.
/// </summary>
public override void Dispose()
{
// Stop all
Stop();
// Forward to input pin
using (DataManager)
DataManager = null;
// Forget the graph
BDAEnvironment.Release(ref m_Graph);
// Forward
base.Dispose();
}
/// <summary>
/// Verbindet diesen Ausgang mit dem Eingang eines beliebigen Filters.
/// </summary>
/// <param name="receiver">Der Filter, der die erzeugten Daten verarbeiten soll.</param>
/// <param name="mediaType">Die Art der zu verwendenden Daten.</param>
public void Connect(TypedComIdentity <IBaseFilter> receiver, MediaType mediaType)
{
// Attach to the one input pin
var to = receiver.GetSinglePin(PinDirection.Input);
try
{
// Process
Connect(to.Interface, mediaType.GetReference());
}
finally
{
// Cleanup
BDAEnvironment.Release(ref to);
}
}
/// <summary>
/// Verbindet diesen Endpunkt mit einem anderen.
/// </summary>
/// <param name="connector">Ein Erzeuger.</param>
/// <param name="mediaType">Der gewünschte Datentyp.</param>
public void ReceiveConnection(IntPtr connector, IntPtr mediaType)
{
// Free
BDAEnvironment.Release(ref m_Connected);
// Remember
if (connector != null)
{
Marshal.AddRef(connector);
}
m_Connected = connector;
// Clone the media type
m_ConnectType.Dispose();
m_ConnectType = new MediaType(mediaType);
}
/// <summary>
/// Erzeugt einen neuen Filter.
/// </summary>
/// <returns>Der gewünschte Filter.</returns>
public static VMR Create()
{
// Create
var instance = Marshal.BindToMoniker(VMRMoniker);
try
{
// Report
return(new VMR(instance));
}
finally
{
// Cleanup
BDAEnvironment.Release(ref instance);
}
}
/// <summary>
/// Gibt alle internen Strukturen frei.
/// </summary>
private void DestroyGraph()
{
// Get rid of clock
DisposeClock();
// Try stop and delete all filters
if (null != m_Graph)
{
try
{
// Stop self
GraphAsFilter.Stop();
}
catch
{
}
}
// Filters first
foreach (var filter in m_Filters.Values)
{
filter.Dispose();
}
// Clear list
m_Filters.Clear();
// Forward
using (m_Register)
m_Register = null;
// Must cleanup COM references
BDAEnvironment.Release(ref m_Graph);
// Must cleanup file
using (m_LogFile)
m_LogFile = null;
// Clear helpers and reset flags
m_VideoWindowCreated = false;
m_VideoPID = 0;
m_AudioPID = 0;
// TS Filter
using (InjectorFilter)
InjectorFilter = null;
}
/// <summary>
/// Ermittelt alle Decoder Filter, die ein bestimmtes Format unterstützen.
/// </summary>
/// <param name="filters">Filterbedingung für die Suche.</param>
/// <returns>Alle zur Bedingung passenden Filter.</returns>
private static IDeviceOrFilterInformation[] FindFilterByDecoderType(params Guid[] filters)
{
// Validate
if (0 != (filters.Length % 2))
{
throw new ArgumentException("filters");
}
// Create result
var list = new List <FilterInformation>();
// Create the filter mapper
var mapper = (IFilterMapper2)Activator.CreateInstance(Type.GetTypeFromCLSID(Constants.CLSID_FilterMapper2));
try
{
// Lock in memory
var fixFilter = GCHandle.Alloc(filters, GCHandleType.Pinned);
try
{
// Request enumerator
IEnumMoniker monikers = null;
mapper.EnumMatchingFilters(out monikers, 0, 1, 0x200001, 1, filters.Length / 2, fixFilter.AddrOfPinnedObject(), IntPtr.Zero, IntPtr.Zero, 0, 1, 0, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);
// Add all to the list using device and filter helper
DeviceAndFilterInformations.Cache.LoadFromEnumeration(Guid.Empty, "CLSID", list, monikers);
}
finally
{
// Unlock memory
fixFilter.Free();
}
}
finally
{
// Back to COM
BDAEnvironment.Release(ref mapper);
}
// Report
return(list.ToArray());
}
/// <summary>
/// Ordnet dieser Instanz einem Graphen zu.
/// </summary>
/// <param name="graph">Der gewünschte Graph.</param>
/// <param name="name">Der Name des Filters im Graphen.</param>
public void JoinFilterGraph(IFilterGraph graph, string name)
{
// Cleanup
BDAEnvironment.Release(ref m_Graph);
// Remember
m_Name = name;
// Disconnect request
if (graph == null)
{
return;
}
// Remember
m_Graph = Marshal.GetIUnknownForObject(graph);
// Release
if (Marshal.IsComObject(graph))
{
Marshal.ReleaseComObject(graph);
}
}
/// <summary>
/// Gibt die Filterreferenz zu diesem Endpunkt frei.
/// </summary>
public void DisposeFilter()
{
// Free COM reference
BDAEnvironment.Release(ref Filter);
}
/// <summary>
/// Untersucht alle Endpunkte eines Filters.
/// </summary>
/// <param name="filter">Der zu betrachtende Filter.</param>
/// <param name="selector">Optional eine Auswahlfunktion.</param>
/// <param name="action">Optional eine Aktion, die pro Endpunkt ausgeführt werden soll.</param>
/// <exception cref="ArgumentNullException">Es wurde kein Filter angegeben.</exception>
public static void InspectAllPins(this TypedComIdentity <IBaseFilter> filter, Predicate <IPin> selector, Func <IPin, bool> action)
{
// Validate
if (filter == null)
{
throw new ArgumentNullException("filter");
}
// Attach to the instance
using (var filterInstance = filter.MarshalToManaged())
{
// Attach to all pins
var pins = filterInstance.Object.EnumPins();
try
{
// Process all
for (; ;)
{
using (var array = new COMArray(1))
{
// Load
uint count = 0;
if (pins.Next(1, array.Address, ref count) != 0)
{
break;
}
// Load object
if (count != 1)
{
continue;
}
// Load the one
var pin = array.GetObject <IPin>(0);
try
{
// Check predicate
if (selector != null)
{
if (!selector(pin))
{
continue;
}
}
// Execute
if (action != null)
{
if (!action(pin))
{
return;
}
}
}
finally
{
// Cleanup
BDAEnvironment.Release(ref pin);
}
}
}
}
finally
{
// Cleanup
BDAEnvironment.Release(ref pins);
}
}
}
/// <summary>
/// Untersucht alle Datenformate eines Endpunktes.
/// </summary>
/// <param name="pin">Der zu betrachtende Endpunkt.</param>
/// <param name="selector">Optional eine Auswahlfunktion.</param>
/// <param name="action">Optional eine Aktion, die pro Format ausgeführt werden soll.</param>
/// <exception cref="ArgumentNullException">Es wurde kein Endpunkt angegeben.</exception>
public static void InspectAllMediaTypes <T>(this T pin, Predicate <MediaType> selector, Func <MediaType, bool> action) where T : IPin
{
// Validate
if (pin == null)
{
throw new ArgumentNullException("pin");
}
// Attach to all pins
var types = pin.EnumMediaTypes();
try
{
// Process all
for (; ;)
{
using (var array = new COMArray(1, false))
{
// Load
uint count;
if (types.Next(1, array.Address, out count) != 0)
{
break;
}
// Load object
if (count != 1)
{
continue;
}
// Load the one
using (var type = new MediaType(array[0], false))
{
// Check predicate
if (selector != null)
{
if (!selector(type))
{
continue;
}
}
// Execute
if (action != null)
{
if (!action(type))
{
return;
}
}
}
}
}
}
finally
{
// Cleanup
BDAEnvironment.Release(ref types);
}
}
/// <summary>
/// Setzt die DVB-S2 Empfangsparameter.
/// </summary>
/// <param name="tune">Informationen zur aktuellen Auswahl der Quellgruppe.</param>
/// <returns>Beschreibt, wie weiter vorzugehen ist.</returns>
private static PipelineResult TuneDVBS2(DataGraph.TuneToken tune)
{
// Graph is starting or resetting
var group = (tune == null) ? null : tune.SourceGroup as SatelliteGroup;
if (group == null)
{
return(PipelineResult.Continue);
}
// Attach to tuner
var tuner = tune.Pipeline.Graph.TunerFilter;
if (tuner == null)
{
return(PipelineResult.Continue);
}
// Verify that grpah is created
if (tune.Pipeline.Graph.TransportStreamAnalyser == null)
{
return(PipelineResult.Continue);
}
// Not DVB-S2
if (!group.UsesS2Modulation)
{
return(PipelineResult.Continue);
}
// Attach to the BDA interface
var config = tuner.GetDigitalDemodulator();
if (config == null)
{
return(PipelineResult.Continue);
}
// Requires cleanup
try
{
// Change interface
var config2 = config as IBDADigitalDemodulator2;
if (config2 == null)
{
return(PipelineResult.Continue);
}
// Pilot to use
var pilot = PilotMode.NotSet;
// Roll-Off to use
var rollOff = RollOff.NotDefined;
switch (group.RollOff)
{
case S2RollOffs.Alpha20: rollOff = RollOff.Twenty; break;
case S2RollOffs.Alpha25: rollOff = RollOff.TwentyFive; break;
case S2RollOffs.Alpha35: rollOff = RollOff.ThirtyFive; break;
default: rollOff = RollOff.NotSet; break;
}
// Modulation to use
var modulation = ModulationType.NotDefined;
switch (group.Modulation)
{
case SatelliteModulations.QPSK: modulation = ModulationType.NBCQPSK; break;
case SatelliteModulations.PSK8: modulation = ModulationType.NBC8PSK; break;
case SatelliteModulations.QAM16: modulation = ModulationType.QAM16; break;
}
// Update conditionally
if (modulation != ModulationType.NotDefined)
{
config2.SetModulation(ref modulation);
}
// Update unconditionally
config2.SetRollOff(ref rollOff);
config2.SetPilot(ref pilot);
}
finally
{
// Back to COM
BDAEnvironment.Release(ref config);
}
// Normal
return(PipelineResult.Continue);
}
/// <summary>
/// Führt die DiSEqC Steuerung aus.
/// </summary>
/// <param name="token">Die aktuellen Informationen zum Wechsel der Quellgruppe.</param>
/// <returns>Meldet, wie die weitere Abarbeitung zu erfolgen hat.</returns>
private static PipelineResult ApplyDiSEqC(DataGraph.TuneToken token)
{
// Check mode
var location = (token == null) ? null : token.GroupLocation as SatelliteLocation;
if (location == null)
{
return(PipelineResult.Continue);
}
// Load tuner
var tuner = token.Pipeline.Graph.TunerFilter;
if (tuner == null)
{
return(PipelineResult.Continue);
}
// Verify that grpah is created
if (token.Pipeline.Graph.TransportStreamAnalyser == null)
{
return(PipelineResult.Continue);
}
// Check support
var diseqc = tuner.GetOutputControlNode <IBDADiseqCommand>(0);
if (diseqc == null)
{
return(PipelineResult.Continue);
}
// Requires cleanup
try
{
// Enable
diseqc.Enable = true;
// Set mode
switch (location.LNB)
{
case DiSEqCLocations.BurstOff: diseqc.UseToneBurst = false; break;
case DiSEqCLocations.BurstOn: diseqc.UseToneBurst = true; break;
case DiSEqCLocations.DiSEqC1: diseqc.LNBSource = 1; break;
case DiSEqCLocations.DiSEqC2: diseqc.LNBSource = 2; break;
case DiSEqCLocations.DiSEqC3: diseqc.LNBSource = 3; break;
case DiSEqCLocations.DiSEqC4: diseqc.LNBSource = 4; break;
case DiSEqCLocations.None: diseqc.Enable = false; break;
}
}
finally
{
// Cleanup
BDAEnvironment.Release(ref diseqc);
}
// Next
return(PipelineResult.Continue);
}
/// <summary>
/// Aktiviert die Auswahl einer DVB-S2 Quellgruppe.
/// </summary>
/// <param name="tune">Der aktuelle Auswahlvorgang.</param>
/// <returns>Beschreibt, wie die Bearbeitung weiter fortgeführt werden soll.</returns>
private static PipelineResult ActivateS2(DataGraph.TuneToken tune)
{
// Graph is starting or resetting
var group = (tune == null) ? null : tune.SourceGroup as SatelliteGroup;
if (group == null)
{
return(PipelineResult.Continue);
}
// Attach to tuner
var tuner = tune.Pipeline.Graph.TunerFilter;
if (tuner == null)
{
return(PipelineResult.Continue);
}
// Verify that grpah is created
if (tune.Pipeline.Graph.TransportStreamAnalyser == null)
{
return(PipelineResult.Continue);
}
// Not DVB-S2
if (!group.UsesS2Modulation)
{
return(PipelineResult.Continue);
}
// Attach to the locator of the tune request
var locator = tune.TuneRequest.Locator;
try
{
// Apply modulation
switch (group.Modulation)
{
case SatelliteModulations.QPSK: locator.Modulation = (ModulationType)(ModulationType.AnalogFrequency + 5); break;
case SatelliteModulations.PSK8: locator.Modulation = (ModulationType)(ModulationType.AnalogFrequency + 6); break;
case SatelliteModulations.QAM16: locator.Modulation = ModulationType.QAM16; break;
}
// Store back
tune.TuneRequest.Locator = locator;
}
finally
{
// Cleanup properly
BDAEnvironment.Release(ref locator);
}
// Attach to the one input pin of the tuner
using (var input = tuner.GetSinglePin(PinDirection.Input))
{
// Start with roll-off
using (var propertySet = KsPropertySet.Create <RollOff>(input.Interface))
if (propertySet != null)
{
// Get the property and node to use
var roNode = KsPNode.Create(BdaTunerExtensionProperties, BDATunerExtensions.RollOff, BDANodes.Tuner);
// Update
if (propertySet.DoesSupport(roNode, PropertySetSupportedTypes.Set))
{
switch (group.RollOff)
{
case S2RollOffs.Alpha35: propertySet.Set(roNode, RollOff.Offset35); break;
case S2RollOffs.Alpha25: propertySet.Set(roNode, RollOff.Offset25); break;
case S2RollOffs.Alpha20: propertySet.Set(roNode, RollOff.Offset20); break;
default: propertySet.Set(roNode, RollOff.NotSet); break;
}
}
}
// Continue with pilot
using (var propertySet = KsPropertySet.Create <Pilot>(input.Interface))
if (propertySet != null)
{
// Get the property and node to use
var piNode = KsPNode.Create(BdaTunerExtensionProperties, BDATunerExtensions.Pilot, BDANodes.Tuner);
// Update
if (propertySet.DoesSupport(piNode, PropertySetSupportedTypes.Set))
{
propertySet.Set(piNode, Pilot.NotSet);
}
}
}
// Normal
return(PipelineResult.Continue);
}
/// <summary>
/// Führt die DiSEqC Steuerung aus.
/// </summary>
/// <param name="token">Die aktuellen Informationen zum Wechsel der Quellgruppe.</param>
/// <returns>Meldet, wie die weitere Abarbeitung zu erfolgen hat.</returns>
private static PipelineResult ApplyDiSEqC(DataGraph.TuneToken token)
{
// Check mode
var location = (token == null) ? null : token.GroupLocation as SatelliteLocation;
if (location == null)
{
return(PipelineResult.Continue);
}
// Attach to capture
var capture = token.Pipeline.Graph.CaptureFilter;
if (capture == null)
{
return(PipelineResult.Continue);
}
// Verify that grpah is created
if (token.Pipeline.Graph.TransportStreamAnalyser == null)
{
return(PipelineResult.Continue);
}
// Initial
uint positionOption;
switch (location.LNB)
{
case DiSEqCLocations.DiSEqC1: positionOption = 0x0000; break;
case DiSEqCLocations.DiSEqC2: positionOption = 0x0001; break;
case DiSEqCLocations.DiSEqC3: positionOption = 0x0100; break;
case DiSEqCLocations.DiSEqC4: positionOption = 0x0101; break;
default: positionOption = uint.MaxValue; break;
}
// Request interface
var filter = capture.GetFrequencyFilter();
if (filter != null)
{
// Do it the more or less modern way
try
{
// Load
filter.Range = positionOption;
}
finally
{
// Cleanup
BDAEnvironment.Release(ref filter);
}
}
else
{
// Attach to the tuning space
var space = token.TuneRequest.TuningSpace;
try
{
// Store
((IDVBSTuningSpace)space).InputRange = positionOption.ToString();
}
finally
{
// Cleanup
BDAEnvironment.Release(ref space);
}
}
// Next
return(PipelineResult.Continue);
}
/// <summary>
/// Wertet alle Filter in einem Graphen aus.
/// </summary>
/// <typeparam name="T">Konkret verwendete Schnittstelle.</typeparam>
/// <param name="graph">Der zu untersuchende Graph.</param>
/// <param name="action">Wird für jeden gefundenen Filter aktiviert.</param>
/// <exception cref="ArgumentNullException">Es wurde kein Graph angegeben.</exception>
public static void InspectFilters <T>(this T graph, Func <IBaseFilter, bool> action) where T : IFilterGraph
{
// Validate
if (graph == null)
{
throw new ArgumentNullException("graph");
}
// Get enumerator
var filters = graph.EnumFilters();
if (filters == null)
{
return;
}
// List to process
var process = new List <IBaseFilter>();
try
{
// Process all
for (; ;)
{
using (var filterArray = new COMArray(1))
{
// Load
uint n;
if (filters.Next(1, filterArray.Address, out n) != 0)
{
break;
}
if (n != 1)
{
break;
}
// Load
process.Add(filterArray.GetObject <IBaseFilter>(0));
}
}
}
catch
{
// Disable action
action = null;
// Forward
throw;
}
finally
{
// Cleanup enumeration
BDAEnvironment.Release(ref filters);
// Safe process
try
{
// Test all
if (action != null)
{
foreach (var filter in process)
{
if (!action(filter))
{
break;
}
}
}
}
finally
{
// Cleanup collected filters
foreach (var filter in process)
{
if (Marshal.IsComObject(filter))
{
Marshal.ReleaseComObject(filter);
}
}
}
}
}
/// <summary>
/// Erzuegt den Anzeigegraphen.
/// </summary>
/// <param name="mpeg4">Gesetzt für H.264 Bildinformationen - ansonsten wird MPEG-2 erwartet.</param>
/// <param name="ac3">Gesetzt für AC3 Toninformationen - ansonsten wird MP2 erwartet.</param>
public void Show(bool mpeg4, bool ac3)
{
// Startup
bool firstCall = PrepareShow();
// Leave fullscreen before stopping graph
bool fullscreen = FullScreen;
if (fullscreen)
{
FullScreen = false;
}
// Stop the graph
Stop();
// Forget the clock
DisposeClock();
// Remove all filters not created by us
var noRemove = new HashSet <IntPtr>(m_Filters.Values.Select(f => f.Interface));
((IFilterGraph)m_Graph).InspectFilters(filter =>
{
// Create report structure
var info = new FilterInfo();
// Load it
filter.QueryFilterInfo(ref info);
// Forget about graph
BDAEnvironment.Release(ref info.Graph);
// Process using raw interfaces
using (var id = ComIdentity.Create(filter))
if (!noRemove.Contains(id.Interface))
{
try
{
// Repoert
if (DirectShowTraceSwitch.Enabled)
{
Trace.WriteLine(string.Format(Properties.Resources.Trace_RemoveFilter, info.Name), DirectShowTraceSwitch.DisplayName);
}
// Process
DirectShowObject.RemoveFilter(id.Interface);
}
catch (Exception e)
{
// Report
Trace.WriteLine(string.Format(Properties.Resources.Trace_Exception_RemoveFilter, info.Name, e.Message), DirectShowTraceSwitch.DisplayName);
}
}
});
// Create media types
var videoType = CreateVideoType(mpeg4, UseCyberlink);
var audioType = CreateAudioType(ac3);
// Configure injection pins
InjectorFilter.SetAudioType(audioType);
InjectorFilter.SetVideoType(videoType);
// Helper
var audioConnected = false;
var videoConnected = false;
// Pre-loaded decoders
LoadDecoder(mpeg4 ? H264Decoder : MPEG2Decoder, mpeg4 ? "HDTV-Video" : "SDTV-Video", decoder => videoConnected = TryDirectConnect(decoder, InjectorFilter.VideoPin, videoType));
LoadDecoder(ac3 ? AC3Decoder : MP2Decoder, ac3 ? "AC3-Audio" : "MP2-Audio", decoder => audioConnected = TryDirectConnect(decoder, InjectorFilter.AudioPin, audioType));
// Create display
if (!audioConnected)
{
DirectShowObject.Render(InjectorFilter.AudioPin.Interface);
}
if (!videoConnected)
{
DirectShowObject.Render(InjectorFilter.VideoPin.Interface);
}
// Show for the first time
var vmr = VMR;
if (firstCall)
{
if (vmr != null)
{
if (m_VideoWindow != null)
{
// Respect window settings
vmr.ClippingWindow = m_VideoWindow;
vmr.AdjustSize(m_VideoWindow);
}
}
}
// Use it
m_Clock = new NoMarshalComObjects.ReferenceClock(Activator.CreateInstance(Type.GetTypeFromCLSID(Constants.CLSID_SystemClock)), true);
// Attach to graph
GraphAsFilter.SetSyncSource(m_Clock.ComInterface);
// Time to restart the graph
Run();
// Reinstall volume
if (m_LastVolume.HasValue)
{
Volume = m_LastVolume.Value;
}
// Reinstall picture parameters
if (m_PictureParameters != null)
{
if (vmr != null)
{
m_PictureParameters.Update(vmr);
}
}
// Back to full screen mode
if (fullscreen)
{
FullScreen = true;
}
}
/// <summary>
/// Erzeugt den zugehörigen Filter.
/// </summary>
/// <returns>Der gewünschte Filter.</returns>
/// <exception cref="NotSupportedException">Der angeforderte Filter existiert.</exception>
public TypedComIdentity <IBaseFilter> CreateFilter()
{
// Create system device enumerator
var devEnum = (ICreateDevEnum)Activator.CreateInstance(System.Type.GetTypeFromCLSID(BDAEnvironment.SystemDeviceEnumeratorClassIdentifier));
try
{
// Helper
var category = Category;
// Get the enumerator
IEnumMoniker monikers;
if (devEnum.CreateClassEnumerator(ref category, out monikers, 0) >= 0)
{
if (monikers != null)
{
try
{
// Process all
for (; ;)
{
using (var array = new COMArray(1))
{
// Load
uint count;
if (monikers.Next(1, array.Address, out count) != 0)
{
break;
}
if (count != 1)
{
break;
}
// Load object
var moniker = array.GetObject <IMoniker>(0);
try
{
// Check name
if (string.Equals(Moniker, moniker.ReadProperty("DevicePath")))
{
// Create the instance
var iid = new Guid("56a86895-0ad4-11ce-b03a-0020af0ba770");
var filter = moniker.BindToObject(null, null, ref iid);
// Report safely
try
{
// Construct
return(ComIdentity.Create((IBaseFilter)filter));
}
catch
{
// Cleanup
BDAEnvironment.Release(ref filter);
// Forward
throw;
}
}
}
finally
{
// Release
BDAEnvironment.Release(ref moniker);
}
}
}
}
finally
{
// Cleanup
BDAEnvironment.Release(ref monikers);
}
}
}
}
finally
{
// Back to COM
BDAEnvironment.Release(ref devEnum);
}
// Not found
throw new NotSupportedException(string.Format(Properties.Resources.Exception_BadFilter, this));
}
