controls.cpp

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

        sizeof(KSPROPERTY),                     // MinProperty
        sizeof(KSMULTIPLE_ITEM),                // 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
    ),
};

const ULONG VideoControl::NumProperties()
{
	return SIZEOF_ARRAY(VideoControlProperties);
}

PKSPROPERTY_ITEM VideoControl::PropertyList()
{
	return (PKSPROPERTY_ITEM)VideoControlProperties;
}

////////////////////////////////////////////////////////////////////////
// Tuner::SetProperty

void Tuner::SetProperty(PHW_STREAM_REQUEST_BLOCK pSrb)
{
	PSTREAM_PROPERTY_DESCRIPTOR pSPD = pSrb->CommandData.PropertyInfo;
	ULONG Id = pSPD->Property->Id;              // index of the property
	ULONG nS = pSPD->PropertyOutputSize;        // size of data supplied

	switch (Id)
	{
	case KSPROPERTY_TUNER_MODE:
	{
		PKSPROPERTY_TUNER_MODE_S pMode =
			(PKSPROPERTY_TUNER_MODE_S)pSPD->Property;
		ASSERT (pMode->Mode == KSPROPERTY_TUNER_MODE_TV);

		break;
	}

	case KSPROPERTY_TUNER_STANDARD:
	{
		PKSPROPERTY_TUNER_STANDARD_S pStandard_S = 
			(PKSPROPERTY_TUNER_STANDARD_S) pSPD->Property;
		m_VideoStandard = pStandard_S->Standard;

		break;
	}

	case KSPROPERTY_TUNER_FREQUENCY:
	{
		PKSPROPERTY_TUNER_FREQUENCY_S pFreq_S = 
			(PKSPROPERTY_TUNER_FREQUENCY_S) pSPD->Property;
		m_Frequency = pFreq_S->Frequency;

		break;
	}

	case KSPROPERTY_TUNER_INPUT:
	{
		PKSPROPERTY_TUNER_INPUT_S pInput_S = 
			(PKSPROPERTY_TUNER_INPUT_S) pSPD->Property;

		m_Input = pInput_S->InputIndex;

		break;
	}

	default:
		ASSERT(FALSE);
	}
}

////////////////////////////////////////////////////////////////////////
// Tuner::GetProperty

