controls.cpp

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

	PKSPROPERTY_VIDEOPROCAMP_S pS = (PKSPROPERTY_VIDEOPROCAMP_S) pSPD->PropertyInfo;

	ASSERT (pSPD->PropertyInputSize >= sizeof (KSPROPERTY_VIDEOPROCAMP_S));

	switch (Id)
	{
	case KSPROPERTY_VIDEOPROCAMP_BRIGHTNESS:
		m_Brightness = pS->Value;
		m_BrightnessFlags = pS->Flags;
		break;
		
	case KSPROPERTY_VIDEOPROCAMP_CONTRAST:
		m_Contrast = pS->Value;
		m_ContrastFlags = pS->Flags;
		break;

	default:
		ASSERT(FALSE);
	}
}

////////////////////////////////////////////////////////////////////////
// VideoProcAmp::GetProperty

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

	ASSERT (pSPD->PropertyOutputSize >= sizeof (KSPROPERTY_VIDEOPROCAMP_S));

	switch (Id)
	{
	case KSPROPERTY_VIDEOPROCAMP_BRIGHTNESS:
		pS->Value = m_Brightness;
		pS->Flags = m_BrightnessFlags;
		pS->Capabilities = KSPROPERTY_VIDEOPROCAMP_FLAGS_MANUAL | 
						   KSPROPERTY_VIDEOPROCAMP_FLAGS_AUTO;
		break;
		
	case KSPROPERTY_VIDEOPROCAMP_CONTRAST:
		pS->Value = m_Contrast;
		pS->Flags = m_ContrastFlags;
		pS->Capabilities = KSPROPERTY_VIDEOPROCAMP_FLAGS_MANUAL | 
						   KSPROPERTY_VIDEOPROCAMP_FLAGS_AUTO;
		break;

	default:
		ASSERT(FALSE);
	}

	pSrb->ActualBytesTransferred = sizeof (KSPROPERTY_VIDEOPROCAMP_S);
}



////////////////////////////////////////////////////////////////////////
// CameraControl::SetProperty

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

	ASSERT (pSPD->PropertyInputSize >= sizeof (KSPROPERTY_CAMERACONTROL_S));

	switch (Id)
	{
	case KSPROPERTY_CAMERACONTROL_ZOOM:
		m_Zoom = pS->Value;
		m_ZoomFlags = pS->Flags;
		break;
		
	case KSPROPERTY_CAMERACONTROL_FOCUS:
		m_Focus = pS->Value;
		m_FocusFlags = pS->Flags;
		break;

	default:
		ASSERT(FALSE);
	}
}


////////////////////////////////////////////////////////////////////////
// CameraControl::SetProperty

void CameraControl::GetProperty(PHW_STREAM_REQUEST_BLOCK pSrb)
{
	PSTREAM_PROPERTY_DESCRIPTOR pSPD = pSrb->CommandData.PropertyInfo;
	ULONG Id = pSPD->Property->Id;              // index of the property
	PKSPROPERTY_CAMERACONTROL_S pS = (PKSPROPERTY_CAMERACONTROL_S) pSPD->PropertyInfo;    // pointer to the output data

	ASSERT (pSPD->PropertyOutputSize >= sizeof (KSPROPERTY_CAMERACONTROL_S));

	switch (Id)
	{
	case KSPROPERTY_CAMERACONTROL_ZOOM:
		pS->Value = m_Zoom;
		pS->Flags = m_ZoomFlags;
		pS->Capabilities = KSPROPERTY_CAMERACONTROL_FLAGS_MANUAL | 
						   KSPROPERTY_CAMERACONTROL_FLAGS_AUTO;
		break;
		
	case KSPROPERTY_CAMERACONTROL_FOCUS:
		pS->Value = m_Focus;
		pS->Flags = m_FocusFlags;
		pS->Capabilities = KSPROPERTY_CAMERACONTROL_FLAGS_MANUAL | 
						   KSPROPERTY_CAMERACONTROL_FLAGS_AUTO;
		break;

	default:
		ASSERT(FALSE);
	}
	pSrb->ActualBytesTransferred = sizeof (KSPROPERTY_CAMERACONTROL_S);
}


////////////////////////////////////////////////////////////////////////
// AudioControl::SetProperty

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


	switch (Id)
	{
	case KSPROPERTY_TVAUDIO_MODE:
	{
		PKSPROPERTY_TVAUDIO_S pS = (PKSPROPERTY_TVAUDIO_S) pSPD->PropertyInfo;    

		m_Mode = pS->Mode;

		break;
	}

	default:
		ASSERT(FALSE);
	}
}

