Starten eines BDA Minidrivers

Wenn ein BDA-Gerät den Betrieb startet, sendet der PnP-Manager (Plug & Play) IRP_MN_START_DEVICE. Die AVStream-Klasse wiederum ruft die Startroutine des BDA-Minitreibers auf, der dem BDA-Gerät zugeordnet ist. Diese Startroutine ruft Informationen zum Gerät aus der Registrierung ab, legt Informationen zum Gerät fest und ruft dann die BdaCreateFilterFactory-Unterstützungsfunktion auf:

• Erstellen Sie die Filterfactory für das Gerät aus dem anfänglichen Filterdeskriptor (KSFILTER_DESCRIPTOR) für das Gerät. Der anfängliche Filterdeskriptor verweist auf Dispatch- und Automatisierungstabellen für die Filter- und Eingabepins. Weitere Informationen finden Sie unter Erstellen von Verteilungstabellen und Definieren von Automatisierungstabellen .

• Ordnen Sie die Filterfactory einer BDA_FILTER_TEMPLATE-Struktur zu. Diese Struktur verweist auf den Vorlagenfilterdeskriptor für das Gerät und die Liste der möglichen Paare von Eingabe- und Ausgabepins. Dieser Deskriptor und die Liste verweisen wiederum auf:

  • Statische Vorlagenstrukturen, die ein Netzwerkanbieter verwenden kann, um die Topologie eines BDA-Filters zu bestimmen.
  • Knoten und Pins für einen BDA-Filter sowie mögliche Möglichkeiten zum Verbinden des Filters.
  • Routinen, die ein Netzwerkanbieter verwenden kann, um einen Filter instance zu erstellen und zu schließen.
  • Statische Vorlagenstrukturen, die ein Netzwerkanbieter verwenden kann, um einen BDA-Filter zu bearbeiten.

• Registrieren Sie die statischen Vorlagenstrukturen, die von BDA_FILTER_TEMPLATE angegeben werden, bei der BDA-Unterstützungsbibliothek, damit die Bibliothek die Standardbehandlung für die Eigenschaften und Methoden eines BDA-Minitreibers bereitstellen kann.

Der folgende Codeausschnitt zeigt ein Beispiel für einen anfänglichen Filterdeskriptor für das Gerät, das BdaCreateFilterFactory als Filterfactory festlegt:

const KSFILTER_DESCRIPTOR    InitialTunerFilterDescriptor;
//
//  Filter Factory Descriptor for the tuner filter
//
//  This structure brings together all of the structures that define
//  the tuner filter instance as it appears when it is first created.
//  Note that not all template pin and node types are exposed as
//  pin and node factories when the filter instance is created.
//
DEFINE_KSFILTER_DESCRIPTOR(InitialTunerFilterDescriptor)
{
    &FilterDispatch,             // Table of dispatch routines
    &FilterAutomation,           // Table of properties and methods
    KSFILTER_DESCRIPTOR_VERSION, // Version
    0,                           // Flags
    &KSNAME_Filter,              // Reference Guid
    DEFINE_KSFILTER_PIN_DESCRIPTORS(InitialPinDescriptors),
                                   // PinDescriptorsCount
                                   // PinDescriptorSize
                                   // PinDescriptors
    DEFINE_KSFILTER_CATEGORY(KSCATEGORY_BDA_RECEIVER_COMPONENT),
                            // CategoriesCount
                            // Categories
    DEFINE_KSFILTER_NODE_DESCRIPTORS_NULL(NodeDescriptors),
                                    // NodeDescriptorsCount
                                    // NodeDescriptorSize
                                    // NodeDescriptors
    DEFINE_KSFILTER_DEFAULT_CONNECTIONS, // ConnectionsCount
                                         // Connections
    NULL                // ComponentId
};

Der folgende Codeausschnitt zeigt ein Beispiel für ein Array von anfänglichen Pindeskriptoren, die von einem initialisierten Filter verfügbar gemacht werden. Der Netzwerkanbieter initialisiert einen Filter mithilfe eines solchen Arrays, bevor der Netzwerkanbieter diesen Filter konfiguriert. Beim Konfigurieren eines initialisierten Filters wählt der Netzwerkanbieter jedoch Pins aus, auf die im Zeiger auf den Filterdeskriptormember der BDA_FILTER_TEMPLATE-Struktur verwiesen wird. Weitere Informationen finden Sie unter Konfigurieren eines BDA-Filters .

