capturefilter.cpp

完整的基于Conxant平台的USB电视棒的WIN驱动程序。

NTSTATUS 
CaptureFilter::
setDecoderProp( 
    IRP                        *p_irp, 
    KSPROPERTY_VIDEODECODER_S  *p_in,
    KSPROPERTY_VIDEODECODER_S  *p_out 
    )
{
    Device* p_device = getDevice(p_irp);
    if(!p_device)
    {
        return STATUS_UNSUCCESSFUL;
    }

    p_device->setVideoStandard(p_in->Value);

    return STATUS_SUCCESS;
}


NTSTATUS 
CaptureFilter::
getDecoderProp( 
    IRP         *p_irp, 
    KSPROPERTY  *p_in, 
    void        *p_out 
    )
{
    Device* p_device = getDevice(p_irp);
    if(!p_device)
    {
        return STATUS_UNSUCCESSFUL;
    }
    IVideoDecoder *p_decoder = p_device->getVidDec();;
    
    switch( p_in->Id ) 
    {
    case KSPROPERTY_VIDEODECODER_CAPS:
    {
        KSPROPERTY_VIDEODECODER_CAPS_S *p_struct = 
            (KSPROPERTY_VIDEODECODER_CAPS_S*)p_out;

        p_struct->StandardsSupported = SUPPORTED_ANALOG_VIDEO_STANDARDS;
        p_struct->Capabilities = KS_VIDEODECODER_FLAGS_CAN_INDICATE_LOCKED;
        // How long to delay after tuning before Locked indicator is valid
        p_struct->SettlingTime  = 10; 
        p_struct->HSyncPerVSync = 6;   // HSync per VSync
        break;
    }
    case KSPROPERTY_VIDEODECODER_STANDARD:
    {
        KSPROPERTY_VIDEODECODER_S *p_struct = 
            (KSPROPERTY_VIDEODECODER_S*)p_out;   

        p_struct->Value = p_decoder->getVideoStandard();
        break;
    }
    case KSPROPERTY_VIDEODECODER_STATUS:
    {
        KSPROPERTY_VIDEODECODER_STATUS_S *p_struct = 
            (KSPROPERTY_VIDEODECODER_STATUS_S*)p_out;

        DWORD video_mode = p_decoder->getVideoMode();
        
        p_struct->NumberOfLines = ((video_mode == VIDEO_MODE_NTSC)||(video_mode== VIDEO_MODE_PAL_M)) ? 525 : 625;
        p_struct->SignalLocked  = p_decoder->IsVideoPresent();

        break;
    }
    default:
        DbgLogError(("Unsupported Property id = %x\n", p_in->Id));
        return STATUS_NOT_SUPPORTED;
    }

    return STATUS_SUCCESS;
}


// ------------------------------------------------------------------------
// Property set for VideoProcAmp
// ------------------------------------------------------------------------

//
// First define all of the ranges and stepping values
//

// ------------------------------------------------------------------------
const int BYTE_STEPS     =   255;
const int LOGCL_MIN      =     0;
const int LOGCL_MAX      = 10000;
const int LOGCL_STEP     = LOGCL_MAX / BYTE_STEPS;

const KSPROPERTY_STEPPING_LONG BrightnessRangeAndStep [] =
{
    {
        LOGCL_STEP,        // SteppingDelta (range / steps)
        0,                 // Reserved
        LOGCL_MIN,         // Minimum in (IRE * 100) units
        LOGCL_MAX          // Maximum in (IRE * 100) units
    }
};

const KSPROPERTY_MEMBERSLIST BrightnessMembersList [] =
{
    {
        {
            KSPROPERTY_MEMBER_RANGES,
            sizeof (BrightnessRangeAndStep),
            SIZEOF_ARRAY (BrightnessRangeAndStep),
            0
        },
        (PVOID) BrightnessRangeAndStep,
     },
     {
        {
            KSPROPERTY_MEMBER_VALUES,
            sizeof (BrightnessDefault),
            1,
            KSPROPERTY_MEMBER_FLAG_DEFAULT
        },
        (PVOID) &BrightnessDefault,
    }
};

const KSPROPERTY_VALUES BrightnessValues =
{
    {
        STATICGUIDOF (KSPROPTYPESETID_General),
        VT_I4,
        0
    },
    SIZEOF_ARRAY (BrightnessMembersList),
    BrightnessMembersList
};

// ------------------------------------------------------------------------
const KSPROPERTY_STEPPING_LONG ContrastRangeAndStep [] =
{
    {
        LOGCL_STEP,        // SteppingDelta (range / steps)
        0,                 // Reserved
        LOGCL_MIN,         // Minimum in (gain * 100) units
        LOGCL_MAX          // Maximum in (gain * 100) units
    }
};