////////////////////////////////////////////////////////////////////////
// AudioControl::GetProperty

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

	switch (Id) {

	case KSPROPERTY_TVAUDIO_CAPS:
	{
		PKSPROPERTY_TVAUDIO_CAPS_S pS = (PKSPROPERTY_TVAUDIO_CAPS_S) pSPD->PropertyInfo;    // pointer to the data

		ASSERT (pSPD->PropertyOutputSize >= sizeof (KSPROPERTY_TVAUDIO_CAPS_S));
		
		pS->InputMedium  = TVAudioMediums[0];
		pS->OutputMedium = TVAudioMediums[1];
		// Report all of the possible audio decoding modes the hardware is capabable of
		pS->Capabilities = KS_TVAUDIO_MODE_MONO   |
						   KS_TVAUDIO_MODE_STEREO |
						   KS_TVAUDIO_MODE_LANG_A |
						   KS_TVAUDIO_MODE_LANG_B ;

		pSrb->ActualBytesTransferred = sizeof (KSPROPERTY_TVAUDIO_CAPS_S);

		break;
	}
		
	case KSPROPERTY_TVAUDIO_MODE:
	{
		PKSPROPERTY_TVAUDIO_S pS = (PKSPROPERTY_TVAUDIO_S) pSPD->PropertyInfo;    // pointer to the data

		ASSERT (pSPD->PropertyOutputSize >= sizeof (KSPROPERTY_TVAUDIO_S));
		// Report the currently selected mode
		pS->Mode = m_Mode;

		pSrb->ActualBytesTransferred = sizeof (KSPROPERTY_TVAUDIO_S);

		break;
	}

	case KSPROPERTY_TVAUDIO_CURRENTLY_AVAILABLE_MODES:
	{
		PKSPROPERTY_TVAUDIO_S pS = (PKSPROPERTY_TVAUDIO_S) pSPD->PropertyInfo;    // pointer to the data

		ASSERT (pSPD->PropertyOutputSize >= sizeof (KSPROPERTY_TVAUDIO_S));
		// Report which audio modes could potentially be selected right now
		pS->Mode = KS_TVAUDIO_MODE_MONO   |
				   KS_TVAUDIO_MODE_STEREO |
				   KS_TVAUDIO_MODE_LANG_A ;

		pSrb->ActualBytesTransferred = sizeof (KSPROPERTY_TVAUDIO_S);

		break;
	}
	
	default:
		ASSERT(FALSE);
	}
}


////////////////////////////////////////////////////////////////////////
// AnalogVideoDecoder::SetProperty

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

	ASSERT (pSPD->PropertyInputSize >= sizeof (KSPROPERTY_VIDEODECODER_S));
	
	switch (Id) 
	{
	case KSPROPERTY_VIDEODECODER_STANDARD:
		m_VideoStandard = pS->Value;
		break;

	case KSPROPERTY_VIDEODECODER_OUTPUT_ENABLE:
		m_OutputEnable = pS->Value;
		break;

	case KSPROPERTY_VIDEODECODER_VCR_TIMING:
		m_VCRTiming = pS->Value;
		break;

	default:
		ASSERT(FALSE);
	}
}


////////////////////////////////////////////////////////////////////////
// AnalogVideoDecoder::GetProperty

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

	switch (Id) {

	case KSPROPERTY_VIDEODECODER_CAPS:
	{
		PKSPROPERTY_VIDEODECODER_CAPS_S pS = (PKSPROPERTY_VIDEODECODER_CAPS_S) pSPD->PropertyInfo;    // pointer to the data

		ASSERT (pSPD->PropertyOutputSize >= sizeof (KSPROPERTY_VIDEODECODER_CAPS_S));
		
		pS->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  
				   ;

		pS->Capabilities = KS_VIDEODECODER_FLAGS_CAN_DISABLE_OUTPUT  |
						   KS_VIDEODECODER_FLAGS_CAN_USE_VCR_LOCKING |
						   KS_VIDEODECODER_FLAGS_CAN_INDICATE_LOCKED ;


		pS->SettlingTime = 10;          // How long to delay after tuning before 
										// Locked indicator is valid
										
		pS->HSyncPerVSync = 6;          // HSync per VSync

		pSrb->ActualBytesTransferred = sizeof (KSPROPERTY_VIDEODECODER_CAPS_S);
	}
	break;
		
	case KSPROPERTY_VIDEODECODER_STANDARD:
	{
		PKSPROPERTY_VIDEODECODER_S pS = (PKSPROPERTY_VIDEODECODER_S) pSPD->PropertyInfo;    // pointer to the data

		ASSERT (pSPD->PropertyOutputSize >= sizeof (KSPROPERTY_VIDEODECODER_S));

		pS->Value = m_VideoStandard;

		pSrb->ActualBytesTransferred = sizeof (KSPROPERTY_VIDEODECODER_S);
	}
	break;

	case KSPROPERTY_VIDEODECODER_STATUS:
	{
		PKSPROPERTY_VIDEODECODER_STATUS_S pS = (PKSPROPERTY_VIDEODECODER_STATUS_S) pSPD->PropertyInfo;    // pointer to the data

		ASSERT (pSPD->PropertyOutputSize >= sizeof (KSPROPERTY_VIDEODECODER_STATUS_S));

		pS->NumberOfLines = (m_VideoStandard & KS_AnalogVideo_NTSC_Mask)
							 ? 525 : 625;

		// Just to make things interesting, simulate that some channels aren't locked
		// In the US, these are channels 54 through 70
		// pS->SignalLocked = (pHwDevExt->Frequency < 400000000 || pHwDevExt->Frequency > 500000000);

		pSrb->ActualBytesTransferred = sizeof (KSPROPERTY_VIDEODECODER_S);
	}
	break;

	case KSPROPERTY_VIDEODECODER_OUTPUT_ENABLE:
	{
		PKSPROPERTY_VIDEODECODER_S pS = (PKSPROPERTY_VIDEODECODER_S) pSPD->PropertyInfo;    // pointer to the data

		ASSERT (pSPD->PropertyOutputSize >= sizeof (KSPROPERTY_VIDEODECODER_S));

		pS->Value = m_OutputEnable;

		pSrb->ActualBytesTransferred = sizeof (KSPROPERTY_VIDEODECODER_S);
	}
	break;

	case KSPROPERTY_VIDEODECODER_VCR_TIMING:
	{
		PKSPROPERTY_VIDEODECODER_S pS = (PKSPROPERTY_VIDEODECODER_S) pSPD->PropertyInfo;    // pointer to the data

		ASSERT (pSPD->PropertyOutputSize >= sizeof (KSPROPERTY_VIDEODECODER_S));

		pS->Value = m_VCRTiming;

		pSrb->ActualBytesTransferred = sizeof (KSPROPERTY_VIDEODECODER_S);
	}
	break;

	default:
		// TRAP --
		break;
	}
}

