Partager via

Démarrage d’un minidriver BDA

  • Article

Lorsqu’un appareil BDA commence à fonctionner, le gestionnaire de Plug-and-Play (PnP) répartit IRP_MN_START_DEVICE. La classe AVStream appelle à son tour la routine de démarrage du minidriver BDA associé à l’appareil BDA. Cette routine de démarrage récupère des informations sur l’appareil à partir du Registre, définit des informations sur l’appareil, puis appelle la fonction de support BdaCreateFilterFactory pour :

  • Créez la fabrique de filtres pour l’appareil à partir du descripteur de filtre initial (KSFILTER_DESCRIPTOR) de l’appareil. Le descripteur de filtre initial fait référence aux tables de répartition et d’automatisation pour les broches de filtre et d’entrée. Pour plus d’informations, consultez Création de tables de répartition et Définition de tables Automation .

  • Associez la fabrique de filtres à une structure BDA_FILTER_TEMPLATE . Cette structure fait référence au descripteur de filtre de modèle pour l’appareil et à la liste des paires possibles de broches d’entrée et de sortie. Ce descripteur et cette liste font à leur tour référence :

    • Structures de modèles statiques qu’un fournisseur de réseau peut utiliser pour déterminer la topologie d’un filtre BDA.
    • Nœuds et broches pour un filtre BDA, ainsi que les moyens possibles de connecter le filtre.
    • Routines qu’un fournisseur de réseau peut utiliser pour créer et fermer un filtre instance.
    • Structures de modèles statiques qu’un fournisseur de réseau peut utiliser pour manipuler un filtre BDA.

  • Inscrivez les structures de modèles statiques spécifiées par BDA_FILTER_TEMPLATE auprès de la bibliothèque de prise en charge BDA afin que la bibliothèque puisse fournir une gestion par défaut des propriétés et méthodes d’un minidriver BDA.

L’extrait de code suivant montre un exemple de descripteur de filtre initial pour l’appareil que BdaCreateFilterFactory définit comme fabrique de filtre :

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
};

L’extrait de code suivant montre un exemple de tableau de descripteurs de broches initiaux exposés par un filtre initialisé. Le fournisseur de réseau initialise un filtre à l’aide d’un tel tableau avant que le fournisseur de réseau configure ce filtre. Toutefois, lors de la configuration d’un filtre initialisé, le fournisseur réseau sélectionne des broches référencées dans le pointeur vers le membre de descripteur de filtre de la structure BDA_FILTER_TEMPLATE. Pour plus d’informations, consultez Configuration d’un filtre BDA .

//
//  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
    }
};

Notez qu’un filtre initialisé doit avoir une ou plusieurs broches d’entrée exposées afin que l’interface Microsoft DirectShow IFilterMapper2 ou IFilterMapper puisse localiser ce filtre. Consultez la documentation Microsoft Windows SDK pour plus d’informations sur ces interfaces DirectShow.

L’extrait de code suivant montre des exemples de structure BDA_FILTER_TEMPLATE et de structures et de tableaux associés :

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
    }
};