capturefilter.cpp

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

/*+++ *******************************************************************\ 
* 
*  Copyright and Disclaimer: 
*  
*     --------------------------------------------------------------- 
*     This software is provided "AS IS" without warranty of any kind, 
*     either expressed or implied, including but not limited to the 
*     implied warranties of noninfringement, merchantability and/or 
*     fitness for a particular purpose.
*     --------------------------------------------------------------- 
*   
*     Copyright (c) 2008 Conexant Systems, Inc. 
*     All rights reserved. 
*
\******************************************************************* ---*/ 

#include "CaptureFilter.h"
#include "Device.h"
#include "PinDataRanges.h"
#include "debug.h"
#include <ksmedia.h>
#include "ivideodecoder.h"
#include "miscfuncs.h"
#include "cxPolarisDiagProp.h"
#include "registryAccess.h"
#include "cxcopyprotectprop.h"
#include "IR_CustomProp.h"
#include "CxPolarisProp.h"
#include "pcbconfig.h"

const 
DWORD 
SUPPORTED_ANALOG_VIDEO_STANDARDS = KS_AnalogVideo_NTSC_M   |
                                   KS_AnalogVideo_NTSC_M_J | 
                                   KS_AnalogVideo_PAL_B    | 
                                   KS_AnalogVideo_PAL_D    | 
                                   KS_AnalogVideo_PAL_G    | 
                                   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  | 
                                   KS_AnalogVideo_SECAM_L1; 


CaptureFilter::
CaptureFilter(
              KSFILTER  *p_ks_filter,
              BOOLEAN use_mpeg1,
              BOOLEAN is_ntsc,
              BOOLEAN is_fullspeed,
              DWORD medium_id,
              DWORD vbi_pin_index):
    _vbi_pin_index( vbi_pin_index ),
    _p_ks_filt( p_ks_filter )
{
    setMediumId(p_ks_filter, CAPTURE_FILTER_VIDEO_IN, medium_id);
    setMediumId(p_ks_filter, CAPTURE_FILTER_AUDIO_IN, medium_id);

    setVideoOutPinCategories(CAPTURE_FILTER_VIDEO_OUT, is_ntsc, is_fullspeed, use_mpeg1);
    if(!is_fullspeed)
    {
        setVideoOutPinCategories(vbi_pin_index, is_ntsc,is_fullspeed);
    }
}


CaptureFilter::
~CaptureFilter()
{
}

/////////////////////////////////////////////////////////////////////////////////////////
// This function may be used on either the capture pin or the 656 output pin

VOID CaptureFilter::setVideoOutPinCategories(DWORD pin_index, BOOLEAN is_ntsc, BOOLEAN is_fullspeed, BOOLEAN using_mpeg1)
{
    DbgLogInfo(("CaptureFilter::setVideoOutPinCategories()\n"));

    NTSTATUS status = editKsFilterPinDescriptors(_p_ks_filt);

    if(NT_SUCCESS(status))
    {
        status = KsEditSized( 
            _p_ks_filt, 
            &_p_ks_filt->Descriptor->PinDescriptors[pin_index].
                PinDescriptor.DataRanges,
            sizeof(KSDATARANGE)*CAPTURE_PIN_DATA_RANGE_COUNT,
            sizeof(KSDATARANGE)*CAPTURE_PIN_DATA_RANGE_COUNT,
            'TXNC');
    }

    // If the KsEdits proceeded without running out of memory, 
    // adjust the framing based on the video info header.
    if(NT_SUCCESS(status)) 
    {
        PKSDATARANGE* p_data_range = 
            (PKSDATARANGE*) _p_ks_filt->Descriptor->PinDescriptors[pin_index].
                PinDescriptor.DataRanges;

        if(is_ntsc)
        {
        	DbgLogInfo(("is ntsc\n"));
            if (pin_index == _vbi_pin_index)
            {
                // NTSC VBI
                DbgLogInfo(("NTSC VBI\n"));
                p_data_range[0] = (PKSDATARANGE)&g_stream_format_VBI;
            }
            else
            {
                if(is_fullspeed)
                {
                    DbgLogInfo(("FORMAT_CXY8_NTSC\n"));
                    p_data_range[0] = (PKSDATARANGE)&FORMAT_UYVY_NTSC;
                    p_data_range[1] = (PKSDATARANGE)&FORMAT_CXY8_NTSC;
                }
                else
                {
                    p_data_range[0] = (PKSDATARANGE)&FORMAT_UYVY_NTSC;
                    p_data_range[1] = (PKSDATARANGE)&FORMAT_UYVY_PAL;
                }
            }
        }
        else
        {
        	DbgLogInfo(("is pal\n"));
            if (pin_index == _vbi_pin_index)
            {
                // PAL VBI
                 DbgLogInfo(("PAL VBI\n"));
                p_data_range[0] = (PKSDATARANGE)&g_stream_format_VBI_PAL;
            }
            else
            {
                if(is_fullspeed)
                {
                    DbgLogInfo(("FORMAT_CXY8_PAL\n"));
                    p_data_range[0] = (PKSDATARANGE)&FORMAT_UYVY_PAL;
                    p_data_range[1] = (PKSDATARANGE)&FORMAT_CXY8_PAL;
                }
                else
                {
                    p_data_range[0] = (PKSDATARANGE)&FORMAT_UYVY_PAL;
                    p_data_range[1] = (PKSDATARANGE)&FORMAT_UYVY_NTSC;
                }
            }
        }
    }
}


