controls.cpp

采集卡的驱动编程,具有较大的参考价值,特别开发视频采集的软件工程师有用

PKSPROPERTY_ITEM Crossbar::PropertyList()
{
	return (PKSPROPERTY_ITEM)XBarProperties;
}

////////////////////////////////////////////////////////////////////////
// Crossbar::Register

NTSTATUS Crossbar::Register(PDEVICE_OBJECT pdo)
{
	return StreamClassRegisterFilterWithNoKSPins(
		pdo,
		(const GUID*)&KSCATEGORY_CROSSBAR,
		SIZEOF_ARRAY(CrossbarMediums),
		(int*)CrossbarPinDirection,
		(KSIDENTIFIER*)CrossbarMediums,
		NULL
		);
}

////////////////////////////////////////////////////////////////////////
// VideoProcAmp property table ... used in registration process
//	provide the characteristics of the VideoProcAmp class back to the 
//	Stream Class Driver.... lots of components defined first.

const ULONG VideoProcAmp::BrightnessDefault = 5000;
const ULONG VideoProcAmp::ContrastDefault = 5000;

//
// First define all of the ranges and stepping values
//

const KSPROPERTY_STEPPING_LONG VideoProcAmp::BrightnessRangeAndStep [] = 
{
    {
        10000 / 10,         // SteppingDelta (range / steps)
        0,                  // Reserved
        0,                  // Minimum in (IRE * 100) units
        10000               // Maximum in (IRE * 100) units
    }
};


const KSPROPERTY_MEMBERSLIST VideoProcAmp::BrightnessMembersList [] = 
{
    {
        {
            KSPROPERTY_MEMBER_RANGES,
            sizeof (BrightnessRangeAndStep),
            SIZEOF_ARRAY (BrightnessRangeAndStep),
            0
        },
        (PVOID) BrightnessRangeAndStep,
     },
     {
        {
            KSPROPERTY_MEMBER_VALUES,
            sizeof (BrightnessDefault),
            sizeof (BrightnessDefault),
            KSPROPERTY_MEMBER_FLAG_DEFAULT
        },
        (PVOID) &BrightnessDefault,
    }    
};

const KSPROPERTY_VALUES VideoProcAmp::BrightnessValues =
{
    {
        STATICGUIDOF (KSPROPTYPESETID_General),
        VT_I4,
        0
    },
    SIZEOF_ARRAY (BrightnessMembersList),
    BrightnessMembersList
};

const KSPROPERTY_STEPPING_LONG VideoProcAmp::ContrastRangeAndStep[] = 
{
    {
        10000 / 256,        // SteppingDelta (range / steps)
        0,                  // Reserved
        0,                  // Minimum in (gain * 100) units
        10000               // Maximum in (gain * 100) units
    }
};


const KSPROPERTY_MEMBERSLIST VideoProcAmp::ContrastMembersList[] = 
{
    {
        {
            KSPROPERTY_MEMBER_RANGES,
            sizeof (ContrastRangeAndStep),
            SIZEOF_ARRAY (ContrastRangeAndStep),
            0
        },
        (PVOID) ContrastRangeAndStep
     },
     {
        {
            KSPROPERTY_MEMBER_VALUES,
            sizeof (ContrastDefault),
            sizeof (ContrastDefault),
            KSPROPERTY_MEMBER_FLAG_DEFAULT
        },
        (PVOID) &ContrastDefault,
    }    
};

const KSPROPERTY_VALUES VideoProcAmp::ContrastValues =
{
    {
        STATICGUIDOF (KSPROPTYPESETID_General),
        VT_I4,
        0
    },
    SIZEOF_ARRAY (ContrastMembersList),
    ContrastMembersList
};


