crossbarprop.cpp

完整的基于Conxant平台的USB电视棒的WIN驱动程序。

/*+++ *******************************************************************\ 
* 
*  Copyright and Disclaimer: 
*  
*     --------------------------------------------------------------- 
*     This software is provided "AS IS" without warranty of any kind, 
*     either expressed or implied, including but not limited to the 
*     implied warranties of noninfringement, merchantability and/or 
*     fitness for a particular purpose.
*     --------------------------------------------------------------- 
*   
*     Copyright (c) 2008 Conexant Systems, Inc. 
*     All rights reserved. 
*
\******************************************************************* ---*/ 

#include "crossbarprop.h"
#include "registryAccess.h"

#include "crossbarpinset.h"

#include "debug.h"
#include "device.h"
#include "commonGuid.h"

/////////////////////////////////////////////////////////////////////////////////////////
//Crossbar output pins
//
CROSSBAR_PIN_PROPERTIES 
CrossbarProperties::
_output_pin_info[CrossbarProperties::XBAR_NUM_OUTPINS] = 
{
    //Output pin 0: Video decoder out
    {KS_PhysConn_Video_VideoDecoder,    //Type
     XBAR_OUTPIN_AUDIO_DECODER,         //Related pin index
     {XBAR_VIDEO_OUT_GUID, 0, 0}},      //Medium

    {KS_PhysConn_Audio_AudioDecoder,    //Type
     XBAR_OUTPIN_VIDEO_DECODER,         //Related pin index
     {XBAR_AUDIO_OUT_GUID, 0, 0 }}      //Medium
};

/////////////////////////////////////////////////////////////////////////////////////////
//CrossbarProperties::CrossbarProperties (constructor)
//
// Initializes the selected video and audio inputs.  
// Reads the last video input from the registry.
//
CrossbarProperties::CrossbarProperties(PDEVICE_OBJECT pdo):
_selected_video_input(0),         //Input 0  
_selected_audio_input(0xFFFFFFFF), //Mute
_pdo(pdo)
{
    DWORD video_input_pin = 0;
    DWORD audio_input_pin = 0;
    RegistryAccess registry_access(_pdo);
    registry_access.readDword("VideoInputPin", &video_input_pin);

    _selected_video_input = video_input_pin;
    registry_access.readDword("AudioInputPin",&audio_input_pin);

    _selected_audio_input=audio_input_pin;
}

/////////////////////////////////////////////////////////////////////////////////////////
//CrossbarProperties::~CrossbarProperties (destructor)
//
// Saves the selected video input pin to the registry.
//
CrossbarProperties::~CrossbarProperties()
{
}

/////////////////////////////////////////////////////////////////////////////////////////
//CrossbarProperties::allocate
//
CrossbarProperties* CrossbarProperties::allocate(
                                                 Device* p_device,
                                                 PDEVICE_OBJECT pdo)
{
    DbgLog(("CrossbarProperties::allocate()\n"));
    CrossbarProperties* p_properties = NULL;
    p_properties = new CrossbarPinSet(p_device, pdo);

    if(!p_properties)
    {
        DbgLogError(("Unable to allocate crossbar properties object\n"));
        return NULL;
    }

    p_properties->registerFilter(pdo, p_device->getMediumId());

    return p_properties;
}

/////////////////////////////////////////////////////////////////////////////////////////
//CrossbarProperties::registerFilter
//
//We need to call KsRegisterFilterWithNoKSPins to register the crossbar correctly
// so that it can get enumerated with the GraphBuilder::FindInterface() call
// in AMCap.
//
// This function should be called when the filter is created.
//