void Tuner::GetProperty(PHW_STREAM_REQUEST_BLOCK pSrb)
{
	PSTREAM_PROPERTY_DESCRIPTOR pSPD = pSrb->CommandData.PropertyInfo;
	ULONG Id = pSPD->Property->Id;              // index of the property
	ULONG nS = pSPD->PropertyOutputSize;        // size of data supplied
	PVOID pV = pSPD->PropertyInfo;              // pointer to the output data

	ASSERT (nS >= sizeof (LONG));

	switch (Id)
	{
	case KSPROPERTY_TUNER_CAPS:
	{
		PKSPROPERTY_TUNER_CAPS_S pCaps =
			(PKSPROPERTY_TUNER_CAPS_S)pSPD->Property;
		ASSERT (nS >= sizeof( KSPROPERTY_TUNER_CAPS_S ) );

		 // now work with the output buffer
		pCaps =(PKSPROPERTY_TUNER_CAPS_S)pV;

		pCaps->ModesSupported = KSPROPERTY_TUNER_MODE_TV;
		pCaps->VideoMedium = TVTunerMediums[0];
		pCaps->TVAudioMedium = TVTunerMediums[1];
		pCaps->RadioAudioMedium = TVTunerMediums[2];   // No separate radio audio pin?

		pSrb->ActualBytesTransferred = sizeof( KSPROPERTY_TUNER_CAPS_S );

		break;
	}

	case KSPROPERTY_TUNER_MODE:
	{
		PKSPROPERTY_TUNER_MODE_S pMode =
			(PKSPROPERTY_TUNER_MODE_S)pSPD->Property;
		ASSERT (nS >= sizeof( KSPROPERTY_TUNER_MODE_S ) );

		// now work with the output buffer
		pMode =(PKSPROPERTY_TUNER_MODE_S)pV;

		pMode->Mode = KSPROPERTY_TUNER_MODE_TV;

		pSrb->ActualBytesTransferred = sizeof( KSPROPERTY_TUNER_MODE_S);

		break;
	}

	case KSPROPERTY_TUNER_MODE_CAPS:
	{
		PKSPROPERTY_TUNER_MODE_CAPS_S pCaps = 
				(PKSPROPERTY_TUNER_MODE_CAPS_S) pSPD->Property;

		ASSERT (nS >= sizeof (KSPROPERTY_TUNER_MODE_CAPS_S));
		ASSERT (pCaps->Mode == KSPROPERTY_TUNER_MODE_TV);
		
		// now work with the output buffer
		pCaps = (PKSPROPERTY_TUNER_MODE_CAPS_S) pV;

		//
		// List the formats actually supported by this tuner
		//

		pCaps->StandardsSupported =  

		KS_AnalogVideo_NTSC_M

				|  KS_AnalogVideo_PAL_B    
				|  KS_AnalogVideo_PAL_D    
			//  |  KS_AnalogVideo_PAL_H    
			//  |  KS_AnalogVideo_PAL_I    
				|  KS_AnalogVideo_PAL_M    
				|  KS_AnalogVideo_PAL_N    

			//  |  KS_AnalogVideo_SECAM_B  
			//  |  KS_AnalogVideo_SECAM_D  
			//  |  KS_AnalogVideo_SECAM_G  
			//  |  KS_AnalogVideo_SECAM_H  
			//  |  KS_AnalogVideo_SECAM_K  
			//  |  KS_AnalogVideo_SECAM_K1 
			//  |  KS_AnalogVideo_SECAM_L  
				;

			//
			// Get the min and max frequencies supported
			//

		pCaps->MinFrequency =  55250000L;
		pCaps->MaxFrequency = 997250000L;

		//
		// What is the frequency step size?
		//

		pCaps->TuningGranularity =  62500L;

		//
		// How many inputs are on the tuner?
		//

		pCaps->NumberOfInputs = 1;

		//
		// What is the maximum settling time in milliseconds?
		//

		pCaps->SettlingTime = 100;

		//
		// Strategy defines how the tuner knows when it is in tune:
		// 
		// KS_TUNER_STRATEGY_PLL (Has PLL offset information)
		// KS_TUNER_STRATEGY_SIGNAL_STRENGTH (has signal strength info)
		// KS_TUNER_STRATEGY_DRIVER_TUNES (driver handles all fine tuning)
		//

		pCaps->Strategy = KS_TUNER_STRATEGY_DRIVER_TUNES;

		pSrb->ActualBytesTransferred = sizeof (KSPROPERTY_TUNER_MODE_CAPS_S);

		break;
	}
		
	case KSPROPERTY_TUNER_STANDARD:
	{
		// What is the currently selected video standard?

		((PKSPROPERTY_TUNER_STANDARD_S) pSPD->PropertyInfo)->Standard =
				m_VideoStandard;

		pSrb->ActualBytesTransferred = sizeof (KSPROPERTY_TUNER_STANDARD_S);

		break;
	}

	case KSPROPERTY_TUNER_INPUT:
	{
		// What is the currently selected input?

		((PKSPROPERTY_TUNER_INPUT_S) pSPD->PropertyInfo)->InputIndex = 
				m_Input;

		pSrb->ActualBytesTransferred = sizeof (PKSPROPERTY_TUNER_INPUT_S);

		break;
	}


	case KSPROPERTY_TUNER_STATUS:
	{
		// Return the status of the tuner

		// PLLOffset is in units of TuningGranularity 
		// SignalStrength is 0 to 100
		// Set Busy to 1 if tuning is still in process

		PKSPROPERTY_TUNER_STATUS_S pStatus = 
			(PKSPROPERTY_TUNER_STATUS_S) pSPD->PropertyInfo;

		ASSERT (nS >= sizeof (KSPROPERTY_TUNER_STATUS_S));
		pStatus->CurrentFrequency = m_Frequency;
		pStatus->PLLOffset = 0;
		pStatus->SignalStrength = 100;
		pStatus->Busy = m_Busy;

		pSrb->ActualBytesTransferred = sizeof (KSPROPERTY_TUNER_STATUS_S);

		break;
	}

	default:
		ASSERT(FALSE);
	}
}

