/// <summary>
        /// Versucht den DVB.NET Datenstrom direkt mit dem zugehörigen Decoder zu verbinden.
        /// </summary>
        /// <param name="decoder">Ein manuell angelegter Decoder.</param>
        /// <param name="source">Der zu verwendende Ausgang.</param>
        /// <param name="mediaType">Das verwendete Format.</param>
        /// <returns>Gesetzt, wenn die Verbindung aufgebaut wurde.</returns>
        private bool TryDirectConnect(TypedComIdentity <IBaseFilter> decoder, OutputPin source, MediaType mediaType)
        {
            // In normal cases we should directly connect to the filter so try
            var connected = false;

            // Try manual connect
            decoder.InspectAllPins(p => p.QueryDirection() == PinDirection.Input,
                                   pin =>
            {
                // Skip on error
                try
                {
                    // Get the raw interface for the media type
                    var type = mediaType.GetReference();

                    // Process
                    using (var iFace = ComIdentity.Create <IPin>(pin))
                        source.Connect(iFace.Interface, type);

                    // Did it
                    connected = true;
                }
                catch (Exception)
                {
                }

                // First pin only - even if it can not be used!
                return(false);
            });

            // Failed
            if (!connected)
            {
                return(false);
            }

            // Find the output of the decoder and render it
            decoder.InspectAllPins(p => p.QueryDirection() == PinDirection.Output,
                                   pin =>
            {
                // Create helper
                using (var pinWrapper = ComIdentity.Create <IPin>(pin))
                    DirectShowObject.Render(pinWrapper.Interface);

                // Did it
                return(false);
            });

            // Report
            return(connected);
        }
        /// <summary>
        /// Ermittelt einen einzelnen Endpunkt.
        /// </summary>
        /// <param name="filter">Der zu betrachtende Filter.</param>
        /// <param name="direction">Die zu untersuchende Seite des Filters.</param>
        /// <returns>Eine Referenz auf den gewünschten Endpunkt.</returns>
        /// <exception cref="ArgumentNullException">Es wurde kein Filter angegeben.</exception>
        /// <exception cref="InvalidOperationException">Der angegeben Endpunkt existiert nicht.</exception>
        public static TypedComIdentity <IPin> GetSinglePin(this TypedComIdentity <IBaseFilter> filter, PinDirection direction)
        {
            // Validate
            if (filter == null)
            {
                throw new ArgumentNullException("filter");
            }

            // Result to use
            TypedComIdentity <IPin> result = null;

            // Use helper to check all of it
            filter.InspectAllPins(p => p.QueryDirection() == direction, p =>
            {
                // At most one hit is allowed
                if (result != null)
                {
                    // Cleanup
                    result.Dispose();

                    // Report error
                    throw new InvalidOperationException(Properties.Resources.Exception_DuplicateEndpoint);
                }

                // Remember the first one
                result = ComIdentity.Create(p);
            });

            // Ups
            if (result != null)
            {
                return(result);
            }
            else
            {
                throw new InvalidOperationException(Properties.Resources.Exception_NoEndpoint);
            }
        }
        /// <summary>
        /// Versucht den DVB.NET Datenstrom direkt mit dem zugehörigen Decoder zu verbinden.
        /// </summary>
        /// <param name="decoder">Ein manuell angelegter Decoder.</param>
        /// <param name="source">Der zu verwendende Ausgang.</param>
        /// <param name="mediaType">Das verwendete Format.</param>
        /// <returns>Gesetzt, wenn die Verbindung aufgebaut wurde.</returns>
        private bool TryDirectConnect( TypedComIdentity<IBaseFilter> decoder, OutputPin source, MediaType mediaType )
        {
            // In normal cases we should directly connect to the filter so try
            var connected = false;

            // Try manual connect
            decoder.InspectAllPins( p => p.QueryDirection() == PinDirection.Input,
                pin =>
                {
                    // Skip on error
                    try
                    {
                        // Get the raw interface for the media type
                        var type = mediaType.GetReference();

                        // Process
                        using (var iFace = ComIdentity.Create<IPin>( pin ))
                            source.Connect( iFace.Interface, type );

                        // Did it
                        connected = true;
                    }
                    catch (Exception)
                    {
                    }

                    // First pin only - even if it can not be used!
                    return false;
                } );

            // Failed
            if (!connected)
                return false;

            // Find the output of the decoder and render it
            decoder.InspectAllPins( p => p.QueryDirection() == PinDirection.Output,
                pin =>
                {
                    // Create helper
                    using (var pinWrapper = ComIdentity.Create<IPin>( pin ))
                        DirectShowObject.Render( pinWrapper.Interface );

                    // Did it
                    return false;
                } );

            // Report
            return connected;
        }
 /// <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, Action <IPin> action)
 {
     // Forward
     filter.InspectAllPins(selector, pin => { action(pin); return(true); });
 }
 /// <summary>
 /// Untersucht alle Endpunkte eines Filters.
 /// </summary>
 /// <param name="filter">Der zu betrachtende Filter.</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, Action <IPin> action)
 {
     // Forward
     filter.InspectAllPins(null, action);
 }