NTSTATUS CrossbarProperties::registerFilter(PDEVICE_OBJECT p_physical_device, DWORD medium_id)
{
    //Get the total number of pins on the filter.  (input and output pins)
    DWORD input_pin_count = getNumInputPins();
    DWORD pin_count =  XBAR_NUM_OUTPINS + input_pin_count;

    //Build an array of pin directions
    BOOL* pin_direction_array = new BOOL[pin_count];
    if(!pin_direction_array)
    {
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    const BOOL XBAR_IN_PIN  = FALSE;
    const BOOL XBAR_OUT_PIN = TRUE;

    //All input pins must be listed first.  Then all output pins.
    DWORD i;
    for(i = 0; i < input_pin_count; i++)
    {
        pin_direction_array[i] = XBAR_IN_PIN;
    }
    for(i = 0; i < XBAR_NUM_OUTPINS; i++)
    {
        pin_direction_array[input_pin_count+i] = XBAR_OUT_PIN;
    }

    //Build an array of pin mediums
    KSPIN_MEDIUM* p_mediums = new KSPIN_MEDIUM[pin_count];
    if(!p_mediums)
    {
        delete [] pin_direction_array;
        return STATUS_INSUFFICIENT_RESOURCES;
    }
    KSPIN_MEDIUM* ptr_medium=p_mediums;

    for(i = 0; i < input_pin_count; i++)
    {
        //Get the medium for the current pin
        CROSSBAR_PIN_PROPERTIES properties;
        getInputPinInfo(i, &properties);

	*(ptr_medium)=properties.medium;
        ptr_medium->Id=medium_id;
        ptr_medium++;
    }
    for(i = 0; i < XBAR_NUM_OUTPINS; i++)
    {
       *(ptr_medium)=_output_pin_info[i].medium;
       ptr_medium->Id=medium_id;
       ptr_medium++;
    }

    NTSTATUS status = KsRegisterFilterWithNoKSPins(
        p_physical_device,
        &KSCATEGORY_CROSSBAR,
        pin_count, 
        pin_direction_array, //Direction
        p_mediums,           //Medium List
        NULL);

    delete [] pin_direction_array;
    delete [] p_mediums;

    return status;
}

/////////////////////////////////////////////////////////////////////////////////////////
//CrossbarProperties::static_getCapabilities
//
// This is the handler for KSPROPERTY_CROSSBAR_CAPS.
// It needs to fill in the number of input and output pins.
// 
// Parameters:
// p_irp - IRP making the request
// p_request - input buffer
// p_data - output buffer
//

NTSTATUS CrossbarProperties::static_getCapabilities(
        PIRP p_irp,
        PKSPROPERTY_CROSSBAR_CAPS_S p_request,
        PKSPROPERTY_CROSSBAR_CAPS_S p_data)
{
        //Get the filter
    PKSFILTER p_filter = KsGetFilterFromIrp(p_irp);
    
    if(!p_filter)
    {
        return STATUS_UNSUCCESSFUL;
    }

    PKSDEVICE p_ks_device = KsFilterGetDevice(p_filter);
    if(!p_ks_device)
    {
        return STATUS_UNSUCCESSFUL;
    }

    Device* p_device = (Device*)p_ks_device->Context;

    if(p_device)
    {
    //Get the TunerProperties object from the filter
    CrossbarProperties* p_properties = p_device->getCrossbarProperties();

    if(!p_properties)
    {
        return STATUS_UNSUCCESSFUL;
    }

    //Fill in the number of input and output pins
    p_data->NumberOfInputs = p_properties->getNumInputPins();
    p_data->NumberOfOutputs = XBAR_NUM_OUTPINS;
    }
    else
    {
        return STATUS_UNSUCCESSFUL;
    }

    return STATUS_SUCCESS;
}


/////////////////////////////////////////////////////////////////////////////////////////
//CrossbarProperties::static_getPinInfo
//
// This is the handler for KSPROPERTY_CROSSBAR_PININFO.
// It needs to fill in information on a pin based on the pin index and direction.
// Output pins are handled in this base class.  Input pins are handled by making 
// a call to a virtual function handled in the child class.
// 
// Parameters:
// p_irp - IRP making the request
// p_request - input buffer
// p_data - output buffer
//

NTSTATUS CrossbarProperties::static_getPinInfo(
        PIRP p_irp,
        PKSPROPERTY_CROSSBAR_PININFO_S p_request,
        PKSPROPERTY_CROSSBAR_PININFO_S p_data)
{
        //Get the filter
    PKSFILTER p_filter = KsGetFilterFromIrp(p_irp);
    
    if(!p_filter)
    {
        return STATUS_UNSUCCESSFUL;
    }

    PKSDEVICE p_ks_device = KsFilterGetDevice(p_filter);
    if(!p_ks_device)
    {
        return STATUS_UNSUCCESSFUL;
    }

    Device* p_device = (Device*)p_ks_device->Context;

    if(!p_device)
    {
        return STATUS_UNSUCCESSFUL;
    }

    //Get the TunerProperties object from the filter
    CrossbarProperties* p_properties = p_device->getCrossbarProperties();
    
    if(!p_properties)
    {
        return STATUS_UNSUCCESSFUL;
    }

    NTSTATUS status = STATUS_SUCCESS;
    CROSSBAR_PIN_PROPERTIES pin_info;
    if(p_request->Direction == KSPIN_DATAFLOW_OUT)
    {
        //It's an output pin.  We have the information in the base class