//
//  Initial Pin Descriptors
//
//  This data structure defines the pins that will appear on the 
//  filter when it is first created.
//
const
KSPIN_DESCRIPTOR_EX
InitialPinDescriptors[] =
{
    //  Antenna Pin
    //
    {
        &AntennaPinDispatch,
        &AntennaAutomation,   // AntennaPinAutomation
        {
            0,  // Interfaces
            NULL,
            0,  // Mediums
            NULL,
            SIZEOF_ARRAY(AntennaPinRanges),
            AntennaPinRanges,
            KSPIN_DATAFLOW_IN,
            KSPIN_COMMUNICATION_BOTH,
            NULL,   // Name
            NULL,   // Category
            0
        },
        KSPIN_FLAG_DO_NOT_USE_STANDARD_TRANSPORT | 
        KSPIN_FLAG_FRAMES_NOT_REQUIRED_FOR_PROCESSING | 
        KSPIN_FLAG_FIXED_FORMAT,
        1,      // InstancesPossible
        0,      // InstancesNecessary
        NULL,   // Allocator Framing
        NULL    // PinIntersectHandler
    }
};

Beachten Sie, dass ein initialisierter Filter einen oder mehrere Eingabenadeln verfügbar machen muss, damit die Microsoft DirectShow IFilterMapper2 - oder IFilterMapper-Schnittstelle diesen Filter finden kann. Informationen zu diesen DirectShow-Schnittstellen finden Sie in der Microsoft Windows SDK-Dokumentation.

Der folgende Codeausschnitt zeigt Beispiele für eine BDA_FILTER_TEMPLATE-Struktur und verwandte Strukturen und Arrays:

const KSFILTER_DESCRIPTOR  TemplateTunerFilterDescriptor;
const BDA_PIN_PAIRING  *TemplateTunerPinPairings;
//
//  BDA Template Topology Descriptor for the filter factory.
//
//  This structure defines the pin and node types that the network 
//  provider can create on the filter and how they are arranged. 
//
const
BDA_FILTER_TEMPLATE
TunerBdaFilterTemplate =
{
    &TemplateTunerFilterDescriptor,
    SIZEOF_ARRAY(TemplateTunerPinPairings),
    TemplateTunerPinPairings
};
//
//  Filter Factory Descriptor for the tuner filter template topology
//
//  This structure brings together all of the structures that define
//  the topologies that the tuner filter can assume as a result of
//  pin factory and topology creation methods.
//
DEFINE_KSFILTER_DESCRIPTOR(TemplateTunerFilterDescriptor)
{
    &FilterDispatch,             // Table of dispatch routines
    &FilterAutomation,           // Table of properties and methods
    KSFILTER_DESCRIPTOR_VERSION, // Version
    0,                           // Flags
    &KSNAME_Filter,              // Reference Guid
    DEFINE_KSFILTER_PIN_DESCRIPTORS(TemplatePinDescriptors),
                                   // PinDescriptorsCount
                                   // PinDescriptorSize
                                   // PinDescriptors
    DEFINE_KSFILTER_CATEGORY(KSCATEGORY_BDA_RECEIVER_COMPONENT),
                            // CategoriesCount
                            // Categories
    DEFINE_KSFILTER_NODE_DESCRIPTORS(NodeDescriptors),  
                                    // NodeDescriptorsCount
                                    // NodeDescriptorSize
                                    // NodeDescriptors
    DEFINE_KSFILTER_CONNECTIONS(TemplateTunerConnections),
                               // ConnectionsCount
                               // Connections
    NULL                // ComponentId
};
//
//  Lists how pairs of input and output pins are configured. 
//
//  Values given to the BDA_PIN_PAIRING structures in the list inform 
//  the network provider which nodes get duplicated when more than one 
//  output pin type is connected to a single input pin type or when
//  more that one input pin type is connected to a single output pin 
//  type. Also, informs of the joints array.
//
const
BDA_PIN_PAIRING TemplateTunerPinPairings[] =
{
    //  Antenna to Transport Topology Joints
    //
    {
        0,  // ulInputPin
        1,  // ulOutputPin
        1,  // ulcMaxInputsPerOutput
        1,  // ulcMinInputsPerOutput
        1,  // ulcMaxOutputsPerInput
        1,  // ulcMinOutputsPerInput
        SIZEOF_ARRAY(AntennaTransportJoints),   // ulcTopologyJoints
        AntennaTransportJoints                  // pTopologyJoints
    }
};