prpobj.c

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

DEFINE_KSPROPERTY_TABLE(FrameRateProperties)
{
    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
        sizeof(KSPROPERTY_VIDEOCONTROL_FRAME_RATES_S),    // MinProperty
        0 ,                                     // MinData
        FALSE,                                  // SetSupported or Handler
        NULL,                                   // Values
        0,                                      // RelationsCount
        NULL,                                   // Relations
        NULL,                                   // SupportHandler
        0                                       // SerializedSize
    ),

    DEFINE_KSPROPERTY_ITEM
    (
        KSPROPERTY_VIDEOCONTROL_MODE,
        TRUE,                                   // GetSupported or Handler
        sizeof(KSPROPERTY_VIDEOCONTROL_MODE_S), // MinProperty
        sizeof(KSPROPERTY_VIDEOCONTROL_MODE_S), // MinData
        TRUE,                                   // SetSupported or Handler
        NULL,                                   // Values
        0,                                      // RelationsCount
        NULL,                                   // Relations
        NULL,                                   // SupportHandler
        0                                       // SerializedSize
    ),

};
    

//
// All of the property sets supported by the adapter
//

DEFINE_KSPROPERTY_SET_TABLE(AdapterPropertyTable)
{

   DEFINE_KSPROPERTY_SET
    ( 
        &PROPSETID_CUSTOM_PROP,                   // Set
        SIZEOF_ARRAY(CustomProperties),           // PropertiesCount
        CustomProperties,                         // PropertyItem
        0,                                        // FastIoCount
        NULL                                      // FastIoTable
    ),
   
    DEFINE_KSPROPERTY_SET
    ( 
        &PROPSETID_VIDCAP_VIDEOPROCAMP,                 // Set
        SIZEOF_ARRAY(VideoProcAmpProperties),           // PropertiesCount
        VideoProcAmpProperties,                         // PropertyItem
        0,                                              // FastIoCount
        NULL                                            // FastIoTable
    ),

    DEFINE_KSPROPERTY_SET
    ( 
        &PROPSETID_VIDCAP_VIDEOCONTROL,           // Set
        SIZEOF_ARRAY(FrameRateProperties),        // PropertiesCount
        FrameRateProperties,                      // PropertyItem
        0,                                        // FastIoCount
        NULL                                      // FastIoTable
    )

};


#define NUMBER_OF_ADAPTER_PROPERTY_SETS (SIZEOF_ARRAY (AdapterPropertyTable))


//
// Format/resolution combinations.  The first resolution under
// each format is the default.
//
static const FORMAT _Format[] =
{
    { FCC_FORMAT_YUV12N, 176,144 },
    { FCC_FORMAT_YUV12N, 320,240 },
    {(FOURCC)-1, -1,-1 }
};

//
// Frame rates.
//
static const ULONG _Rate[] =
{
    1000000/25,                     // Default
    0,                              // Zero
    1000000/6,
    1000000/10,
    1000000/12,
    1000000/15,
    1000000/18,
    1000000/20,
    (ULONG)-1
};


/*
** INTELCAM_GetStreamPropertiesArray()
**
** Returns the stream class defined properties fror the camera
**
**  see stream class documentation
**
** Arguments:
**
** DeviceContext - camera specific context
**
** NumberOfArrayEntries - pointer to ulong , should be filled
**      in with the number of elements in the array returned.
**
** Returns:
**
** Side Effects:  none
*/

PVOID   
INTELCAM_GetAdapterPropertyTable(
    PULONG NumberOfArrayEntries
    )
{

    INTELCAM_KdPrint (MAX_TRACE, ("GetStreamFormatsArray\n")); 
    
    *NumberOfArrayEntries = NUMBER_OF_ADAPTER_PROPERTY_SETS;
    
    return (PVOID) AdapterPropertyTable;
}




NTSTATUS
FormPropertyData(
    IN OUT PHW_STREAM_REQUEST_BLOCK pSrb,
    IN PVOID pData,
	IN REQUEST ReqID
    )
{

	PSTREAM_PROPERTY_DESCRIPTOR pSPD = pSrb->CommandData.PropertyInfo;
    
    switch( ReqID )
	{
        case REQ_BRIGHTNESS:
        case REQ_WHITEBALANCE:
        case REQ_ENHANCEMENT:
        case REQ_EXPOSURE:
        case REQ_SATURATION:
		{
            PKSPROPERTY_VIDEOPROCAMP_S pPropertyInfo =
                (PKSPROPERTY_VIDEOPROCAMP_S)pSPD->PropertyInfo;

            pSrb->ActualBytesTransferred = sizeof (KSPROPERTY_VIDEOPROCAMP_S);

			RtlZeroMemory(pPropertyInfo, sizeof(KSPROPERTY_VIDEOPROCAMP_S));

			pPropertyInfo->Flags = KSPROPERTY_VIDEOPROCAMP_FLAGS_MANUAL;
			pPropertyInfo->Capabilities = KSPROPERTY_VIDEOPROCAMP_FLAGS_MANUAL; // no Auto mode

			if(pData)
				pPropertyInfo->Value = *(WORD *)pData;
			else
				return STATUS_NO_MEMORY;

			return STATUS_SUCCESS;
		}

		default:
		   return STATUS_NOT_SUPPORTED;
	}

}