NTSTATUS
CaptureFilter::
dispatchCreate(
    KSFILTER  *p_ks_filter, 
    IRP       *p_irp
    )
{
    PAGED_CODE();

    Device* p_device = getDevice(p_irp);

    BOOLEAN is_ntsc = p_device->getVidDec()->getVideoMode() == VIDEO_MODE_NTSC;
    BYTE usb_speed=p_device->getUSBSpeed();
    BOOLEAN is_fullspeed = (usb_speed==FULL_SPEED)?TRUE:FALSE;

    p_ks_filter->Context = new CaptureFilter(
        p_ks_filter, 
        FALSE, 
        is_ntsc,
        is_fullspeed,
        p_device->getMediumId(),
        p_device->getVbiPinIndex());

    if( !p_ks_filter->Context )
        return STATUS_INSUFFICIENT_RESOURCES;

    return STATUS_SUCCESS;
}


NTSTATUS
CaptureFilter::
dispatchClose( 
    KSFILTER  *p_ks_filter, 
    IRP       *p_irp 
    )
{
    delete reinterpret_cast<CaptureFilter*>( p_ks_filter->Context );
    p_ks_filter->Context = NULL;
    return STATUS_SUCCESS;
}

IVideoDecoder* getDecoder(PIRP p_irp)
{
    KSFILTER  *p_ks_filt = KsGetFilterFromIrp(p_irp);
    KSDEVICE  *p_ks_dev  = KsGetDevice(p_ks_filt);
    return ((Device*)p_ks_dev->Context)->getVidDec();
}

NTSTATUS
CaptureFilter::
setProcAmpProp( 
    IRP                       *p_irp, 
    KSPROPERTY_VIDEOPROCAMP_S *p_in,
    KSPROPERTY_VIDEOPROCAMP_S *p_out 
    )
{
    IVideoDecoder *p_decoder = getDecoder( p_irp );

    switch( p_in->Property.Id ) 
    {
    case KSPROPERTY_VIDEOPROCAMP_BRIGHTNESS:
        if(!p_decoder->setBrightness(p_in->Value))
        {
            return STATUS_INVALID_PARAMETER;
        }
        break;
        
    case KSPROPERTY_VIDEOPROCAMP_CONTRAST:
        if(!p_decoder->setContrast(p_in->Value))
        {
            return STATUS_INVALID_PARAMETER;
        }
        break;

    case KSPROPERTY_VIDEOPROCAMP_HUE:
        if(!p_decoder->setHue(p_in->Value))
        {
            return STATUS_INVALID_PARAMETER;
        }
        break;

    case KSPROPERTY_VIDEOPROCAMP_SATURATION:
        if(!p_decoder->setSaturation(p_in->Value))
        {
            return STATUS_INVALID_PARAMETER;
        }
        break;

    case KSPROPERTY_VIDEOPROCAMP_SHARPNESS:
        if(!p_decoder->setSharpness(p_in->Value))
        {
            return STATUS_INVALID_PARAMETER;
        }
        break;

    case KSPROPERTY_VIDEOPROCAMP_GAMMA:
//        if( p_decoder->SetGamma( p_in->Value ) == Fail )
//            return STATUS_INVALID_PARAMETER;
        break;

    case KSPROPERTY_VIDEOPROCAMP_COLORENABLE:
//        if( p_decoder->SetColorEnable( p_in->Value ) == Fail )
//            return STATUS_INVALID_PARAMETER;
        break;

    default:
        return STATUS_NOT_SUPPORTED;
    }

    return STATUS_SUCCESS;
}


NTSTATUS 
CaptureFilter::
getProcAmpProp( 
    IRP                       *p_irp, 
    KSPROPERTY_VIDEOPROCAMP_S *p_in,
    KSPROPERTY_VIDEOPROCAMP_S *p_out 
    )
{
    IVideoDecoder *p_decoder = getDecoder( p_irp );

    switch( p_in->Property.Id ) 
    {
    case KSPROPERTY_VIDEOPROCAMP_BRIGHTNESS:
        p_out->Value = p_decoder->getBrightness();
        break;

    case KSPROPERTY_VIDEOPROCAMP_CONTRAST:
        p_out->Value = p_decoder->getContrast();
        break;

    case KSPROPERTY_VIDEOPROCAMP_HUE:
        p_out->Value = p_decoder->getHue();
        break;

    case KSPROPERTY_VIDEOPROCAMP_SATURATION:
        p_out->Value = p_decoder->getSaturation();
        break;

    case KSPROPERTY_VIDEOPROCAMP_SHARPNESS:
        p_out->Value = p_decoder->getSharpness();
        break;

    case KSPROPERTY_VIDEOPROCAMP_GAMMA:
//        p_out->Value = p_decoder->GetGamma();
        break;

    case KSPROPERTY_VIDEOPROCAMP_COLORENABLE:
//        p_out->Value = p_decoder->GetColorEnable();
        break;

    default:
        return STATUS_NOT_SUPPORTED;
    }

    p_out->Flags        = KSPROPERTY_VIDEOPROCAMP_FLAGS_MANUAL;
    p_out->Capabilities = KSPROPERTY_VIDEOPROCAMP_FLAGS_MANUAL;

    return STATUS_SUCCESS;
}