tuneprop.cpp

传说中的 视频抓取驱动源码 啊啊啊啊啊啊啊啊啊啊啊啊啊

//==========================================================================;
//
//  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.
//
//==========================================================================;

extern "C"
{
#include "strmini.h"
#include "ksmedia.h"

#include "wdmdebug.h"
}

#include "wdmdrv.h"
#include "atitunep.h"
#include "aticonfg.h"


/*^^*
 *      AdapterGetProperty()
 * Purpose  : Called when SRB_GET_PROPERTY SRB is received.
 *
 * Inputs   :   PHW_STREAM_REQUEST_BLOCK pSrb   : pointer to the current Srb
 *
 * Outputs  : BOOL : returns returns FALSE, if it is not a TVTuner property
 *              it also returns the required property
 * Author   : IKLEBANOV
 *^^*/
BOOL CATIWDMTuner::AdapterGetProperty( PHW_STREAM_REQUEST_BLOCK pSrb)
{
    PSTREAM_PROPERTY_DESCRIPTOR pSpd = pSrb->CommandData.PropertyInfo;
    ULONG   uiPropertyId = pSpd->Property->Id;              // index of the property
    BOOL    bResult = FALSE;

    if( !::IsEqualGUID(( const struct _GUID &)PROPSETID_TUNER, ( const struct _GUID &)pSpd->Property->Set))
        return( bResult);

    if(( pSpd == NULL) || ( pSpd->PropertyInfo == NULL))
        return( bResult);
    
    OutputDebugInfo(( "CATIWDMTuner:AdapterGetProperty() Id = %d\n", uiPropertyId));

    bResult = TRUE;

    switch( uiPropertyId)
    {
    case KSPROPERTY_TUNER_CAPS:
        ASSERT( pSpd->PropertyOutputSize >= sizeof( KSPROPERTY_TUNER_CAPS_S));
        {
            KSPIN_MEDIUM NoPinMedium;
            PKSPROPERTY_TUNER_CAPS_S pTunerCaps = ( PKSPROPERTY_TUNER_CAPS_S)pSpd->PropertyInfo;

            // Copy the input property info to the output property info
            ::RtlCopyMemory( pTunerCaps, pSpd->Property, sizeof( KSPROPERTY_TUNER_CAPS_S));

            pTunerCaps->ModesSupported = m_ulSupportedModes;

            NoPinMedium.Set = GUID_NULL;
            NoPinMedium.Id = 0;
            NoPinMedium.Flags = 0;

            switch( m_ulNumberOfPins)
            {
            case 2:
            case 3:
                // TVTuner with TVAudio
/*
                pTunerCaps->VideoMedium = &m_pTVTunerPinsMediumInfo[0];
                pTunerCaps->TVAudioMedium = &m_pTVTunerPinsMediumInfo[1];
                pTunerCaps->RadioAudioMedium = ( m_ulNumberOfPins == 3) ?
                    &m_pTVTunerPinsMediumInfo[2] : NULL;
*/
                pTunerCaps->VideoMedium = m_pTVTunerPinsMediumInfo[0];
                pTunerCaps->TVAudioMedium = m_pTVTunerPinsMediumInfo[1];
                pTunerCaps->RadioAudioMedium = ( m_ulNumberOfPins == 3) ?
                    m_pTVTunerPinsMediumInfo[2] : NoPinMedium;
                break;

            case 1:
                // it can be FM Tuner only.
/*
                pTunerCaps->VideoMedium = NULL;
                pTunerCaps->TVAudioMedium = NULL;
                pTunerCaps->RadioAudioMedium = &m_pTVTunerPinsMediumInfo[0];
*/
                pTunerCaps->VideoMedium = NoPinMedium;
                pTunerCaps->TVAudioMedium = NoPinMedium;
                pTunerCaps->RadioAudioMedium = m_pTVTunerPinsMediumInfo[0];
                break;
            }

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

    case KSPROPERTY_TUNER_MODE_CAPS:
        ASSERT( pSpd->PropertyOutputSize >= sizeof( KSPROPERTY_TUNER_MODE_CAPS_S));
        {
            PKSPROPERTY_TUNER_MODE_CAPS_S   pTunerModeCaps = ( PKSPROPERTY_TUNER_MODE_CAPS_S)pSpd->PropertyInfo;
            ULONG                           ulOperationMode = (( PKSPROPERTY_TUNER_MODE_CAPS_S)pSpd->Property)->Mode;

            // Copy the input property info to the output property info
            ::RtlCopyMemory( pTunerModeCaps, pSpd->Property, sizeof( PKSPROPERTY_TUNER_MODE_CAPS_S));

            if( !( ulOperationMode & m_ulSupportedModes))
            {
                TRAP;
                bResult = FALSE;
                break;
            }

            // There is support for TVTuner at this tinme only. It will be enchanced later on to
            // support FM Tuner as well.
            switch( ulOperationMode)
            {
                case KSPROPERTY_TUNER_MODE_TV :
                    ::RtlCopyMemory( &pTunerModeCaps->StandardsSupported, &m_wdmTunerCaps, sizeof( ATI_KSPROPERTY_TUNER_CAPS));
                    break;

                default:
                    bResult = FALSE;
                    break;
            }

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

    case KSPROPERTY_TUNER_MODE:
        ASSERT( pSpd->PropertyOutputSize >= sizeof( KSPROPERTY_TUNER_MODE_S));
        {
            PKSPROPERTY_TUNER_MODE_S pTunerMode = ( PKSPROPERTY_TUNER_MODE_S)pSpd->PropertyInfo;

            // Copy the input property info to the output property info
            ::RtlCopyMemory( pTunerMode, pSpd->Property, sizeof( PKSPROPERTY_TUNER_MODE_S));

            pTunerMode->Mode = m_ulTunerMode;

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

    case KSPROPERTY_TUNER_STANDARD:
        ASSERT( pSpd->PropertyOutputSize >= sizeof( KSPROPERTY_TUNER_STANDARD_S));
        {
            PKSPROPERTY_TUNER_STANDARD_S pTunerStandard = ( PKSPROPERTY_TUNER_STANDARD_S)pSpd->PropertyInfo;

            // Copy the input property info to the output property info
            ::RtlCopyMemory( pTunerStandard, pSpd->Property, sizeof( KSPROPERTY_TUNER_STANDARD_S));

            pTunerStandard->Standard = m_ulVideoStandard;

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

    case KSPROPERTY_TUNER_FREQUENCY:
        ASSERT( pSpd->PropertyOutputSize >= sizeof( KSPROPERTY_TUNER_FREQUENCY_S));
        {
            PKSPROPERTY_TUNER_FREQUENCY_S pTunerFrequency = ( PKSPROPERTY_TUNER_FREQUENCY_S)pSpd->PropertyInfo;

            // Copy the input property info to the output property info
            ::RtlCopyMemory( pTunerFrequency, pSpd->Property, sizeof( KSPROPERTY_TUNER_FREQUENCY_S));

            pTunerFrequency->Frequency = m_ulTuningFrequency;

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

    case KSPROPERTY_TUNER_INPUT:
        ASSERT( pSpd->PropertyOutputSize >= sizeof( KSPROPERTY_TUNER_INPUT_S));
        {
            PKSPROPERTY_TUNER_INPUT_S pTunerInput = ( PKSPROPERTY_TUNER_INPUT_S)pSpd->PropertyInfo;

            // Copy the input property info to the output property info
            ::RtlCopyMemory( pTunerInput, pSpd->Property, sizeof( KSPROPERTY_TUNER_INPUT_S));

            pTunerInput->InputIndex = m_ulTunerInput;

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

    case KSPROPERTY_TUNER_STATUS:
        ASSERT( pSpd->PropertyOutputSize >= sizeof( KSPROPERTY_TUNER_STATUS_S));
        {
            BOOL    bBusy;
            LONG    lPLLOffset;
            PKSPROPERTY_TUNER_STATUS_S pTunerStatus = ( PKSPROPERTY_TUNER_STATUS_S)pSpd->PropertyInfo;

            if(( bResult = GetTunerPLLOffsetBusyStatus( &lPLLOffset, &bBusy)))
            {
                OutputDebugInfo(( "CATIWDMTuner:GetStatus() Busy = %d, Quality = %d, Frequency = %ld\n",
                    bBusy, lPLLOffset, m_ulTuningFrequency));

                // Copy the input property info to the output property info
                ::RtlCopyMemory( pTunerStatus, pSpd->Property, sizeof( KSPROPERTY_TUNER_STATUS_S));

                pTunerStatus->Busy = bBusy;
                if( !bBusy)
                {
                    pTunerStatus->PLLOffset = lPLLOffset;
                    pTunerStatus->CurrentFrequency = m_ulTuningFrequency;
                }

                pSrb->ActualBytesTransferred = sizeof( KSPROPERTY_TUNER_STATUS_S);
            }
            else
            {
                bResult = FALSE;
                OutputDebugError(( "CATIWDMTuner:GetStatus() fails\n"));
            }
        }
        break;

    default:
        TRAP;
        bResult = FALSE;
        break;
    }

    return( bResult);
}



/*^^*
 *      AdapterSetProperty()
 * Purpose  : Called when SRB_GET_PROPERTY SRB is received.
 *
 * Inputs   :   PHW_STREAM_REQUEST_BLOCK pSrb   : pointer to the current Srb
 *
 * Outputs  : BOOL : returns FALSE, if it is not a TVTuner property
 *              it also sets the required property
 * Author   : IKLEBANOV
 *^^*/
BOOL CATIWDMTuner::AdapterSetProperty( PHW_STREAM_REQUEST_BLOCK pSrb)
{

    PSTREAM_PROPERTY_DESCRIPTOR pSpd = pSrb->CommandData.PropertyInfo;
    ULONG uiPropertyId = pSpd->Property->Id;            // index of the property

    if( !::IsEqualGUID( ( const struct _GUID &)PROPSETID_TUNER, ( const struct _GUID &)pSpd->Property->Set))
        return( FALSE);

    OutputDebugInfo(( "CATIWDMTuner:AdapterSetProperty() Id = %d\n", uiPropertyId));