Inicio de un minidriver BDA

Cuando un dispositivo BDA comienza a funcionar, el administrador de Plug and Play (PnP) envía IRP_MN_START_DEVICE. A su vez, la clase AVStream llama a la rutina de inicio del minidriver BDA asociado al dispositivo BDA. Esta rutina de inicio recupera información sobre el dispositivo del Registro, establece información sobre el dispositivo y, a continuación, llama a la función de compatibilidad de BdaCreateFilterFactory para:

• Cree el generador de filtros para el dispositivo a partir del descriptor de filtro inicial (KSFILTER_DESCRIPTOR) para el dispositivo. El descriptor de filtro inicial hace referencia a las tablas de distribución y automatización para los pines de entrada y filtro. Consulte Creación de tablas de distribución y Definición de tablas de automatización para obtener más información.

• Asocie el generador de filtros a una estructura de BDA_FILTER_TEMPLATE . Esta estructura hace referencia al descriptor de filtro de plantilla para el dispositivo y la lista de posibles pares de patillas de entrada y salida. Este descriptor y la lista hacen referencia a su vez:

  • Estructuras de plantilla estáticas que un proveedor de red puede usar para determinar la topología de un filtro BDA.
  • Nodos y patillas para un filtro BDA junto con posibles formas de conectar el filtro.
  • Rutinas que un proveedor de red puede usar para crear y cerrar una instancia de filtro.
  • Estructuras de plantilla estáticas que un proveedor de red puede usar para manipular un filtro BDA.

• Registre las estructuras de plantilla estáticas especificadas por BDA_FILTER_TEMPLATE con la biblioteca de compatibilidad de BDA para que la biblioteca pueda proporcionar un control predeterminado para las propiedades y los métodos de un minidriver de BDA.

En el fragmento de código siguiente se muestra un ejemplo de un descriptor de filtro inicial para el dispositivo que BdaCreateFilterFactory establece como generador 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
};

En el fragmento de código siguiente se muestra un ejemplo de una matriz de descriptores de pin iniciales expuestos por un filtro inicializado. El proveedor de red inicializa un filtro mediante dicha matriz antes de que el proveedor de red configure ese filtro. Sin embargo, al configurar un filtro inicializado, el proveedor de red selecciona las patillas a las que se hace referencia en el puntero al miembro descriptor de filtro de la estructura de BDA_FILTER_TEMPLATE. Consulte Configuring a BDA Filter (Configuración de un filtro BDA ) para obtener más información.

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

Tenga en cuenta que un filtro inicializado debe tener uno o varios pines de entrada expuestos para que la interfaz IFilterMapper2 o IFilterMapper de Microsoft directShow puedan localizar ese filtro. Consulte la documentación de Microsoft Windows SDK para obtener información sobre estas interfaces directShow.

En el fragmento de código siguiente se muestran ejemplos de una estructura de BDA_FILTER_TEMPLATE y estructuras y matrices 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
    }
};