Iniciando um minidriver BDA

  • Artigo

Quando um dispositivo BDA começa a operar, o gerenciador de Plug and Play (PnP) envia IRP_MN_START_DEVICE. A classe AVStream, por sua vez, chama a rotina de início do minidriver BDA associado ao dispositivo BDA. Essa rotina de início recupera informações sobre o dispositivo do registro, define informações sobre o dispositivo e, em seguida, chama a função de suporte BdaCreateFilterFactory para:

  • Crie a fábrica de filtros para o dispositivo do descritor de filtro inicial (KSFILTER_DESCRIPTOR) para o dispositivo. O descritor de filtro inicial faz referência a tabelas de expedição e automação para os pinos de filtro e de entrada. Consulte Criando tabelas de expedição e definindo tabelas de automação para obter mais informações.

  • Associe a fábrica de filtros a uma estrutura BDA_FILTER_TEMPLATE . Essa estrutura faz referência ao descritor de filtro de modelo para o dispositivo e à lista de possíveis pares de pinos de entrada e saída. Este descritor e lista, por sua vez, fazem referência:

    • Estruturas de modelo estático que um provedor de rede pode usar para determinar a topologia de um filtro BDA.
    • Nós e pinos para um filtro BDA, juntamente com possíveis maneiras de conectar o filtro.
    • Rotinas que um provedor de rede pode usar para criar e fechar uma instância de filtro.
    • Estruturas de modelo estático que um provedor de rede pode usar para manipular um filtro BDA.

  • Registre as estruturas de modelo estático especificadas por BDA_FILTER_TEMPLATE com a biblioteca de suporte do BDA para que a biblioteca possa fornecer tratamento padrão para propriedades e métodos de um minidriver BDA.

O snippet de código a seguir mostra um exemplo de um descritor de filtro inicial para o dispositivo que BdaCreateFilterFactory define como a fábrica de filtros:

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

O snippet de código a seguir mostra um exemplo de uma matriz de descritores de pino iniciais que são expostos por um filtro inicializado. O provedor de rede inicializa um filtro usando essa matriz antes que o provedor de rede configure esse filtro. No entanto, ao configurar um filtro inicializado, o provedor de rede seleciona os pinos referenciados no ponteiro para o membro descritor de filtro da estrutura BDA_FILTER_TEMPLATE. Consulte Configurando um filtro BDA para obter mais informações.

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

Observe que um filtro inicializado deve ter um ou mais pinos de entrada expostos para que a interface IFilterMapper2 ou IFilterMapper do Microsoft DirectShow possa localizar esse filtro. Consulte a documentação do SDK do Microsoft Windows para obter informações sobre essas interfaces do DirectShow.

O snippet de código a seguir mostra exemplos de uma estrutura BDA_FILTER_TEMPLATE e estruturas e matrizes relacionadas:

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