////////////////////////////////////////////////////////////////////////
// VideoControl::SetProperty

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

	ASSERT (pSPD->PropertyInputSize >= sizeof (KSPROPERTY_VIDEOCONTROL_MODE_S));
	
	switch (Id)
	{
	case KSPROPERTY_VIDEOCONTROL_MODE:
		m_Mode = pS->Mode;
		break;

	default:
		ASSERT(FALSE);
	}
}


////////////////////////////////////////////////////////////////////////
// VideoControl::GetProperty

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

	switch (Id)
	{
	case KSPROPERTY_VIDEOCONTROL_CAPS:
	{
		PKSPROPERTY_VIDEOCONTROL_CAPS_S pS = (PKSPROPERTY_VIDEOCONTROL_CAPS_S) pSPD->PropertyInfo;    // pointer to the data

		ASSERT (pSPD->PropertyOutputSize >= sizeof (KSPROPERTY_VIDEOCONTROL_CAPS_S));
		
		pS->VideoControlCaps =    
			  KS_VideoControlFlag_FlipHorizontal       
			| KS_VideoControlFlag_FlipVertical         
			| KS_VideoControlFlag_ExternalTriggerEnable
			| KS_VideoControlFlag_Trigger              
			;

		pSrb->ActualBytesTransferred = sizeof (KSPROPERTY_VIDEOCONTROL_CAPS_S);

		break;
	}
		
	case KSPROPERTY_VIDEOCONTROL_ACTUAL_FRAME_RATE:
	{
		PKSPROPERTY_VIDEOCONTROL_ACTUAL_FRAME_RATE_S pS = 
			(PKSPROPERTY_VIDEOCONTROL_ACTUAL_FRAME_RATE_S) pSPD->PropertyInfo;    // pointer to the data

		ASSERT (pSPD->PropertyOutputSize >= sizeof (KSPROPERTY_VIDEOCONTROL_ACTUAL_FRAME_RATE_S));

		pS->CurrentActualFrameRate = 15;        // bugbug
		pS->CurrentMaxAvailableFrameRate = 15;  // bugbug
		

		pSrb->ActualBytesTransferred = sizeof (KSPROPERTY_VIDEOCONTROL_ACTUAL_FRAME_RATE_S);

		break;
	}

	case KSPROPERTY_VIDEOCONTROL_FRAME_RATES:
	{
		// bugbug 
		// todo
		break;
	}

	case KSPROPERTY_VIDEOCONTROL_MODE:
	{
		PKSPROPERTY_VIDEOCONTROL_MODE_S pS = (PKSPROPERTY_VIDEOCONTROL_MODE_S) pSPD->PropertyInfo;    // pointer to the data

		ASSERT (pSPD->PropertyOutputSize >= sizeof (KSPROPERTY_VIDEOCONTROL_MODE_S));

		pS->Mode = m_Mode;

		pSrb->ActualBytesTransferred = sizeof (KSPROPERTY_VIDEOCONTROL_MODE_S);

		break;
	}

	default:
		ASSERT(FALSE);
	}
}