/*
** GetPropertyCurrent()
**
** Arguments:
**
**  pDC - driver context
**
** Returns:
**
**  BOOLEAN 
**  
** Side Effects:  none
*/
BOOLEAN
GetPropertyCurrent(
    IN PINTELCAM_DEVICE_CONTEXT pDC,
    OUT PVOID pProperty,
    IN REQUEST ReqID
    )
/*++
    Routine Description:
    Arguments:
    Return Value:
--*/
{
    NTSTATUS Status = STATUS_NOT_SUPPORTED;

    ASSERT(pDC);
    ASSERT(pProperty);         

    switch ( ReqID )
    {
        case REQ_BRIGHTNESS:
            *((LONG*)pProperty) = pDC->CurrentProperty.Brightness;
            break;
        
        case REQ_ENHANCEMENT:
            *((LONG*)pProperty) = pDC->CurrentProperty.Sharpness;
            break;

        case REQ_EXPOSURE:
            *((LONG*)pProperty) = pDC->CurrentProperty.Contrast;
            break;

        case REQ_SATURATION:
            *((LONG*)pProperty) = pDC->CurrentProperty.Saturation;
            break;

        case REQ_WHITEBALANCE:
            *((LONG*)pProperty) = pDC->CurrentProperty.WhiteBalance;
            break;
        INTELCAM_KdPrint(MAX_TRACE, ("PROP: Getting Curr property - %d\n",  *((ULONG*)pProperty) ));
    }

    return TRUE;

}


NTSTATUS 
CreateRegistryKeySingle(
    IN HANDLE hKey,
    IN ACCESS_MASK desiredAccess,
    PWCHAR pwszSection,
    OUT PHANDLE phKeySection
    )
{
    NTSTATUS status;
    UNICODE_STRING ustr;
    OBJECT_ATTRIBUTES objectAttributes;

    RtlInitUnicodeString(&ustr, pwszSection);
	   InitializeObjectAttributes(
		      &objectAttributes,
		      &ustr,
		      OBJ_CASE_INSENSITIVE,
		      hKey,
		      NULL
		      );

    status = 
	       ZwCreateKey(
		          phKeySection,
		          desiredAccess,
		          &objectAttributes,
		          0,
		          NULL,				            /* optional*/
		          REG_OPTION_NON_VOLATILE,
		          NULL
		          );         

    return status;
}



NTSTATUS 
CreateRegistrySubKey(
    IN HANDLE hKey,
    IN ACCESS_MASK desiredAccess,
    PWCHAR pwszSection,
    OUT PHANDLE phKeySection
    )
{
    UNICODE_STRING ustr;
    USHORT usPos = 1;             // Skip first backslash
    static WCHAR wSep = '\\';
    NTSTATUS status = STATUS_SUCCESS;

    RtlInitUnicodeString(&ustr, pwszSection);

    while(usPos < ustr.Length) {
        if(ustr.Buffer[usPos] == wSep) {

            // NULL terminate our partial string
            ustr.Buffer[usPos] = UNICODE_NULL;
            status = 
                CreateRegistryKeySingle(
                    hKey,
                    desiredAccess,
                    ustr.Buffer,
                    phKeySection
                    );
            ustr.Buffer[usPos] = wSep;

            if(NT_SUCCESS(status)) {
                ZwClose(*phKeySection);
            } else {
                break;
            }
        }
        usPos++;
    }

    // Create the full key
    if(NT_SUCCESS(status)) {
        status = 
            CreateRegistryKeySingle(
                 hKey,
                 desiredAccess,
                 ustr.Buffer,
                 phKeySection
                 );
    }

    return status;
}


NTSTATUS 
GetRegistryKeyValue (
    IN HANDLE Handle,
    IN PWCHAR KeyNameString,
    IN ULONG KeyNameStringLength,
    IN PVOID Data,
    IN PULONG DataLength
    )

/*++

Routine Description:
    
    This routine gets the specified value out of the registry

Arguments:

    Handle - Handle to location in registry

    KeyNameString - registry key we're looking for

    KeyNameStringLength - length of registry key we're looking for

    Data - where to return the data

    DataLength - how big the data is

Return Value:

    status is returned from ZwQueryValueKey

--*/

{
    NTSTATUS status = STATUS_INSUFFICIENT_RESOURCES;
    UNICODE_STRING keyName;
    ULONG length;
    PKEY_VALUE_FULL_INFORMATION fullInfo;


    RtlInitUnicodeString(&keyName, KeyNameString);
    
    length = sizeof(KEY_VALUE_FULL_INFORMATION) + 
            KeyNameStringLength + *DataLength;
            
    fullInfo = ExAllocatePool(PagedPool, length); 
     
    if (fullInfo) { 
       
        status = ZwQueryValueKey(
                    Handle,
                   &keyName,
                    KeyValueFullInformation,
                    fullInfo,
                    length,
                   &length
                    );
                        
        if (NT_SUCCESS(status)){

            if (fullInfo->DataLength == *DataLength) {