////////////////////////////////////////////////////////////////////////
// Crossbar::SetProperty

void Crossbar::SetProperty(PHW_STREAM_REQUEST_BLOCK pSrb)
{
	PSTREAM_PROPERTY_DESCRIPTOR pSPD = pSrb->CommandData.PropertyInfo;
	ULONG Id  = pSPD->Property->Id;              // index of the property
	ULONG nS  = pSPD->PropertyOutputSize;        // size of data supplied

	switch (Id)
	{
	case KSPROPERTY_CROSSBAR_ROUTE:
	{
		PKSPROPERTY_CROSSBAR_ROUTE_S  pRoute = 
			(PKSPROPERTY_CROSSBAR_ROUTE_S)pSPD->PropertyInfo;   

		ASSERT (nS >= sizeof (KSPROPERTY_CROSSBAR_ROUTE_S));

		// Copy the input property info to the output property info
		RtlCopyMemory(  pRoute, 
						pSPD->Property, 
						sizeof (KSPROPERTY_CROSSBAR_ROUTE_S));

		// BUGBUG, this should check for legality of request, 
		// ie. that video pin isn't being routed to an audio pin, etc.

		if ((pRoute->IndexInputPin < NumberOfXBarInputs()) &&
			(pRoute->IndexOutputPin < NumberOfXBarOutputs())) {
				m_InputConnected = pRoute->IndexInputPin;
				pRoute->CanRoute = 1;
		}
		else
			pRoute->CanRoute = 0;

		break;
	}

	default:
		ASSERT (FALSE);
		break;
	}
}

////////////////////////////////////////////////////////////////////////
// Crossbar::GetProperty