const KSPROPERTY_ITEM VideoProcAmp::VideoProcAmpProperties[] =
{
    DEFINE_KSPROPERTY_ITEM
    (
        KSPROPERTY_VIDEOPROCAMP_CONTRAST,
        TRUE,                                   // GetSupported or Handler
        sizeof(KSPROPERTY_VIDEOPROCAMP_S),      // MinProperty
        sizeof(KSPROPERTY_VIDEOPROCAMP_S),      // MinData
        TRUE,                                   // SetSupported or Handler
        &ContrastValues,                        // Values
        0,                                      // RelationsCount
        NULL,                                   // Relations
        NULL,                                   // SupportHandler
        sizeof(ULONG)                           // SerializedSize
    ),
    DEFINE_KSPROPERTY_ITEM
    (
        KSPROPERTY_VIDEOPROCAMP_BRIGHTNESS,
        TRUE,                                   // GetSupported or Handler
        sizeof(KSPROPERTY_VIDEOPROCAMP_S),      // MinProperty
        sizeof(KSPROPERTY_VIDEOPROCAMP_S),      // MinData
        TRUE,                                   // SetSupported or Handler
        &BrightnessValues,                      // Values
        0,                                      // RelationsCount
        NULL,                                   // Relations
        NULL,                                   // SupportHandler
        sizeof(ULONG)                           // SerializedSize
    ),
};

const ULONG VideoProcAmp::NumProperties()
{
	return SIZEOF_ARRAY(VideoProcAmpProperties);
}

PKSPROPERTY_ITEM VideoProcAmp::PropertyList()
{
	return (PKSPROPERTY_ITEM)VideoProcAmpProperties;
}

VideoProcAmp::VideoProcAmp() :
	m_Brightness(BrightnessDefault),
	m_BrightnessFlags(KSPROPERTY_VIDEOPROCAMP_FLAGS_AUTO),
	m_Contrast(ContrastDefault),
	m_ContrastFlags(KSPROPERTY_VIDEOPROCAMP_FLAGS_AUTO)
{

}

////////////////////////////////////////////////////////////////////////
// CameraControl property table ... used in registration process
//	provide the characteristics of the CameraControl class back to the 
//	Stream Class Driver.... lots of components... define those first

const ULONG CameraControl::ZoomDefault = 5000;
const ULONG CameraControl::FocusDefault = 5000;

//
// First define all of the ranges and stepping values
//

const KSPROPERTY_STEPPING_LONG CameraControl::ZoomRangeAndStep [] = 
{
    {
        10000 / 10,         // SteppingDelta (range / steps)
        0,                  // Reserved
        0,                  // Minimum 
        10000               // Maximum 
    }
};

const KSPROPERTY_MEMBERSLIST CameraControl::ZoomMembersList[] = 
{
    {
        {
            KSPROPERTY_MEMBER_RANGES,
            sizeof (ZoomRangeAndStep),
            SIZEOF_ARRAY (ZoomRangeAndStep),
            0
        },
        (PVOID) ZoomRangeAndStep,
     },
     {
        {
            KSPROPERTY_MEMBER_VALUES,
            sizeof (ZoomDefault),
            sizeof (ZoomDefault),
            KSPROPERTY_MEMBER_FLAG_DEFAULT
        },
        (PVOID) &ZoomDefault,
    }    
};

const KSPROPERTY_VALUES CameraControl::ZoomValues =
{
    {
        STATICGUIDOF (KSPROPTYPESETID_General),
        VT_I4,
        0
    },
    SIZEOF_ARRAY (ZoomMembersList),
    ZoomMembersList
};

const KSPROPERTY_STEPPING_LONG CameraControl::FocusRangeAndStep[] = 
{
    {
        10000 / 256,        // SteppingDelta (range / steps)
        0,                  // Reserved
        0,                  // Minimum 
        10000               // Maximum 
    }
};


