prpobj.c

winddk src目录下的WDM源码压缩!

/*++

Copyright (c) 1998  Microsoft Corporation

Module Name:

   prpobj.c

Abstract:

   Code related to "getting"  about properties 

Author:

Notes:

  THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY
  KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR
  PURPOSE.

Environment:

   Kernel mode only


Revision History:

--*/

#include "warn.h"
#include "wdm.h"
#include <strmini.h>
#include <ksmedia.h>
#include "usbdi.h"
#include "usbcamdi.h"
#include "intelcam.h"
#include "prpobj.h"


extern const GUID PROPSETID_CUSTOM_PROP = 
    {0x3dc2e820, 0x4713, 0x11d2, {0xba, 0x41, 0x0, 0xa0, 0xc9, 0xd, 0x2b, 0x5}};


//
// Registry subky and values wide character strings.
//
WCHAR wszSettings[]     = L"Settings";
WCHAR wszBrightness[]   = L"Brightness";
WCHAR wszContrast[]     = L"Contrast";
WCHAR wszSaturation[]   = L"Saturation";
WCHAR wszSharpness[]    = L"Sharpness";
WCHAR wszWhiteBalance[] = L"WhiteBalance";


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

// ------------------------------------------------------------------------
KSPROPERTY_STEPPING_LONG BrightnessRangeAndStep [] = 
{
    {
        STEPPING_DELTA_BRIGHTNESS,   // SteppingDelta
        0,                           // Reserved
        0,                           // Minimum in (IRE * 100) units
        MAX_BRIGHTNESS_IRE_UNITS     // Maximum in (IRE * 100) units
    }
};

const LONG BrightnessDefault = (5 * STEPPING_DELTA_BRIGHTNESS); 

KSPROPERTY_MEMBERSLIST BrightnessMembersList [] = 
{
    {
        {
            KSPROPERTY_MEMBER_STEPPEDRANGES,
            sizeof (BrightnessRangeAndStep),
            SIZEOF_ARRAY (BrightnessRangeAndStep),
            0
        },
		(PVOID) BrightnessRangeAndStep,
	},


    {
        {
            KSPROPERTY_MEMBER_VALUES,
            sizeof (BrightnessDefault),
            1,
            KSPROPERTY_MEMBER_FLAG_DEFAULT
        },
        (PVOID) &BrightnessDefault
	}


};

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


////////////
////
////   SHARPNESS
////
////////////

KSPROPERTY_STEPPING_LONG SharpnessRangeAndStep [] = 
{
    {
        STEPPING_DELTA_ENHANCEMENT,       // SteppingDelta
        0,                                // Reserved
        0,                                // Minimum 
        MAX_ENHANCEMENT_MISC_UNITS        // Maximum 
    }
};

const LONG SharpnessDefault = (7 * STEPPING_DELTA_ENHANCEMENT); 

KSPROPERTY_MEMBERSLIST SharpnessMembersList [] = 
{
    {
        {
            KSPROPERTY_MEMBER_STEPPEDRANGES,
            sizeof (SharpnessRangeAndStep),
            SIZEOF_ARRAY (SharpnessRangeAndStep),
            0
        },
        (PVOID) SharpnessRangeAndStep
    },
	
    {
        {
            KSPROPERTY_MEMBER_VALUES,
            sizeof (SharpnessDefault),
            1,
            KSPROPERTY_MEMBER_FLAG_DEFAULT
        },
        (PVOID) &SharpnessDefault
	}

};

KSPROPERTY_VALUES SharpnessValues =
{
    {
        STATICGUIDOF (KSPROPTYPESETID_General),
        VT_I4,
        0
    },
    SIZEOF_ARRAY (SharpnessMembersList),
    SharpnessMembersList
};


////////////
////
////   SATURATION
////
////////////

KSPROPERTY_STEPPING_LONG SaturationRangeAndStep [] = 
{
    {
        STEPPING_DELTA_SATURATION,        // SteppingDelta
        0,                                // Reserved
        0,                                // Minimum 
        MAX_SATURATION_MISC_UNITS         // Maximum 
    }
};

const LONG SaturationDefault = (7 * STEPPING_DELTA_SATURATION); 

KSPROPERTY_MEMBERSLIST SaturationMembersList [] = 
{
    {
        {
            KSPROPERTY_MEMBER_STEPPEDRANGES,
            sizeof (SaturationRangeAndStep),
            SIZEOF_ARRAY (SaturationRangeAndStep),
            0
        },
        (PVOID) SaturationRangeAndStep
    },

    {
        {
            KSPROPERTY_MEMBER_VALUES,
            sizeof (SaturationDefault),
            1,
            KSPROPERTY_MEMBER_FLAG_DEFAULT
        },
        (PVOID) &SaturationDefault
	}

};

KSPROPERTY_VALUES SaturationValues =
{
    {
        STATICGUIDOF (KSPROPTYPESETID_General),
        VT_I4,
        0
    },
    SIZEOF_ARRAY (SaturationMembersList),
    SaturationMembersList
};


////////////
////
////   CONTRAST (EXPOSURE_COMPENSATION )
////
////////////

