device.cpp

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

void Device::GetVideoPortVBIProperty(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
    ULONG standard = GetVideoDecoderStandard();

    switch (Id)
    {
    case KSPROPERTY_VPCONFIG_NUMCONNECTINFO :
        ASSERT(nS >= sizeof(ULONG));

        // 2 VideoPort connections are possible
        *(PULONG)(pSpd->PropertyInfo) = BT829_VPCONNECTIONS_NUMBER;

        pSrb->ActualBytesTransferred = sizeof(ULONG);
        break;

    case KSPROPERTY_VPCONFIG_GETCONNECTINFO :

        ASSERT(nS >= sizeof(DDVIDEOPORTCONNECT));

        {
            PKSMULTIPLE_DATA_PROP MultiProperty = (PKSMULTIPLE_DATA_PROP)pSpd->Property;

            if (MultiProperty->MultipleItem.Count == BT829_VPCONNECTIONS_NUMBER &&
                MultiProperty->MultipleItem.Size == sizeof(DDVIDEOPORTCONNECT)) {
                
                if (nS >= BT829_VPCONNECTIONS_NUMBER * sizeof(DDVIDEOPORTCONNECT)) {

                    LPDDVIDEOPORTCONNECT pConnectInfo;

                    pConnectInfo = (LPDDVIDEOPORTCONNECT) pSpd->PropertyInfo;

                    // fill in the DDVIDEOPORTCONNECT structure offset 0
                    pConnectInfo->dwSize = sizeof(DDVIDEOPORTCONNECT);
                    pConnectInfo->dwPortWidth = 8;
                    pConnectInfo->guidTypeID = DDVPTYPE_BROOKTREE;
                    pConnectInfo->dwFlags = DDVPCONNECT_INVERTPOLARITY;
                    pConnectInfo->dwReserved1 = 0;

#ifdef BT829_SUPPORT_16BIT
                    // fill in the DDVIDEOPORTCONNECT structure offset 1
                    pConnectInfo ++;
                    pConnectInfo->dwSize = sizeof(DDVIDEOPORTCONNECT);
                    pConnectInfo->guidTypeID = DDVPTYPE_BROOKTREE;
                    pConnectInfo->dwPortWidth = 16;
                    pConnectInfo->dwFlags = DDVPCONNECT_INVERTPOLARITY;
                    pConnectInfo->dwReserved1 = 0;
#endif
                    pSrb->ActualBytesTransferred = BT829_VPCONNECTIONS_NUMBER * sizeof(DDVIDEOPORTCONNECT);
                }
                else {
                    pSrb->Status = STATUS_INVALID_BUFFER_SIZE;
                }
            }
            else {
                pSrb->Status = STATUS_INVALID_PARAMETER;
            }
        }
        break;

    case KSPROPERTY_VPCONFIG_NUMVIDEOFORMAT :
        ASSERT(nS >= sizeof(ULONG));

        *(PULONG)(pSpd->PropertyInfo) = BT829_PIXELFORMATS_NUMBER;

        pSrb->ActualBytesTransferred = sizeof(ULONG);
        break;

    case KSPROPERTY_VPCONFIG_GETVIDEOFORMAT :

        ASSERT(nS >= sizeof(DDPIXELFORMAT));

        {
            PKSMULTIPLE_DATA_PROP MultiProperty = (PKSMULTIPLE_DATA_PROP)pSpd->Property;

            if (MultiProperty->MultipleItem.Count == BT829_PIXELFORMATS_NUMBER &&
                MultiProperty->MultipleItem.Size == sizeof(DDPIXELFORMAT)) {
                
                if (nS >= BT829_PIXELFORMATS_NUMBER * sizeof(DDPIXELFORMAT)) {

                    ASSERT(BT829_PIXELFORMATS_NUMBER == 1); // as currently implemented, this must be true

                    LPDDPIXELFORMAT pPixelFormat;

                    pPixelFormat = (LPDDPIXELFORMAT) pSpd->PropertyInfo;

                    RtlZeroMemory(pPixelFormat, BT829_PIXELFORMATS_NUMBER * sizeof(DDPIXELFORMAT));

                    // fill in the DDPIXELFORMAT structure
                    pPixelFormat->dwSize = sizeof(DDPIXELFORMAT);
                    pPixelFormat->dwFlags = DDPF_FOURCC;
                    pPixelFormat->dwFourCC = FOURCC_VBID;
                    pPixelFormat->dwYUVBitCount = 8;

                    pSrb->ActualBytesTransferred = BT829_PIXELFORMATS_NUMBER * sizeof(DDPIXELFORMAT);
                }
                else {
                    pSrb->Status = STATUS_INVALID_BUFFER_SIZE;
                }
            }
            else {
                pSrb->Status = STATUS_INVALID_PARAMETER;
            }
        }
        break;

    case KSPROPERTY_VPCONFIG_VPDATAINFO :

        ASSERT(nS >= sizeof(KS_AMVPDATAINFO));

        {
            // Clear the portion of the buffer we plan to return
            RtlZeroMemory(pSpd->PropertyInfo, sizeof(KS_AMVPDATAINFO));

            PKS_AMVPDATAINFO pAMVPDataInfo;

            pAMVPDataInfo = (PKS_AMVPDATAINFO) pSpd->PropertyInfo;

            int decoderLostLines = (GetPartRev() >= 4) ?
                BT829A_LOST_LINES : BT829_LOST_LINES;

            // the values are sortof hardcoded for NTSC at this point
            // VBI values will need to be tweaked
            pAMVPDataInfo->dwSize = sizeof(KS_AMVPDATAINFO);

            if ( standard & ( KS_AnalogVideo_NTSC_Mask | KS_AnalogVideo_PAL_M ) )   // NTSC rectangle?
                pAMVPDataInfo->dwMicrosecondsPerField = 16667;
            else
                pAMVPDataInfo->dwMicrosecondsPerField = 20000;

            pAMVPDataInfo->bEnableDoubleClock = FALSE;
            pAMVPDataInfo->bEnableVACT = FALSE;

            pAMVPDataInfo->lHalfLinesOdd = 0;
            pAMVPDataInfo->lHalfLinesEven = 1;

            pAMVPDataInfo->bFieldPolarityInverted = FALSE;
            pAMVPDataInfo->bDataIsInterlaced = TRUE;
            pAMVPDataInfo->dwNumLinesInVREF = 6 - decoderLostLines;

            pAMVPDataInfo->amvpDimInfo.dwFieldWidth = GetDecoderWidth();
            
            // Beware of hard-coded numbers
            pAMVPDataInfo->amvpDimInfo.dwVBIWidth = VBISamples;

            if ( standard & ( KS_AnalogVideo_NTSC_Mask | KS_AnalogVideo_PAL_M ) )   // NTSC rectangle?
            {
                pAMVPDataInfo->amvpDimInfo.dwVBIHeight = NTSCVBIEnd - decoderLostLines;
                pAMVPDataInfo->amvpDimInfo.dwFieldHeight =
                    GetDecoderHeight() +
                    pAMVPDataInfo->amvpDimInfo.dwVBIHeight;
                /*
                    (NTSCVBIEnd - 1) -  // the '- 1' makes VBIEnd zero-based
                    decoderLostLines -
                    pAMVPDataInfo->dwNumLinesInVREF;
                */
            
                pAMVPDataInfo->amvpDimInfo.rcValidRegion.top = NTSCVBIStart - 1 - decoderLostLines;
            }
            else
            {
                pAMVPDataInfo->amvpDimInfo.dwVBIHeight = PALVBIEnd - decoderLostLines;
                pAMVPDataInfo->amvpDimInfo.dwFieldHeight =
                    GetDecoderHeight() +
                    pAMVPDataInfo->amvpDimInfo.dwVBIHeight;
                /*
                    (PALVBIEnd - 1) -  // the '- 1' makes VBIEnd zero-based
                    decoderLostLines -
                    pAMVPDataInfo->dwNumLinesInVREF;
                */
            
                pAMVPDataInfo->amvpDimInfo.rcValidRegion.top = PALVBIStart - 1 - decoderLostLines;
            }

            pAMVPDataInfo->amvpDimInfo.rcValidRegion.left = 0;
            pAMVPDataInfo->amvpDimInfo.rcValidRegion.right = pAMVPDataInfo->amvpDimInfo.dwVBIWidth;
            pAMVPDataInfo->amvpDimInfo.rcValidRegion.bottom = pAMVPDataInfo->amvpDimInfo.dwVBIHeight;

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

    case KSPROPERTY_VPCONFIG_MAXPIXELRATE :
        ASSERT(nS >= sizeof(KSVPMAXPIXELRATE));

        {
            PKSVPMAXPIXELRATE pKSPixelRate;

            int decoderHeight = GetDecoderHeight();
            int decoderWidth = GetDecoderWidth();

            pKSPixelRate = (PKSVPMAXPIXELRATE) pSpd->PropertyInfo;

            pKSPixelRate->Size.dwWidth = decoderWidth;
            pKSPixelRate->Size.dwHeight = decoderHeight;
            if ( standard & ( KS_AnalogVideo_NTSC_Mask | KS_AnalogVideo_PAL_M ) )   // NTSC rectangle?
                pKSPixelRate->MaxPixelsPerSecond = decoderWidth * decoderHeight * NTSC_FRAME_RATE;
            else
                pKSPixelRate->MaxPixelsPerSecond = decoderWidth * decoderHeight * PAL_FRAME_RATE;
            pKSPixelRate->Reserved = 0;

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

    case KSPROPERTY_VPCONFIG_DECIMATIONCAPABILITY :
        *(PBOOL)(pSpd->PropertyInfo) = FALSE;
        pSrb->ActualBytesTransferred = sizeof(BOOL);
        break;

    default:
        TRAP();
        pSrb->ActualBytesTransferred = 0;
        pSrb->Status = STATUS_NOT_IMPLEMENTED;
        break;
    }
}       



void Device::ConfigVPSurfaceParams(PKSVPSURFACEPARAMS pSurfaceParams)
{
    DBGINFO(("VP Surface Params:\n"));
    DBGINFO(("dwPitch    = %d\n",pSurfaceParams->dwPitch));
    DBGINFO(("dwXOrigin  = %d\n",pSurfaceParams->dwXOrigin));
    DBGINFO(("dwYOrigin  = %d\n",pSurfaceParams->dwYOrigin));

    VideoSurfaceOriginX = pSurfaceParams->dwXOrigin;
    VideoSurfaceOriginY = pSurfaceParams->dwYOrigin;
    VideoSurfacePitch = pSurfaceParams->dwPitch;
}



void Device::ConfigVPVBISurfaceParams(PKSVPSURFACEPARAMS pSurfaceParams)
{
    DBGINFO(("VP VBI Surface Params:\n"));
    DBGINFO(("dwPitch    = %d\n",pSurfaceParams->dwPitch));
    DBGINFO(("dwXOrigin  = %d\n",pSurfaceParams->dwXOrigin));
    DBGINFO(("dwYOrigin  = %d\n",pSurfaceParams->dwYOrigin));

    VBISurfaceOriginX = pSurfaceParams->dwXOrigin;
    VBISurfaceOriginY = pSurfaceParams->dwYOrigin;
    VBISurfacePitch = pSurfaceParams->dwPitch;
}


// -------------------------------------------------------------------
// VideoProcAmp functions
// -------------------------------------------------------------------

NTSTATUS Device::SetProcAmpProperty(ULONG Id, LONG Value)
{
    switch (Id) {
        case KSPROPERTY_VIDEOPROCAMP_BRIGHTNESS:

            decoder->SetBrightness(Value);
            break;
        
        case KSPROPERTY_VIDEOPROCAMP_CONTRAST:

            decoder->SetContrast(Value);
            break;

        case KSPROPERTY_VIDEOPROCAMP_HUE:

            decoder->SetHue(Value);
            break;

        case KSPROPERTY_VIDEOPROCAMP_SATURATION:

            decoder->SetSaturation(Value);
            break;

        default:
            TRAP();
            return STATUS_NOT_IMPLEMENTED;
            break;
    }

    return STATUS_SUCCESS;
}

NTSTATUS Device::GetProcAmpProperty(ULONG Id, PLONG pValue)
{
    switch (Id) {

        case KSPROPERTY_VIDEOPROCAMP_BRIGHTNESS:
            *pValue = decoder->GetBrightness();
            break;
        
        case KSPROPERTY_VIDEOPROCAMP_CONTRAST:
            *pValue = decoder->GetContrast();
            break;

        case KSPROPERTY_VIDEOPROCAMP_HUE:
            *pValue = decoder->GetHue();
            break;

        case KSPROPERTY_VIDEOPROCAMP_SATURATION:
            *pValue = decoder->GetSaturation();
            break;

        default:
            TRAP();
            return STATUS_NOT_IMPLEMENTED;
            break;
        }

    return STATUS_SUCCESS;
}

BOOL Device::SetVideoDecoderStandard(DWORD standard)    //Paul:  Changed
{
    if ( decoder->SetVideoDecoderStandard(standard) )
    {
        switch (standard)
        {
        case KS_AnalogVideo_NTSC_M:
            scaler->VideoFormatChanged( VFormat_NTSC );
            break;
        case KS_AnalogVideo_NTSC_M_J:
            scaler->VideoFormatChanged( VFormat_NTSC_J );
            break;
        case KS_AnalogVideo_PAL_B:
        case KS_AnalogVideo_PAL_D:
        case KS_AnalogVideo_PAL_G:
        case KS_AnalogVideo_PAL_H:
        case KS_AnalogVideo_PAL_I:
            scaler->VideoFormatChanged( VFormat_PAL_BDGHI );    // PAL_BDGHI covers most areas 
            break;
        case KS_AnalogVideo_PAL_M:
            scaler->VideoFormatChanged( VFormat_PAL_M ); 
            break;
        case KS_AnalogVideo_PAL_N:
            scaler->VideoFormatChanged( VFormat_PAL_N_COMB ); 
            break;
        default:    //Paul:  SECAM
            scaler->VideoFormatChanged( VFormat_SECAM );
        }
        //SetRect(destRect);
        return TRUE;
    }
    return FALSE;
}