const KSPROPERTY_MEMBERSLIST CameraControl::FocusMembersList[] = 
{
    {
        {
            KSPROPERTY_MEMBER_RANGES,
            sizeof (FocusRangeAndStep),
            SIZEOF_ARRAY (FocusRangeAndStep),
            0
        },
        (PVOID) FocusRangeAndStep
     },
     {
        {
            KSPROPERTY_MEMBER_VALUES,
            sizeof (FocusDefault),
            sizeof (FocusDefault),
            KSPROPERTY_MEMBER_FLAG_DEFAULT
        },
        (PVOID) &FocusDefault,
    }    
};

const KSPROPERTY_VALUES CameraControl::FocusValues =
{
    {
        STATICGUIDOF (KSPROPTYPESETID_General),
        VT_I4,
        0
    },
    SIZEOF_ARRAY (FocusMembersList),
    FocusMembersList
};

const KSPROPERTY_ITEM CameraControl::CameraControlProperties[] =
{
    DEFINE_KSPROPERTY_ITEM
    (
        KSPROPERTY_CAMERACONTROL_ZOOM,
        TRUE,                                   // GetSupported or Handler
        sizeof(KSPROPERTY_CAMERACONTROL_S),     // MinProperty
        sizeof(KSPROPERTY_CAMERACONTROL_S),     // MinData
        TRUE,                                   // SetSupported or Handler
        &ZoomValues,                            // Values
        0,                                      // RelationsCount
        NULL,                                   // Relations
        NULL,                                   // SupportHandler
        sizeof(ULONG)                           // SerializedSize
    ),
    DEFINE_KSPROPERTY_ITEM
    (
        KSPROPERTY_CAMERACONTROL_FOCUS,   
        TRUE,                                   // GetSupported or Handler
        sizeof(KSPROPERTY_CAMERACONTROL_S),     // MinProperty
        sizeof(KSPROPERTY_CAMERACONTROL_S),     // MinData
        TRUE,                                   // SetSupported or Handler
        &FocusValues,                           // Values
        0,                                      // RelationsCount
        NULL,                                   // Relations
        NULL,                                   // SupportHandler
        sizeof(ULONG)                           // SerializedSize
    ),
};

const ULONG CameraControl::NumProperties()
{
	return SIZEOF_ARRAY(CameraControlProperties);
}

PKSPROPERTY_ITEM CameraControl::PropertyList()
{
	return (PKSPROPERTY_ITEM)CameraControlProperties; 
}

CameraControl::CameraControl() : 
	m_Focus(FocusDefault),
	m_FocusFlags(KSPROPERTY_CAMERACONTROL_FLAGS_AUTO),
	m_Zoom(ZoomDefault),
	m_ZoomFlags(KSPROPERTY_CAMERACONTROL_FLAGS_AUTO)
{
	
}

////////////////////////////////////////////////////////////////////////
// AnalogVideoDecoder property table ... used in registration process
//	provide the characteristics of the AnalogVideoDecoder class back to the 
//	Stream Class Driver....

