//==========================================================================;
//
// 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.
//
// Copyright (c) 1992 - 1996 Microsoft Corporation. All Rights Reserved.
//
//==========================================================================;
//
// This file handles all adapter property sets
//
#include "strmini.h"
#include "ksmedia.h"
#include "capmain.h"
#include "capdebug.h"
#include "capxfer.h"
#define DEFINE_MEDIUMS
#include "mediums.h"
// -------------------------------------------------------------------
// A few notes about property set handling
//
// Property sets used in Testcap are of two varieties, those that have
// default values, ranges, and stepping, such as VideoProcAmp and CameraControl,
// and those which don't have defaults and ranges, such as TVTuner and
// Crossbar.
//
// Default values and stepping are established by tables in capprop.h,
// no code is required to implement this other than initally creating the tables.
//
// Many of the property sets require the ability to modify a number
// of input parameters. Since KS doesn't allow this inherently, you'll
// note that some property sets require copying the provided input parameters
// to the ouput parameter list, effectively creating a "read, modify, write"
// capability. For this reason, the input and output parameter lists
// use identical structures.
//
// On an SRB_GET_DEVICE_PROPERTY, read-only input data to the driver is provided as:
// pSrb->CommandData.PropertyInfo
//
// ... while the output data pointer is:
// pSrb->CommandData.PropertyInfo.PropertyInfo
//
// -------------------------------------------------------------------
// -------------------------------------------------------------------
// XBar pin definitions
// -------------------------------------------------------------------
typedef struct _XBAR_PIN_DESCRIPTION {
ULONG PinType;
ULONG SynthImageCommand; // This driver simulates different inputs by synthesizing images
ULONG RelatedPinIndex;
const KSPIN_MEDIUM *Medium; // Describes hardware connectivity
} XBAR_PIN_DESCRIPTION, *PXBAR_PIN_DESCRIPTION;
XBAR_PIN_DESCRIPTION XBarInputPins[] = {
// First list the video input pins, then the audio inputs, then the output pins
// Note that audio pin index 6 is shared between two video inputs (index 1 and index 2)
// PinType SynthImageCommand RelatedPinIndex Medium
/*0*/ KS_PhysConn_Video_Tuner, IMAGE_XFER_NTSC_EIA_100AMP_100SAT, 5, &CrossbarMediums[0],
/*1*/ KS_PhysConn_Video_Composite, IMAGE_XFER_NTSC_EIA_75AMP_100SAT, 6, &CrossbarMediums[1],
/*2*/ KS_PhysConn_Video_SVideo, IMAGE_XFER_BLACK, 6, &CrossbarMediums[2],
/*3*/ KS_PhysConn_Video_Tuner, IMAGE_XFER_WHITE, 7, &CrossbarMediums[3],
/*4*/ KS_PhysConn_Video_Composite, IMAGE_XFER_GRAY_INCREASING, 8, &CrossbarMediums[4],
/*5*/ KS_PhysConn_Audio_Tuner, 0, 0, &CrossbarMediums[5],
/*6*/ KS_PhysConn_Audio_Line, 0, 1, &CrossbarMediums[6],
/*7*/ KS_PhysConn_Audio_Tuner, 0, 3, &CrossbarMediums[7],
/*8*/ KS_PhysConn_Audio_Line, 0, 4, &CrossbarMediums[8],
};
#define NUMBER_OF_XBAR_INPUTS (SIZEOF_ARRAY (XBarInputPins))
XBAR_PIN_DESCRIPTION XBarOutputPins[] = {
// PinType SynthImageCommand RelatedPinIndex
/*0*/ KS_PhysConn_Video_VideoDecoder, 0, 1, &CrossbarMediums[9],
/*1*/ KS_PhysConn_Audio_AudioDecoder, 0, 0, &CrossbarMediums[10],
};
#define NUMBER_OF_XBAR_OUTPUTS (SIZEOF_ARRAY (XBarOutputPins))
#define NUMBER_OF_XBAR_PINS_TOTAL (NUMBER_OF_XBAR_INPUTS + NUMBER_OF_XBAR_OUTPUTS)
// -------------------------------------------------------------------
// XBar Property Set functions
// -------------------------------------------------------------------
/*
** AdapterSetCrossbarProperty ()
**
** Handles Set operations on the Crossbar property set.
** Testcap uses this to select an image to synthesize.
**
** Arguments:
**
** pSRB -
** Pointer to the HW_STREAM_REQUEST_BLOCK
**
** Returns:
**
** Side Effects: none
*/
VOID
STREAMAPI
AdapterSetCrossbarProperty(
PHW_STREAM_REQUEST_BLOCK pSrb
)
{
PHW_DEVICE_EXTENSION pHwDevExt = ((PHW_DEVICE_EXTENSION)pSrb->HwDeviceExtension);
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: // W
{
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));
// Default to failure
pRoute->CanRoute = 0;
// if video
if (pRoute->IndexOutputPin == 0) {
if (pRoute->IndexInputPin <= 4) {
pHwDevExt->VideoInputConnected = pRoute->IndexInputPin;
pRoute->CanRoute = 1;
}
}
// if audio
else if (pRoute->IndexOutputPin == 1) {
// Special case! Audio Routing of (-1) means mute!!!
if (pRoute->IndexInputPin == -1) {
pHwDevExt->AudioInputConnected = pRoute->IndexInputPin;
pRoute->CanRoute = 1;
}
else if (pRoute->IndexInputPin > 4 && pRoute->IndexInputPin <= 8) {
pHwDevExt->AudioInputConnected = pRoute->IndexInputPin;
pRoute->CanRoute = 1;
}
}
// Somebody passed bogus data
if (pRoute->CanRoute == 0) {
pSrb->Status = STATUS_INVALID_PARAMETER;
}
}
break;
default:
TRAP;
break;
}
}
/*
** AdapterGetCrossbarProperty ()
**
** Handles Get operations on the Crossbar property set.
** Testcap uses this to select an image to synthesize.
**
** Arguments:
**
** pSRB -
** Pointer to the HW_STREAM_REQUEST_BLOCK
**
** Returns:
**
** Side Effects: none
*/
VOID
STREAMAPI
AdapterGetCrossbarProperty(
PHW_STREAM_REQUEST_BLOCK pSrb
)
{
PHW_DEVICE_EXTENSION pHwDevExt = ((PHW_DEVICE_EXTENSION)pSrb->HwDeviceExtension);
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 = NUMBER_OF_XBAR_INPUTS;
pCaps->NumberOfOutputs = NUMBER_OF_XBAR_OUTPUTS;
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));
// Special case, audio output routed to (-1) means mute
if (pRoute->IndexOutputPin == 1 && pRoute->IndexInputPin == -1) {
pRoute->CanRoute = TRUE;
}
else if ((pRoute->IndexInputPin >= NUMBER_OF_XBAR_INPUTS) ||
(pRoute->IndexOutputPin >= NUMBER_OF_XBAR_OUTPUTS)) {
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 < NUMBER_OF_XBAR_INPUTS);
pPinInfo->PinType = XBarInputPins[pPinInfo->Index].PinType;
pPinInfo->RelatedPinIndex = XBarInputPins[pPinInfo->Index].RelatedPinIndex;
pPinInfo->Medium = *XBarInputPins[pPinInfo->Index].Medium;
}
else {
ASSERT (pPinInfo->Index < NUMBER_OF_XBAR_OUTPUTS);
pPinInfo->PinType = XBarOutputPins[pPinInfo->Index].PinType;
pPinInfo->RelatedPinIndex = XBarOutputPins[pPinInfo->Index].RelatedPinIndex;
pPinInfo->Medium = *XBarOutputPins[pPinInfo->Index].Medium;
}
pPinInfo->Medium.Id = pHwDevExt->DriverMediumInstanceCount; // Multiple instance support
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 >= NUMBER_OF_XBAR_OUTPUTS) {
pRoute->CanRoute = FALSE;
}
// querying the the video output pin
else if (pRoute->IndexOutputPin == 0) {
pRoute->IndexInputPin = pHwDevExt->VideoInputConnected;
pRoute->CanRoute = TRUE;
}
// querying the the audio output pin
else if (pRoute->IndexOutputPin == 1) {
pRoute->IndexInputPin = pHwDevExt->AudioInputConnected;
pRoute->CanRoute = TRUE;
}
pSrb->ActualBytesTransferred = sizeof (KSPROPERTY_CROSSBAR_ROUTE_S);
}
break;
default:
TRAP;
break;
}
}
// -------------------------------------------------------------------
// TVTuner Property Set functions
// -------------------------------------------------------------------
/*
** AdapterSetTunerProperty ()
**
** Handles Set operations on the TvTuner property set.
** Testcap uses this for demo purposes only.
**
** Arguments:
**
** pSRB -
** Pointer to the HW_STREAM_REQUEST_BLOCK
**
** Returns:
**
** Side Effects: none
*/
VOID
STREAMAPI
AdapterSetTunerProperty(
PHW_STREAM_REQUEST_BLOCK pSrb
)
{
PHW_DEVICE_EXTENSION pHwDevExt = ((PHW_DEVICE_EXTENSION)pSrb->HwDeviceExtension);
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 |
KSPROPERTY_TUNER_MODE_AM_RADIO |
KSPROPERTY_TUNER_MODE_FM_RADIO |
KSPROPERTY_TUNER_MODE_ATSC));
pHwDevExt->TunerMode = pMode->Mode;
}
break;
case KSPROPERTY_TUNER_STANDARD:
{
PKSPROPERTY_TUNER_STANDARD_S pStandard_S =
(PKSPROPERTY_TUNER_STANDARD_S) pSPD->Property;
pHwDevExt->VideoStandard = pStandard_S->Standard;
}
break;
case KSPROPERTY_TUNER_FREQUENCY:
{
PKSPROPERTY_TUNER_FREQUENCY_S pFreq_S =
(PKSPROPERTY_TUNER_FREQUENCY_S) pSPD->Property;
pHwDevExt->Frequency = pFreq_S->Frequency;
pHwDevExt->Country = pFreq_S->Country;
pHwDevExt->Channel = pFreq_S->Channel;
}
break;
case KSPROPERTY_TUNER_INPUT:
{
PKSPROPERTY_TUNER_INPUT_S pInput_S =
(PKSPROPERTY_TUNER_INPUT_S) pSPD->Property;
pHwDevExt->TunerInput = pInput_S->InputIndex;
}
break;
default:
TRAP;
break;
}
}
/*
** AdapterGetTunerProperty ()
**
** Handles Get operations on the TvTuner property set.
** Testcap uses this for demo purposes only.
**
** Arguments:
**
** pSRB -
** Pointer to the HW_STREAM_REQUEST_BLOCK
**
** Returns:
**
** Side Effects: none
*/
VOID
STREAMAPI
AdapterGetTunerProperty(
PHW_STREAM_REQUEST_BLOCK pSrb
)
{
PHW_DEVICE_EXTENSION pHwDevExt = ((PHW_DEVICE_EXTENSION)pSrb->HwDeviceExtension);
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 |
KSPROPERTY_TUNER_MODE_FM_RADIO |
KSPROPERTY_TUNER_MODE_AM_RADIO |
KSPROPERTY_TUNER_MODE_ATSC;
pCaps->VideoMedium = TVTunerMediums[0];
pCaps->VideoMedium.Id = pHwDevExt->DriverMediumInstanceCount; // Multiple instance support
pCaps->TVAudioMedium = TVTunerMediums[1];
pCaps->TVAudioMedium.Id = pHwDevExt->DriverMediumInstanceCount; // Multiple instance support
pCaps->RadioAudioMedium = TVTunerMediums[2]; // No separate radio audio pin?
pCaps->RadioAudioMedium.Id = pHwDevExt->DriverMediumInstanceCount; // Multiple instance support
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 = pHwDevExt->TunerMode;
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));
// now work with the output buffer
pCaps = (PKSPROPERTY_TUNER_MODE_CAPS_S) pV;
pCaps->Mode = ((PKSPROPERTY_TUNER_MODE_CAPS_S) pSPD->Property)->Mode;
pSrb->ActualBytesTransferred = sizeof (KSPROPERTY_TUNER_MODE_CAPS_S);
switch (pCaps->Mode) {
case KSPROPERTY_TUNER_MODE_TV:
case KSPROPERTY_TUNER_MODE_ATSC:
// List the formats actually supported by the tuner in this mode
pCaps->StandardsSupported =
(pHwDevExt->TunerMode == KSPROPERTY_TUNER_MODE_ATSC) ?
KS_AnalogVideo_NTSC_M
:
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_PAL_N_COMBO
// | 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_PLL;
break;
case KSPROPERTY_TUNER_MODE_FM_RADIO:
pCaps->StandardsSupported = 0;
pCaps->MinFrequency = 88100000L;
pCaps->MaxFrequency = 107900000L;
// What is the frequency step size?
pCaps->TuningGranularity = 200000L;
// 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:
pCaps->Strategy = KS_TUNER_STRATEGY_DRIVER_TUNES;
break;
case KSPROPERTY_TUNER_MODE_AM_RADIO:
pCaps->StandardsSupported = 0;
pCaps->MinFrequency = 540000L;
pCaps->MaxFrequency = 1700000L;
// What is the frequency step size?
pCaps->TuningGranularity = 1000L;
// 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:
pCaps->Strategy = KS_TUNER_STRATEGY_DRIVER_TUNES;
break;
default:
ASSERT (FALSE);
break;
}
}
break;
case KSPROPERTY_TUNER_STANDARD:
{
// What is the currently selected video standard?
((PKSPROPERTY_TUNER_STANDARD_S) pSPD->PropertyInfo)->Standard =
pHwDevExt->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 =
pHwDevExt->TunerInput;
pSrb->ActualBytesTransferred = sizeof (KSPROPERTY_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 = pHwDevExt->Frequency;
pStatus->PLLOffset = 0;
pStatus->SignalStrength = 100;
pStatus->Busy = pHwDevExt->Busy;
pSrb->ActualBytesTransferred = sizeof (KSPROPERTY_TUNER_STATUS_S);
}
break;
case KSPROPERTY_TUNER_IF_MEDIUM:
{
// Only Digital TV tuners should support this property
PKSPROPERTY_TUNER_IF_MEDIUM_S pMedium =
(PKSPROPERTY_TUNER_IF_MEDIUM_S)pSPD->Property;
ASSERT (nS >= sizeof( KSPROPERTY_TUNER_IF_MEDIUM_S) );
// now work with the output buffer
pMedium =(PKSPROPERTY_TUNER_IF_MEDIUM_S)pV;
pMedium->IFMedium = TVTunerMediums[3];
pMedium->IFMedium.Id = pHwDevExt->DriverMediumInstanceCount; // Multiple instance support
pSrb->ActualBytesTransferred = sizeof (KSPROPERTY_TUNER_IF_MEDIUM_S);
}
break;
default:
TRAP;
break;
}
}
// -------------------------------------------------------------------
// VideoProcAmp functions
// -------------------------------------------------------------------
/*
** AdapterSetVideoProcAmpProperty ()
**
** Handles Set operations on the VideoProcAmp property set.
** Testcap uses this for demo purposes only.
**
** Arguments:
**
** pSRB -
** Pointer to the HW_STREAM_REQUEST_BLOCK
**
** Returns:
**
** Side Effects: none
*/
VOID
STREAMAPI
AdapterSetVideoProcAmpProperty(
PHW_STREAM_REQUEST_BLOCK pSrb
)
{
PHW_DEVICE_EXTENSION pHwDevExt = ((PHW_DEVICE_EXTENSION)pSrb->HwDeviceExtension);
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->PropertyInputSize >= sizeof (KSPROPERTY_VIDEOPROCAMP_S));
switch (Id) {
case KSPROPERTY_VIDEOPROCAMP_BRIGHTNESS:
pHwDevExt->Brightness = pS->Value;
pHwDevExt->BrightnessFlags = pS->Flags;
break;
case KSPROPERTY_VIDEOPROCAMP_CONTRAST:
pHwDevExt->Contrast = pS->Value;
pHwDevExt->ContrastFlags = pS->Flags;
break;
case KSPROPERTY_VIDEOPROCAMP_COLORENABLE:
pHwDevExt->ColorEnable = pS->Value;
pHwDevExt->ColorEnableFlags = pS->Flags;
break;
default:
TRAP;
break;
}
}
/*
** AdapterGetVideoProcAmpProperty ()
**
** Handles Get operations on the VideoProcAmp property set.
** Testcap uses this for demo purposes only.
**
** Arguments:
**
** pSRB -
** Pointer to the HW_STREAM_REQUEST_BLOCK
**
** Returns:
**
** Side Effects: none
*/
VOID
STREAMAPI
AdapterGetVideoProcAmpProperty(
PHW_STREAM_REQUEST_BLOCK pSrb
)
{
PHW_DEVICE_EXTENSION pHwDevExt = ((PHW_DEVICE_EXTENSION)pSrb->HwDeviceExtension);
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 = pHwDevExt->Brightness;
pS->Flags = pHwDevExt->BrightnessFlags;
pS->Capabilities = KSPROPERTY_VIDEOPROCAMP_FLAGS_MANUAL |
KSPROPERTY_VIDEOPROCAMP_FLAGS_AUTO;
break;
case KSPROPERTY_VIDEOPROCAMP_CONTRAST:
pS->Value = pHwDevExt->Contrast;
pS->Flags = pHwDevExt->ContrastFlags;
pS->Capabilities = KSPROPERTY_VIDEOPROCAMP_FLAGS_MANUAL |
KSPROPERTY_VIDEOPROCAMP_FLAGS_AUTO;
break;
case KSPROPERTY_VIDEOPROCAMP_COLORENABLE:
pS->Value = pHwDevExt->ColorEnable;
pS->Flags = pHwDevExt->ColorEnableFlags;
pS->Capabilities = KSPROPERTY_VIDEOPROCAMP_FLAGS_MANUAL;
break;
default:
TRAP;
break;
}
pSrb->ActualBytesTransferred = sizeof (KSPROPERTY_VIDEOPROCAMP_S);
}
// -------------------------------------------------------------------
// CameraControl functions
// -------------------------------------------------------------------
/*
** AdapterSetCameraControlProperty ()
**
** Handles Set operations on the CameraControl property set.
** Testcap uses this for demo purposes only.
**
** Arguments:
**
** pSRB -
** Pointer to the HW_STREAM_REQUEST_BLOCK
**
** Returns:
**
** Side Effects: none
*/
VOID
STREAMAPI
AdapterSetCameraControlProperty(
PHW_STREAM_REQUEST_BLOCK pSrb
)
{
PHW_DEVICE_EXTENSION pHwDevExt = ((PHW_DEVICE_EXTENSION)pSrb->HwDeviceExtension);
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:
pHwDevExt->Zoom = pS->Value;
pHwDevExt->ZoomFlags = pS->Flags;
break;
case KSPROPERTY_CAMERACONTROL_FOCUS:
pHwDevExt->Focus = pS->Value;
pHwDevExt->FocusFlags = pS->Flags;
break;
default:
TRAP;
break;
}
}
/*
** AdapterGetCameraControlProperty ()
**
** Handles Get operations on the CameraControl property set.
** Testcap uses this for demo purposes only.
**
** Arguments:
**
** pSRB -
** Pointer to the HW_STREAM_REQUEST_BLOCK
**
** Returns:
**
** Side Effects: none
*/
VOID
STREAMAPI
AdapterGetCameraControlProperty(
PHW_STREAM_REQUEST_BLOCK pSrb
)
{
PHW_DEVICE_EXTENSION pHwDevExt = ((PHW_DEVICE_EXTENSION)pSrb->HwDeviceExtension);
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 = pHwDevExt->Zoom;
pS->Flags = pHwDevExt->ZoomFlags;
pS->Capabilities = KSPROPERTY_CAMERACONTROL_FLAGS_MANUAL |
KSPROPERTY_CAMERACONTROL_FLAGS_AUTO;
break;
case KSPROPERTY_CAMERACONTROL_FOCUS:
pS->Value = pHwDevExt->Focus;
pS->Flags = pHwDevExt->FocusFlags;
pS->Capabilities = KSPROPERTY_CAMERACONTROL_FLAGS_MANUAL |
KSPROPERTY_CAMERACONTROL_FLAGS_AUTO;
break;
default:
TRAP;
break;
}
pSrb->ActualBytesTransferred = sizeof (KSPROPERTY_CAMERACONTROL_S);
}
// -------------------------------------------------------------------
// TVAudio functions
// -------------------------------------------------------------------
/*
** AdapterSetTVAudioProperty ()
**
** Handles Set operations on the TVAudio property set.
** Testcap uses this for demo purposes only.
**
** Arguments:
**
** pSRB -
** Pointer to the HW_STREAM_REQUEST_BLOCK
**
** Returns:
**
** Side Effects: none
*/
VOID
STREAMAPI
AdapterSetTVAudioProperty(
PHW_STREAM_REQUEST_BLOCK pSrb
)
{
PHW_DEVICE_EXTENSION pHwDevExt = ((PHW_DEVICE_EXTENSION)pSrb->HwDeviceExtension);
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;
pHwDevExt->TVAudioMode = pS->Mode;
}
break;
default:
TRAP;
break;
}
}
/*
** AdapterGetTVAudioProperty ()
**
** Handles Get operations on the TVAudio property set.
** Testcap uses this for demo purposes only.
**
** Arguments:
**
** pSRB -
** Pointer to the HW_STREAM_REQUEST_BLOCK
**
** Returns:
**
** Side Effects: none
*/
VOID
STREAMAPI
AdapterGetTVAudioProperty(
PHW_STREAM_REQUEST_BLOCK pSrb
)
{
PHW_DEVICE_EXTENSION pHwDevExt = ((PHW_DEVICE_EXTENSION)pSrb->HwDeviceExtension);
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->InputMedium.Id = pHwDevExt->DriverMediumInstanceCount; // Multiple instance support
pS->OutputMedium = TVAudioMediums[1];
pS->OutputMedium.Id = pHwDevExt->DriverMediumInstanceCount; // Multiple instance support
// 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 = pHwDevExt->TVAudioMode;
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:
TRAP;
break;
}
}
// -------------------------------------------------------------------
// AnalogVideoDecoder functions
// -------------------------------------------------------------------
/*
** AdapterSetAnalogVideoDecoderProperty ()
**
** Handles Set operations on the AnalogVideoDecoder property set.
** Testcap uses this for demo purposes only.
**
** Arguments:
**
** pSRB -
** Pointer to the HW_STREAM_REQUEST_BLOCK
**
** Returns:
**
** Side Effects: none
*/
VOID
STREAMAPI
AdapterSetAnalogVideoDecoderProperty(
PHW_STREAM_REQUEST_BLOCK pSrb
)
{
PHW_DEVICE_EXTENSION pHwDevExt = ((PHW_DEVICE_EXTENSION)pSrb->HwDeviceExtension);
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:
{
pHwDevExt->VideoDecoderVideoStandard = pS->Value;
}
break;
case KSPROPERTY_VIDEODECODER_OUTPUT_ENABLE:
{
pHwDevExt->VideoDecoderOutputEnable = pS->Value;
}
break;
case KSPROPERTY_VIDEODECODER_VCR_TIMING:
{
pHwDevExt->VideoDecoderVCRTiming = pS->Value;
}
break;
default:
TRAP;
break;
}
}
/*
** AdapterGetAnalogVideoDecoderProperty ()
**
** Handles Get operations on the AnalogVideoDecoder property set.
** Testcap uses this for demo purposes only.
**
** Arguments:
**
** pSRB -
** Pointer to the HW_STREAM_REQUEST_BLOCK
**
** Returns:
**
** Side Effects: none
*/
VOID
STREAMAPI
AdapterGetAnalogVideoDecoderProperty(
PHW_STREAM_REQUEST_BLOCK pSrb
)
{
PHW_DEVICE_EXTENSION pHwDevExt = ((PHW_DEVICE_EXTENSION)pSrb->HwDeviceExtension);
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 = pHwDevExt->VideoDecoderVideoStandard;
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 = (pHwDevExt->VideoDecoderVideoStandard & 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 = pHwDevExt->VideoDecoderOutputEnable;
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 = pHwDevExt->VideoDecoderVCRTiming;
pSrb->ActualBytesTransferred = sizeof (KSPROPERTY_VIDEODECODER_S);
}
break;
default:
TRAP;
break;
}
}
// -------------------------------------------------------------------
// VideoControl functions
// -------------------------------------------------------------------
/*
** AdapterSetVideoControlProperty ()
**
** Handles Set operations on the VideoControl property set.
** Testcap uses this for demo purposes only.
**
** Arguments:
**
** pSRB -
** Pointer to the HW_STREAM_REQUEST_BLOCK
**
** Returns:
**
** Side Effects: none
*/
VOID
STREAMAPI
AdapterSetVideoControlProperty(
PHW_STREAM_REQUEST_BLOCK pSrb
)
{
PHW_DEVICE_EXTENSION pHwDevExt = ((PHW_DEVICE_EXTENSION)pSrb->HwDeviceExtension);
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;
PSTREAMEX pStrmEx;
ULONG StreamIndex;
ULONG *pVideoControlMode;
// For this property set, the StreamIndex is always in the same place
// for each property
StreamIndex = ((PKSPROPERTY_VIDEOCONTROL_CAPS_S) pSPD->Property)->StreamIndex;
ASSERT (StreamIndex < MAX_TESTCAP_STREAMS);
// Verify the stream index is valid
if (StreamIndex >= MAX_TESTCAP_STREAMS) {
pSrb->Status = STATUS_INVALID_PARAMETER;
return;
}
pStrmEx = (PSTREAMEX) pHwDevExt->pStrmEx[StreamIndex];
// If the stream is not opened when this property set is used,
// store the values in the HwDevExt
if (pStrmEx) {
pVideoControlMode = &pStrmEx->VideoControlMode;
}
else {
pVideoControlMode = &pHwDevExt->VideoControlMode;
}
ASSERT (pSPD->PropertyInputSize >= sizeof (KSPROPERTY_VIDEOCONTROL_MODE_S));
switch (Id) {
case KSPROPERTY_VIDEOCONTROL_MODE:
{
*pVideoControlMode = pS->Mode;
}
break;
default:
TRAP;
break;
}
}
/*
** AdapterGetVideoControlProperty ()
**
** Handles Get operations on the VideoControl property set.
** Testcap uses this for demo purposes only.
**
** Arguments:
**
** pSRB -
** Pointer to the HW_STREAM_REQUEST_BLOCK
**
** Returns:
**
** Side Effects: none
*/
VOID
STREAMAPI
AdapterGetVideoControlProperty(
PHW_STREAM_REQUEST_BLOCK pSrb
)
{
PHW_DEVICE_EXTENSION pHwDevExt = ((PHW_DEVICE_EXTENSION)pSrb->HwDeviceExtension);
PSTREAM_PROPERTY_DESCRIPTOR pSPD = pSrb->CommandData.PropertyInfo;
ULONG Id = pSPD->Property->Id; // index of the property
PSTREAMEX pStrmEx;
ULONG StreamIndex;
ULONG *pVideoControlMode;
// For this property set, the StreamIndex is always in the same place
// for each property
StreamIndex = ((PKSPROPERTY_VIDEOCONTROL_CAPS_S) pSPD->Property)->StreamIndex;
ASSERT (StreamIndex < MAX_TESTCAP_STREAMS);
// Verify the stream index is valid
if (StreamIndex >= MAX_TESTCAP_STREAMS) {
pSrb->Status = STATUS_INVALID_PARAMETER;
return;
}
pStrmEx = (PSTREAMEX) pHwDevExt->pStrmEx[StreamIndex];
// If the stream is not opened when this property set is used,
// store the values in the HwDevExt
if (pStrmEx) {
pVideoControlMode = &pStrmEx->VideoControlMode;
}
else {
pVideoControlMode = &pHwDevExt->VideoControlMode;
}
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; // TODO: Implement the right rates in shipping drivers.
pS->CurrentMaxAvailableFrameRate = 15; // TODO: Implement the right rates in shipping drivers.
pSrb->ActualBytesTransferred = sizeof (KSPROPERTY_VIDEOCONTROL_ACTUAL_FRAME_RATE_S);
}
break;
case KSPROPERTY_VIDEOCONTROL_FRAME_RATES:
{
// 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 = *pVideoControlMode;
pSrb->ActualBytesTransferred = sizeof (KSPROPERTY_VIDEOCONTROL_MODE_S);
}
break;
default:
TRAP;
break;
}
}
/*
** AdapterGetVideoCompressionProperty()
**
** Gets compressor settings
**
** Arguments:
**
** pSrb - pointer to the stream request block for properties
**
** Returns:
**
** Side Effects: none
*/
VOID
STREAMAPI
AdapterGetVideoCompressionProperty(
PHW_STREAM_REQUEST_BLOCK pSrb
)
{
PHW_DEVICE_EXTENSION pHwDevExt = ((PHW_DEVICE_EXTENSION)pSrb->HwDeviceExtension);
PSTREAMEX pStrmEx;
PSTREAM_PROPERTY_DESCRIPTOR pSPD = pSrb->CommandData.PropertyInfo;
ULONG Id = pSPD->Property->Id; // index of the property
ULONG StreamIndex;
PCOMPRESSION_SETTINGS pCompressionSettings;
// For this property set, the StreamIndex is always in the same place
// for each property
StreamIndex = ((PKSPROPERTY_VIDEOCOMPRESSION_S) pSPD->Property)->StreamIndex;
ASSERT (StreamIndex < MAX_TESTCAP_STREAMS);
// Verify the stream index is valid
if (StreamIndex >= MAX_TESTCAP_STREAMS) {
pSrb->Status = STATUS_INVALID_PARAMETER;
return;
}
pStrmEx = (PSTREAMEX) pHwDevExt->pStrmEx[StreamIndex];
// If the stream is not opened when this property set is used,
// store the values in the HwDevExt
if (pStrmEx) {
pCompressionSettings = &pStrmEx->CompressionSettings;
}
else {
pCompressionSettings = &pHwDevExt->CompressionSettings;
}
switch (Id) {
case KSPROPERTY_VIDEOCOMPRESSION_GETINFO:
{
PKSPROPERTY_VIDEOCOMPRESSION_GETINFO_S pS =
(PKSPROPERTY_VIDEOCOMPRESSION_GETINFO_S) pSPD->PropertyInfo;
pS->DefaultKeyFrameRate = 15; // Key frame rate
pS->DefaultPFrameRate = 3; // Predeicted frames per Key frame
pS->DefaultQuality = 5000; // 0 to 10000
pS->Capabilities =
KS_CompressionCaps_CanQuality |
KS_CompressionCaps_CanKeyFrame |
KS_CompressionCaps_CanBFrame ;
pSrb->ActualBytesTransferred = sizeof (KSPROPERTY_VIDEOCOMPRESSION_GETINFO_S);
}
break;
case KSPROPERTY_VIDEOCOMPRESSION_KEYFRAME_RATE:
{
PKSPROPERTY_VIDEOCOMPRESSION_S pS =
(PKSPROPERTY_VIDEOCOMPRESSION_S) pSPD->PropertyInfo;
pS->Value = pCompressionSettings->CompressionKeyFrameRate;
pSrb->ActualBytesTransferred = sizeof (KSPROPERTY_VIDEOCOMPRESSION_S);
}
break;
case KSPROPERTY_VIDEOCOMPRESSION_PFRAMES_PER_KEYFRAME:
{
PKSPROPERTY_VIDEOCOMPRESSION_S pS =
(PKSPROPERTY_VIDEOCOMPRESSION_S) pSPD->PropertyInfo;
pS->Value = pCompressionSettings->CompressionPFramesPerKeyFrame;
pSrb->ActualBytesTransferred = sizeof (KSPROPERTY_VIDEOCOMPRESSION_S);
}
break;
case KSPROPERTY_VIDEOCOMPRESSION_QUALITY:
{
PKSPROPERTY_VIDEOCOMPRESSION_S pS =
(PKSPROPERTY_VIDEOCOMPRESSION_S) pSPD->PropertyInfo;
pS->Value = pCompressionSettings->CompressionQuality;
pSrb->ActualBytesTransferred = sizeof (KSPROPERTY_VIDEOCOMPRESSION_S);
}
break;
default:
TRAP;
break;
}
}
/*
** AdapterSetVideoCompressionProperty()
**
** Sets compressor settings
**
** Arguments:
**
** pSrb - pointer to the stream request block for properties
**
** Returns:
**
** Side Effects: none
*/
VOID
STREAMAPI
AdapterSetVideoCompressionProperty(
PHW_STREAM_REQUEST_BLOCK pSrb
)
{
PHW_DEVICE_EXTENSION pHwDevExt = ((PHW_DEVICE_EXTENSION)pSrb->HwDeviceExtension);
PSTREAMEX pStrmEx;
PSTREAM_PROPERTY_DESCRIPTOR pSPD = pSrb->CommandData.PropertyInfo;
PKSPROPERTY_VIDEOCOMPRESSION_S pS = (PKSPROPERTY_VIDEOCOMPRESSION_S) pSPD->Property;
ULONG Id = pSPD->Property->Id; // index of the property
ULONG StreamIndex;
PCOMPRESSION_SETTINGS pCompressionSettings;
// For this property set, the StreamIndex is always in the same place
// for each property
StreamIndex = ((PKSPROPERTY_VIDEOCOMPRESSION_S) pSPD->Property)->StreamIndex;
ASSERT (StreamIndex < MAX_TESTCAP_STREAMS);
// Verify the stream index is valid
if (StreamIndex >= MAX_TESTCAP_STREAMS) {
pSrb->Status = STATUS_INVALID_PARAMETER;
return;
}
pStrmEx = (PSTREAMEX) pHwDevExt->pStrmEx[StreamIndex];
// If the stream is not opened when this property set is used,
// store the values in the HwDevExt
if (pStrmEx) {
pCompressionSettings = &pStrmEx->CompressionSettings;
}
else {
pCompressionSettings = &pHwDevExt->CompressionSettings;
}
switch (Id) {
case KSPROPERTY_VIDEOCOMPRESSION_KEYFRAME_RATE:
{
pCompressionSettings->CompressionKeyFrameRate = pS->Value;
}
break;
case KSPROPERTY_VIDEOCOMPRESSION_PFRAMES_PER_KEYFRAME:
{
pCompressionSettings->CompressionPFramesPerKeyFrame = pS->Value;
}
break;
case KSPROPERTY_VIDEOCOMPRESSION_QUALITY:
{
pCompressionSettings->CompressionQuality = pS->Value;
}
break;
default:
TRAP;
break;
}
}
/*
** AdapterGetVBIProperty()
**
** Gets VBI settings
**
** Arguments:
**
** pSrb - pointer to the stream request block for properties
**
** Returns:
**
** Side Effects: none
*/
VOID
STREAMAPI
AdapterGetVBIProperty(
PHW_STREAM_REQUEST_BLOCK pSrb
)
{
PHW_DEVICE_EXTENSION pHwDevExt = pSrb->HwDeviceExtension;
PSTREAMEX pStrmEx;
PSTREAM_PROPERTY_DESCRIPTOR pSPD = pSrb->CommandData.PropertyInfo;
ULONG Id = pSPD->Property->Id; // index of the property
ULONG StreamIndex;
PVBICAP_PROPERTIES_PROTECTION_S pS =
(PVBICAP_PROPERTIES_PROTECTION_S) pSPD->PropertyInfo;
StreamIndex = pS->StreamIndex;
ASSERT (StreamIndex < MAX_TESTCAP_STREAMS);
// Verify the stream index is valid
if (StreamIndex >= MAX_TESTCAP_STREAMS) {
pSrb->Status = STATUS_INVALID_PARAMETER;
return;
}
pStrmEx = (PSTREAMEX) pHwDevExt->pStrmEx[StreamIndex];
pS->Status = 0;
if (pHwDevExt->ProtectionStatus & KS_VBI_FLAG_MV_PRESENT)
pS->Status |= KS_VBICAP_PROTECTION_MV_PRESENT;
if (pHwDevExt->ProtectionStatus & KS_VBI_FLAG_MV_HARDWARE)
pS->Status |= KS_VBICAP_PROTECTION_MV_HARDWARE;
if (pHwDevExt->ProtectionStatus & KS_VBI_FLAG_MV_DETECTED)
pS->Status |= KS_VBICAP_PROTECTION_MV_DETECTED;
pSrb->ActualBytesTransferred = sizeof (*pS);
}
#if DBG
/*
** AdapterSetVBIProperty()
**
** Sets VBI settings
**
** Arguments:
**
** pSrb - pointer to the stream request block for properties
**
** Returns:
**
** Side Effects: none
*/
VOID
STREAMAPI
AdapterSetVBIProperty(
PHW_STREAM_REQUEST_BLOCK pSrb
)
{
PHW_DEVICE_EXTENSION pHwDevExt = pSrb->HwDeviceExtension;
PSTREAMEX pStrmEx;
PSTREAM_PROPERTY_DESCRIPTOR pSPD = pSrb->CommandData.PropertyInfo;
ULONG Id = pSPD->Property->Id; // index of the property
ULONG StreamIndex;
PVBICAP_PROPERTIES_PROTECTION_S pS =
(PVBICAP_PROPERTIES_PROTECTION_S) pSPD->PropertyInfo;
StreamIndex = pS->StreamIndex;
ASSERT (StreamIndex < MAX_TESTCAP_STREAMS);
// Verify the stream index is valid
if (StreamIndex >= MAX_TESTCAP_STREAMS) {
pSrb->Status = STATUS_INVALID_PARAMETER;
return;
}
pStrmEx = (PSTREAMEX) pHwDevExt->pStrmEx[StreamIndex];
pHwDevExt->ProtectionStatus = 0;
if (pS->Status & KS_VBICAP_PROTECTION_MV_PRESENT)
pHwDevExt->ProtectionStatus |= KS_VBI_FLAG_MV_PRESENT;
if (pS->Status & KS_VBICAP_PROTECTION_MV_HARDWARE)
pHwDevExt->ProtectionStatus |= KS_VBI_FLAG_MV_HARDWARE;
if (pS->Status & KS_VBICAP_PROTECTION_MV_DETECTED)
pHwDevExt->ProtectionStatus |= KS_VBI_FLAG_MV_DETECTED;
}
#endif //DBG
// -------------------------------------------------------------------
// General entry point for all get/set adapter properties
// -------------------------------------------------------------------
/*
** AdapterSetProperty ()
**
** Handles Set operations for all adapter properties.
**
** Arguments:
**
** pSRB -
** Pointer to the HW_STREAM_REQUEST_BLOCK
**
** Returns:
**
** Side Effects: none
*/
VOID
STREAMAPI
AdapterSetProperty(
PHW_STREAM_REQUEST_BLOCK pSrb
)
{
PSTREAM_PROPERTY_DESCRIPTOR pSPD = pSrb->CommandData.PropertyInfo;
if (IsEqualGUID(&PROPSETID_VIDCAP_CROSSBAR, &pSPD->Property->Set)) {
AdapterSetCrossbarProperty (pSrb);
}
else if (IsEqualGUID(&PROPSETID_TUNER, &pSPD->Property->Set)) {
AdapterSetTunerProperty (pSrb);
}
else if (IsEqualGUID(&PROPSETID_VIDCAP_VIDEOPROCAMP, &pSPD->Property->Set)) {
AdapterSetVideoProcAmpProperty (pSrb);
}
else if (IsEqualGUID(&PROPSETID_VIDCAP_CAMERACONTROL, &pSPD->Property->Set)) {
AdapterSetCameraControlProperty (pSrb);
}
else if (IsEqualGUID(&PROPSETID_VIDCAP_TVAUDIO, &pSPD->Property->Set)) {
AdapterSetTVAudioProperty (pSrb);
}
else if (IsEqualGUID(&PROPSETID_VIDCAP_VIDEODECODER, &pSPD->Property->Set)) {
AdapterSetAnalogVideoDecoderProperty (pSrb);
}
else if (IsEqualGUID(&PROPSETID_VIDCAP_VIDEOCONTROL, &pSPD->Property->Set)) {
AdapterSetVideoControlProperty (pSrb);
}
else if (IsEqualGUID (&PROPSETID_VIDCAP_VIDEOCOMPRESSION, &pSPD->Property->Set)) {
AdapterSetVideoCompressionProperty (pSrb);
}
#if DBG
// Can't normally set protection status; only allow this for DEBUGGING
else if (IsEqualGUID (&KSPROPSETID_VBICAP_PROPERTIES, &pSPD->Property->Set)) {
AdapterSetVBIProperty (pSrb);
}
#endif //DBG
else {
//
// We should never get here
//
TRAP;
pSrb->Status = STATUS_NOT_IMPLEMENTED;
}
}
/*
** AdapterGetProperty ()
**
** Handles Get operations for all adapter properties.
**
** Arguments:
**
** pSRB -
** Pointer to the HW_STREAM_REQUEST_BLOCK
**
** Returns:
**
** Side Effects: none
*/
VOID
STREAMAPI
AdapterGetProperty(
PHW_STREAM_REQUEST_BLOCK pSrb
)
{
PSTREAM_PROPERTY_DESCRIPTOR pSPD = pSrb->CommandData.PropertyInfo;
if (IsEqualGUID (&PROPSETID_VIDCAP_CROSSBAR, &pSPD->Property->Set)) {
AdapterGetCrossbarProperty (pSrb);
}
else if (IsEqualGUID (&PROPSETID_TUNER, &pSPD->Property->Set)) {
AdapterGetTunerProperty (pSrb);
}
else if (IsEqualGUID(&PROPSETID_VIDCAP_VIDEOPROCAMP, &pSPD->Property->Set)) {
AdapterGetVideoProcAmpProperty (pSrb);
}
else if (IsEqualGUID(&PROPSETID_VIDCAP_CAMERACONTROL, &pSPD->Property->Set)) {
AdapterGetCameraControlProperty (pSrb);
}
else if (IsEqualGUID(&PROPSETID_VIDCAP_TVAUDIO, &pSPD->Property->Set)) {
AdapterGetTVAudioProperty (pSrb);
}
else if (IsEqualGUID(&PROPSETID_VIDCAP_VIDEODECODER, &pSPD->Property->Set)) {
AdapterGetAnalogVideoDecoderProperty (pSrb);
}
else if (IsEqualGUID(&PROPSETID_VIDCAP_VIDEOCONTROL, &pSPD->Property->Set)) {
AdapterGetVideoControlProperty (pSrb);
}
else if (IsEqualGUID (&PROPSETID_VIDCAP_VIDEOCOMPRESSION, &pSPD->Property->Set)) {
AdapterGetVideoCompressionProperty (pSrb);
}
else if (IsEqualGUID (&KSPROPSETID_VBICAP_PROPERTIES, &pSPD->Property->Set)) {
AdapterGetVBIProperty (pSrb);
}
else {
//
// We should never get here
//
TRAP;
pSrb->Status = STATUS_NOT_IMPLEMENTED;
}
}