void Crossbar::GetProperty(PHW_STREAM_REQUEST_BLOCK pSrb)
{
	PSTREAM_PROPERTY_DESCRIPTOR pSPD = pSrb->CommandData.PropertyInfo;
	ULONG Id  = pSPD->Property->Id;              // index of the property
	ULONG nS  = pSPD->PropertyOutputSize;        // size of data supplied

	switch (Id)
	{
	case KSPROPERTY_CROSSBAR_CAPS:                  // R 
	{
		PKSPROPERTY_CROSSBAR_CAPS_S  pCaps = 
			(PKSPROPERTY_CROSSBAR_CAPS_S)pSPD->PropertyInfo;   

		if (nS < sizeof (KSPROPERTY_CROSSBAR_CAPS_S))
			break;

		// Copy the input property info to the output property info
		RtlCopyMemory(pCaps, pSPD->Property, sizeof (KSPROPERTY_CROSSBAR_CAPS_S));

		pCaps->NumberOfInputs  = NumberOfXBarInputs();
		pCaps->NumberOfOutputs = NumberOfXBarOutputs();

		pSrb->ActualBytesTransferred = sizeof (KSPROPERTY_CROSSBAR_CAPS_S);

		break;
	}

	case KSPROPERTY_CROSSBAR_CAN_ROUTE:                   // R 
	{
		PKSPROPERTY_CROSSBAR_ROUTE_S  pRoute = 
			(PKSPROPERTY_CROSSBAR_ROUTE_S)pSPD->PropertyInfo;   

		if (nS < sizeof (KSPROPERTY_CROSSBAR_ROUTE_S))
			break;

		// Copy the input property info to the output property info
		RtlCopyMemory(pRoute, pSPD->Property, sizeof (KSPROPERTY_CROSSBAR_ROUTE_S));

		// Sanity check
		if ((pRoute->IndexInputPin  >= NumberOfXBarInputs()) ||
			(pRoute->IndexOutputPin >= NumberOfXBarOutputs()))
			pRoute->CanRoute = FALSE;
					
		else if ((pRoute->IndexInputPin <= 4) &&
			(pRoute->IndexOutputPin == 0) ||
			(pRoute->IndexInputPin >= 5) &&
			(pRoute->IndexOutputPin == 1))
		{
			// This driver allows any video input to connect to any video output
			// and any audio input to connect to any audio output
			pRoute->CanRoute = TRUE;
		}
		else
			pRoute->CanRoute = FALSE;

		pSrb->ActualBytesTransferred = sizeof (KSPROPERTY_CROSSBAR_ROUTE_S);

		break;
	}

	case KSPROPERTY_CROSSBAR_PININFO:                     // R
	{ 
		PKSPROPERTY_CROSSBAR_PININFO_S  pPinInfo = 
			(PKSPROPERTY_CROSSBAR_PININFO_S)pSPD->PropertyInfo;   

		if (nS < sizeof (KSPROPERTY_CROSSBAR_PININFO_S))
			break;

		// Copy the input property info to the output property info
		RtlCopyMemory(pPinInfo, pSPD->Property, sizeof (KSPROPERTY_CROSSBAR_PININFO_S));

		if (pPinInfo->Direction == KSPIN_DATAFLOW_IN)
		{
			ASSERT (pPinInfo->Index < NumberOfXBarInputs());

			pPinInfo->PinType          = XBarInputPins[pPinInfo->Index].PinType;
			pPinInfo->RelatedPinIndex  = XBarInputPins[pPinInfo->Index].RelatedPinIndex;
			pPinInfo->Medium           = *XBarInputPins[pPinInfo->Index].Medium;
		}
		else
		{
			ASSERT (pPinInfo->Index < NumberOfXBarOutputs());

			pPinInfo->PinType          = XBarOutputPins[pPinInfo->Index].PinType;
			pPinInfo->RelatedPinIndex  = XBarOutputPins[pPinInfo->Index].RelatedPinIndex;
			pPinInfo->Medium           = *XBarOutputPins[pPinInfo->Index].Medium;
		}

		pSrb->ActualBytesTransferred = sizeof (KSPROPERTY_CROSSBAR_PININFO_S);

		break;
	}

	case KSPROPERTY_CROSSBAR_ROUTE:                   // R 
	{
		PKSPROPERTY_CROSSBAR_ROUTE_S  pRoute = 
			(PKSPROPERTY_CROSSBAR_ROUTE_S)pSPD->PropertyInfo;   

		if (nS < sizeof (KSPROPERTY_CROSSBAR_ROUTE_S))
			break;

		// Copy the input property info to the output property info
		RtlCopyMemory(pRoute, pSPD->Property, sizeof (KSPROPERTY_CROSSBAR_ROUTE_S));

		// Sanity check
		if (pRoute->IndexOutputPin >= NumberOfXBarOutputs())
			pRoute->CanRoute = FALSE;
				
		else
		{
			pRoute->IndexInputPin = m_InputConnected;
			pRoute->CanRoute = TRUE;
		}

		pSrb->ActualBytesTransferred = sizeof (KSPROPERTY_CROSSBAR_ROUTE_S);

		break;
	}

	default:
		ASSERT(FALSE);
	}
}

////////////////////////////////////////////////////////////////////////
// VideoProcAmp::SetProperty

void VideoProcAmp::SetProperty(PHW_STREAM_REQUEST_BLOCK pSrb)
{
	PSTREAM_PROPERTY_DESCRIPTOR pSPD = pSrb->CommandData.PropertyInfo;
	ULONG Id = pSPD->Property->Id;              // index of the property