const KSPROPERTY_ITEM AnalogVideoDecoder::AnalogVideoDecoderProperties[] =
{
    DEFINE_KSPROPERTY_ITEM
    (
        KSPROPERTY_VIDEODECODER_CAPS,
        TRUE,                                   // GetSupported or Handler
        sizeof(KSPROPERTY_VIDEODECODER_CAPS_S), // MinProperty
        sizeof(KSPROPERTY_VIDEODECODER_CAPS_S), // MinData
        FALSE,                                  // SetSupported or Handler
        NULL,                                   // Values
        0,                                      // RelationsCount
        NULL,                                   // Relations
        NULL,                                   // SupportHandler
        0                                       // SerializedSize
    ),
    DEFINE_KSPROPERTY_ITEM
    (
        KSPROPERTY_VIDEODECODER_STANDARD,
        TRUE,                                   // GetSupported or Handler
        sizeof(KSPROPERTY_VIDEODECODER_S),      // MinProperty
        sizeof(KSPROPERTY_VIDEODECODER_S),      // MinData
        TRUE,                                   // SetSupported or Handler
        NULL,                                   // Values
        0,                                      // RelationsCount
        NULL,                                   // Relations
        NULL,                                   // SupportHandler
        0                                       // SerializedSize
    ),
    DEFINE_KSPROPERTY_ITEM
    (
        KSPROPERTY_VIDEODECODER_STATUS,
        TRUE,                                   // GetSupported or Handler
        sizeof(KSPROPERTY_VIDEODECODER_STATUS_S),// MinProperty
        sizeof(KSPROPERTY_VIDEODECODER_STATUS_S),// MinData
        FALSE,                                  // SetSupported or Handler
        NULL,                                   // Values
        0,                                      // RelationsCount
        NULL,                                   // Relations
        NULL,                                   // SupportHandler
        0                                       // SerializedSize
    ),
    DEFINE_KSPROPERTY_ITEM
    (
        KSPROPERTY_VIDEODECODER_OUTPUT_ENABLE,
        TRUE,                                   // GetSupported or Handler
        sizeof(KSPROPERTY_VIDEODECODER_S),      // MinProperty
        sizeof(KSPROPERTY_VIDEODECODER_S),      // MinData
        TRUE,                                   // SetSupported or Handler
        NULL,                                   // Values
        0,                                      // RelationsCount
        NULL,                                   // Relations
        NULL,                                   // SupportHandler
        0                                       // SerializedSize
    ),
    DEFINE_KSPROPERTY_ITEM
    (
        KSPROPERTY_VIDEODECODER_VCR_TIMING,
        TRUE,                                   // GetSupported or Handler
        sizeof(KSPROPERTY_VIDEODECODER_S),      // MinProperty
        sizeof(KSPROPERTY_VIDEODECODER_S),      // MinData
        TRUE,                                   // SetSupported or Handler
        NULL,                                   // Values
        0,                                      // RelationsCount
        NULL,                                   // Relations
        NULL,                                   // SupportHandler
        0                                       // SerializedSize
    ),
};

const ULONG AnalogVideoDecoder::NumProperties()
{
	return SIZEOF_ARRAY(AnalogVideoDecoderProperties); 
}

PKSPROPERTY_ITEM AnalogVideoDecoder::PropertyList()
{
	return (PKSPROPERTY_ITEM)AnalogVideoDecoderProperties;
}


////////////////////////////////////////////////////////////////////////
// VideoControl property table ... used in registration process
//	provide the characteristics of the VideoControl class back to the 
//	Stream Class Driver....

const KSPROPERTY_ITEM VideoControl::VideoControlProperties[] =
{
    DEFINE_KSPROPERTY_ITEM
    (
        KSPROPERTY_VIDEOCONTROL_CAPS,
        TRUE,                                   // GetSupported or Handler
        sizeof(KSPROPERTY_VIDEOCONTROL_CAPS_S), // MinProperty
        sizeof(KSPROPERTY_VIDEOCONTROL_CAPS_S), // MinData
        FALSE,                                  // SetSupported or Handler
        NULL,                                   // Values
        0,                                      // RelationsCount
        NULL,                                   // Relations
        NULL,                                   // SupportHandler
        0                                       // SerializedSize
    ),
    DEFINE_KSPROPERTY_ITEM
    (
        KSPROPERTY_VIDEOCONTROL_ACTUAL_FRAME_RATE,
        TRUE,                                   // GetSupported or Handler
        sizeof(KSPROPERTY_VIDEOCONTROL_ACTUAL_FRAME_RATE_S),      // MinProperty
        sizeof(KSPROPERTY_VIDEOCONTROL_ACTUAL_FRAME_RATE_S),      // MinData
        FALSE,                                  // SetSupported or Handler
        NULL,                                   // Values
        0,                                      // RelationsCount
        NULL,                                   // Relations
        NULL,                                   // SupportHandler
        0                                       // SerializedSize
    ),
    DEFINE_KSPROPERTY_ITEM
    (
        KSPROPERTY_VIDEOCONTROL_FRAME_RATES,
        TRUE,                                   // GetSupported or Handler