const KSPROPERTY_MEMBERSLIST ContrastMembersList [] =
{
    {
        {
            KSPROPERTY_MEMBER_RANGES,
            sizeof (ContrastRangeAndStep),
            SIZEOF_ARRAY (ContrastRangeAndStep),
            0
        },
        (PVOID) ContrastRangeAndStep
     },
     {
        {
            KSPROPERTY_MEMBER_VALUES,
            sizeof (ContrastDefault),
            1,
            KSPROPERTY_MEMBER_FLAG_DEFAULT
        },
        (PVOID) &ContrastDefault,
    }
};

const KSPROPERTY_VALUES ContrastValues =
{
    {
        STATICGUIDOF (KSPROPTYPESETID_General),
        VT_I4,
        0
    },
    SIZEOF_ARRAY (ContrastMembersList),
    ContrastMembersList
};

// ------------------------------------------------------------------------
const KSPROPERTY_STEPPING_LONG HueRangeAndStep [] =
{
   {
      LOGCL_STEP,        // SteppingDelta (range / steps)
      0,                 // Reserved
      {
         {
            LOGCL_MIN,   // Minimum in (gain * 100) units
            LOGCL_MAX    // Maximum in (gain * 100) units
         }
      }
   }
};

const KSPROPERTY_MEMBERSLIST HueMembersList [] =
{
   {
      {
         KSPROPERTY_MEMBER_RANGES,
         sizeof( HueRangeAndStep ),
         SIZEOF_ARRAY( HueRangeAndStep ),
         0
      },
      (PVOID) HueRangeAndStep
   },
   {
     {
         KSPROPERTY_MEMBER_VALUES,
         sizeof( HueDefault ),
         sizeof( HueDefault ),
         KSPROPERTY_MEMBER_FLAG_DEFAULT
     },
     (PVOID) &HueDefault
   }
};

const KSPROPERTY_VALUES HueValues =
{
   {
      {
         STATICGUIDOF( KSPROPTYPESETID_General ),
         VT_I4,
         0
      }
   },
   SIZEOF_ARRAY( HueMembersList ),
   HueMembersList
};

const KSPROPERTY_STEPPING_LONG SaturationRangeAndStep [] =
{
   {
      LOGCL_STEP,        // SteppingDelta (range / steps)
      0,                 // Reserved
      {
         {
            LOGCL_MIN,   // Minimum in (gain * 100) units
            LOGCL_MAX    // Maximum in (gain * 100) units
         }
      }
   }
};



const KSPROPERTY_MEMBERSLIST SaturationMembersList [] =
{
   {
      {
         KSPROPERTY_MEMBER_RANGES,
         sizeof( SaturationRangeAndStep ),
         SIZEOF_ARRAY( SaturationRangeAndStep ),
         0
      },
      (PVOID) SaturationRangeAndStep
   },
   {
     {
         KSPROPERTY_MEMBER_VALUES,
         sizeof( SaturationDefault ),
         sizeof( SaturationDefault ),
         KSPROPERTY_MEMBER_FLAG_DEFAULT
     },
     (PVOID) &SaturationDefault
   }
};

const KSPROPERTY_VALUES SaturationValues =
{
   {
      {
         STATICGUIDOF( KSPROPTYPESETID_General ),
         VT_I4,
         0
      }
   },
   SIZEOF_ARRAY( SaturationMembersList ),
   SaturationMembersList
};


const KSPROPERTY_STEPPING_LONG SharpnessRangeAndStep [] =
{
   {
      10,        // SteppingDelta (range / steps)
      0,                  // Reserved
      {
         {
            0,              // Minimum
            100             // Maximum
         }
      }
   }
};


const KSPROPERTY_MEMBERSLIST SharpnessMembersList [] =
{
   {
      {
         KSPROPERTY_MEMBER_RANGES,
         sizeof( SharpnessRangeAndStep ),
         SIZEOF_ARRAY( SharpnessRangeAndStep ),
         0
      },
      (PVOID) SharpnessRangeAndStep
   },
   {
     {
         KSPROPERTY_MEMBER_VALUES,
         sizeof( SharpnessDefault ),
         sizeof( SharpnessDefault ),
         KSPROPERTY_MEMBER_FLAG_DEFAULT
     },
     (PVOID) &SharpnessDefault
   }
};

const KSPROPERTY_VALUES SharpnessValues =
{
   {
      {
         STATICGUIDOF( KSPROPTYPESETID_General ),
         VT_I4,