KSPROPERTY_STEPPING_LONG ContrastRangeAndStep [] = 
{
    {
        STEPPING_DELTA_CONTRAST,          // SteppingDelta
        0,                                // Reserved
        0,                                // Minimum 
        MAX_CONTRAST_MISC_UNITS           // Maximum 
    }
};

const LONG ContrastDefault = (4 * STEPPING_DELTA_CONTRAST); 

KSPROPERTY_MEMBERSLIST ContrastMembersList [] = 
{
    {
        {
            KSPROPERTY_MEMBER_STEPPEDRANGES,
            sizeof (ContrastRangeAndStep),
            SIZEOF_ARRAY (ContrastRangeAndStep),
            0
        },
        (PVOID) ContrastRangeAndStep
    },    

    {
        {
            KSPROPERTY_MEMBER_VALUES,
            sizeof (ContrastDefault),
            1,
            KSPROPERTY_MEMBER_FLAG_DEFAULT
        },
        (PVOID) &ContrastDefault
	}

};

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


////////////
////
////   WHITEBALANCE
////
////////////

KSPROPERTY_STEPPING_LONG WhiteBalanceRangeAndStep [] = 
{
    {
        STEPPING_DELTA_WHITEBALANCE,    // SteppingDelta
        0,                              // Reserved
        0,                              // Minimum 
        MAX_WHITEBALANCE_MISC_UNITS     // Maximum 
    }
};

const LONG WhiteBalanceDefault = (23 * STEPPING_DELTA_WHITEBALANCE); 

KSPROPERTY_MEMBERSLIST WhiteBalanceMembersList [] = 
{
    {
        {
            KSPROPERTY_MEMBER_STEPPEDRANGES,
            sizeof (WhiteBalanceRangeAndStep),
            SIZEOF_ARRAY (WhiteBalanceRangeAndStep),
            0
        },
        (PVOID) WhiteBalanceRangeAndStep
    },    

    {
        {
            KSPROPERTY_MEMBER_VALUES,
            sizeof (WhiteBalanceDefault),
            1,
            KSPROPERTY_MEMBER_FLAG_DEFAULT
        },
        (PVOID) &WhiteBalanceDefault
	}

};

KSPROPERTY_VALUES WhiteBalanceValues =
{
    {
        STATICGUIDOF (KSPROPTYPESETID_General),
        VT_I4,
        0
    },
    SIZEOF_ARRAY (WhiteBalanceMembersList),
    WhiteBalanceMembersList
};

// ------------------------------------------------------------------------
DEFINE_KSPROPERTY_TABLE(VideoProcAmpProperties)
{
    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
    ),
    
    DEFINE_KSPROPERTY_ITEM
    (
        KSPROPERTY_VIDEOPROCAMP_SHARPNESS,
        TRUE,                                   // GetSupported or Handler
        sizeof(KSPROPERTY_VIDEOPROCAMP_S),      // MinProperty
        sizeof(KSPROPERTY_VIDEOPROCAMP_S),      // MinData
        TRUE,                                   // SetSupported or Handler
        &SharpnessValues,                     // Values
        0,                                      // RelationsCount
        NULL,                                   // Relations
        NULL,                                   // SupportHandler
        sizeof(ULONG)                           // SerializedSize
    ),

    DEFINE_KSPROPERTY_ITEM
    (
        KSPROPERTY_VIDEOPROCAMP_SATURATION,
        TRUE,                                   // GetSupported or Handler
        sizeof(KSPROPERTY_VIDEOPROCAMP_S),      // MinProperty
        sizeof(KSPROPERTY_VIDEOPROCAMP_S),      // MinData
        TRUE,                                   // SetSupported or Handler
        &SaturationValues,                      // Values
        0,                                      // RelationsCount
        NULL,                                   // Relations
        NULL,                                   // SupportHandler
        sizeof(ULONG)                           // SerializedSize
    ),
    
    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_WHITEBALANCE,
        TRUE,                                   // GetSupported or Handler
        sizeof(KSPROPERTY_VIDEOPROCAMP_S),      // MinProperty
        sizeof(KSPROPERTY_VIDEOPROCAMP_S),      // MinData
        TRUE,                                   // SetSupported or Handler
        &WhiteBalanceValues,                    // Values
        0,                                      // RelationsCount
        NULL,                                   // Relations
        NULL,                                   // SupportHandler
        sizeof(ULONG)                           // SerializedSize
    )
};



DEFINE_KSPROPERTY_TABLE(CustomProperties)
{
    DEFINE_KSPROPERTY_ITEM
    (
        KSPROPERTY_CUSTOM_PROP_FIRMWARE_VER,    // PropertyId
        TRUE,                                   // GetSupported or Handler
        sizeof(KSPROPERTY_CUSTOM_PROP_S),       // MinProperty
        sizeof(KSPROPERTY_CUSTOM_PROP_S),       // MinData
        FALSE,                                  // SetSupported or Handler
        NULL,                                   // Values
        0,                                      // RelationsCount
        NULL,                                   // Relations
        NULL,                                   // SupportHandler
        sizeof(ULONG)                           // SerializedSize
    )
};