如何设计自定义的transform filter(转)

对于DIrectShow的初学者而言，最大的困难莫过于尝试设计自定义的filter。
设计自定义的transform filter是困难的
因为 首先filter是一种dll （后缀名为.ax）而编写dll工程需要一定的VC基础 所以建议先补充一点dll的知识
其次 dll的注册，GUID的生成和工程的配置都很麻烦。
再次 网上缺乏现成的transform filter的例子。DirectShow给的源码比如NULLINPLACE 和CONTRAST都太复杂，都带有对话框和属性页，不适合初学者，而且这些例子 没有一个涉及到图像格式的转换，而transform filter最大的公用就是媒体类型的转换，因此这些例子不适用
作为一个初学者，我深深受到这些问题的困扰，经过刻苦钻研终于走出了这个泥潭，豁然开朗。于是把它记录下来，希望可以对其他人有帮助，也作为对08年的一个小结。

我的例子是 设计一个 transform filter 把 YUY2 16bit 的媒体转化为RGB24 24bit的类型。
原因是我的摄像头只支持YUY2 16bit这种格式， 我想得到位图。。顺便学习一下Filter的设计

以下为具体步骤：

一 配置开发环境

   1. VC中在Tools->Options->Directories 设置好DirectX SDK的头文件和库文件路径   
   2. 编译了基类源码,生成strmbasd.lib (debug版), strmbase.lib(release版)
   3. VC向导新建一个win32 DLL（empty）工程
   4. Setting->Link->Output file name: YUV2RGBfilter.ax
   5. Setting->Link加入strmbasd.lib winmm.lib quartz.lib vfw32.lib   (注意路径)
   6. 定义一个同名.def文件，加入到工程，内容如下：
         
        LIBRARY YUV2RGBfilter.ax
        EXPORTS
           DllMain              PRIVATE  
           DllGetClassObject    PRIVATE
           DllCanUnloadNow      PRIVATE
           DllRegisterServer    PRIVATE
           DllUnregisterServer PRIVATE

   7.建立一个类 YUV2RGBfilter 建立他的cpp文件和h文件
  
   8. 在YUV2RGBfilter.cpp中定义DLL的入口函数及注册   放在cpp文件的最后

//
// DllEntryPoint
//
extern "C" BOOL WINAPI DllEntryPoint(HINSTANCE, ULONG, LPVOID);

BOOL APIENTRY DllMain(HANDLE hModule,
                      DWORD dwReason,
                      LPVOID lpReserved)
{
return DllEntryPoint((HINSTANCE)(hModule), dwReason, lpReserved);
}

////////////////////////////////////////////////////////////////////////
//
// Exported entry points for registration and unregistration
// (in this case they only call through to default implementations).
//
////////////////////////////////////////////////////////////////////////

STDAPI DllRegisterServer()
{
    return AMovieDllRegisterServer2( TRUE );
}

STDAPI DllUnregisterServer()
{
     return AMovieDllRegisterServer2( FALSE );
}

   9. cpp文件中要包含的头文件

#include <streams.h>
#include <windows.h>
#include <initguid.h>
#include <olectl.h>
#if (1100 > _MSC_VER)
#include <olectlid.h>
#endif
#include "Y2Ruids.h"         // our own public guids
#include "YUV2RGBfilter.h"
  
二 开发Filter

   1. 生成GUID( 命令行模式下运行guidgen工具) 为他建立一个文件Y2Ruids.h 单独引用
#include <initguid.h>
// YUV2toRGB24 Filter Object
// {F91FC8FD-B1A6-49b0-A308-D6EDEAF405DA}
DEFINE_GUID(CLSID_YUV2toRGB24,
0xf91fc8fd, 0xb1a6, 0x49b0, 0xa3, 0x8, 0xd6, 0xed, 0xea, 0xf4, 0x5, 0xda);
      
   2. 构造CYUV2RGBfilter类 继承自CTransformFilter    写在TransformFilter.h中

// ----------------------------------------------------------------------------
// Class definitions of CYUV2RGBfilter
// ----------------------------------------------------------------------------
//
//
class CYUV2RGBfilter : public CTransformFilter
{

    public:
        static CUnknown * WINAPI CreateInstance(LPUNKNOWN punk, HRESULT *phr);

        STDMETHODIMP NonDelegatingQueryInterface(REFIID riid, void ** ppv);
  
        DECLARE_IUNKNOWN;
// override pure virtual function
        HRESULT CheckInputType(const CMediaType *mtIn);
        HRESULT CheckTransform(const CMediaType *mtIn, const CMediaType *mtOut);
        HRESULT DecideBufferSize(IMemAllocator *pAlloc, ALLOCATOR_PROPERTIES *pProp);
        HRESULT GetMediaType(int iPosition, CMediaType *pMediaType);
        HRESULT Transform(IMediaSample *pIn, IMediaSample *pOut);

    private:
        //Constructor
        CYUV2RGBfilter(TCHAR *tszName, LPUNKNOWN punk, HRESULT *phr);
   // member function
   VOID ChangeFormat(AM_MEDIA_TYPE* pAdjustedType);
   DWORD ConvertYUV2toRGB(BYTE* yuv, BYTE* rgb, DWORD dsize);

    // member variable
   const long m_lBufferRequest;
        CCritSec m_Y2RLock;     // To serialise access.
};

   3. 按格式改写构造函数
        //
// CNullInPlace::Constructor
//
CYUV2RGBfilter::CYUV2RGBfilter(TCHAR *tszName,LPUNKNOWN punk,HRESULT *phr) :
    CTransformFilter(tszName, punk, CLSID_YUV2toRGB24),
    m_lBufferRequest(1)
{
ASSERT(tszName);
    ASSERT(phr);
   
} // CYUV2RGBfilter

   4. 改写CTransformFilter五个纯虚函数（最重要的地方）

        HRESULT CheckInputType(const CMediaType *mtIn);
        HRESULT CheckTransform(const CMediaType *mtIn, const CMediaType *mtOut);
        HRESULT DecideBufferSize(IMemAllocator *pAlloc, ALLOCATOR_PROPERTIES *pProp);
        HRESULT GetMediaType(int iPosition, CMediaType *pMediaType);
        HRESULT Transform(IMediaSample *pIn, IMediaSample *pOut);

   5. 设计自己的私有函数 完成一定的功能

   6. 注册Filter信息
      
// 注册信息

//setup data

const AMOVIESETUP_MEDIATYPE
sudPinTypes =   { &MEDIATYPE_Video                // clsMajorType
                , &MEDIASUBTYPE_NULL } ;       // clsMinorType

const AMOVIESETUP_PIN
psudPins[] = { { L"Input"            // strName
               , FALSE               // bRendered
               , FALSE               // bOutput
               , FALSE               // bZero
               , FALSE               // bMany
               , &CLSID_NULL         // clsConnectsToFilter
               , L"Output"           // strConnectsToPin
               , 1                   // nTypes
               , &sudPinTypes }      // lpTypes
             , { L"Output"           // strName
               , FALSE               // bRendered
               , TRUE                // bOutput
               , FALSE               // bZero
               , FALSE               // bMany
               , &CLSID_NULL         // clsConnectsToFilter
               , L"Input"            // strConnectsToPin
               , 1                   // nTypes
               , &sudPinTypes } };   // lpTypes

const AMOVIESETUP_FILTER
sudYUV2RGB = { &CLSID_YUV2toRGB24                 // clsID
            , L"YUV2RGB"                // strName
            , MERIT_DO_NOT_USE                // dwMerit
            , 2                               // nPins
            , psudPins };                     // lpPin

//
// Needed for the CreateInstance mechanism
//
CFactoryTemplate g_Templates[1]=
    {   {L"YUV2RGB"
        , &CLSID_YUV2toRGB24
        , CYUV2RGBfilter::CreateInstance
        , NULL
        , &sudYUV2RGB }
    };
int g_cTemplates = sizeof(g_Templates)/sizeof(g_Templates[0]);

编译成功后生成GrayFilter.ax
命令行运行regsvr32 GrayFilter.ax注册即可 不用反复注册，只用注册一次，如若修改只需将重新编译的.ax覆盖原来的就行了
调试最好在graphEdit中经行 比较方便。

以上就是设计一个filter的总体步骤。

三 下面就关键点 五个重载的纯虚函数做详细介绍。 这才是最关键的地方。

        HRESULT CheckInputType(const CMediaType *mtIn);
        HRESULT CheckTransform(const CMediaType *mtIn, const CMediaType *mtOut);
        HRESULT DecideBufferSize(IMemAllocator *pAlloc, ALLOCATOR_PROPERTIES *pProp);
        HRESULT GetMediaType(int iPosition, CMediaType *pMediaType);
        HRESULT Transform(IMediaSample *pIn, IMediaSample *pOut);
这五个函数全部是都纯虚函数 ，是CTransformFilter为我们提供的接口，必须重载他们才能实例化。
初学者最大的困扰莫过于，是谁调用了这些函数。这些函数调用的时候实参是从哪来的。我一开始就被这些问题困扰。其实DX的帮助文档里就讲的很清楚了只是我一开始没认真看；

CheckInputType是由tranformfiltr的输入pin调用的用来检查本Filter的输入媒体是否合法；
CheckTransform是由tranformfiltr的输出pin调用的用来检查本filter的输出是否和合法；
GetMediaType是有由tranformfiltr的输出pin调用的用来获取该输出端口支持的媒体格式供下游filter的枚举
DecideBufferSize是由tranformfiltr的输出pin调用的来确定buffer的数量和大小
上游filter通过调用filter上输入pin上的IMemInputPin::Receive方法，将sample传递到filter，filter调用CTransformFilter::Transform方法来处理数据

整个过程就是
   输入pin调用CheckInputType来筛选上游过来的媒体类型，如果可以接受 就有输出pin通GetMediaType来枚举输出媒体类型，进一步通过输出pin的CheckTransform来找到与输入媒体类型相融合的输出媒 体类型并选中。在通过DecideBufferSize确定输出buffer的属性，所有的检查和筛选通过以后就可以连接了， 并通过tranform 将输入pin上的sample 传个输出pin输出媒体的类型是由GetMediaType来确定的， 只要媒体类型对应了就可以成功连接但是数据的传送还是要通过transform来实现。理论上对于没有压缩的视频， 一个sample就是一帧的数据，可以精确的量化处理。

要实现输出pin上媒体格式的转化 就必须在在GetMediaType函数中修改新的媒体格式，然后在checkTransform中确认 输出的媒体格式是不是期望的输出。例如 要将YUY2 16bit的媒体格式改为RGB8 8bit的媒体格式 就要做如下修改：

在GetMediaType中

CheckPointer(pMediaType,E_POINTER);
   VIDEOINFO   vih;  
   memset(&vih, 0, sizeof(vih));  
   vih.bmiHeader.biCompression   =   0;  
   vih.bmiHeader.biBitCount      =   8;  
   vih.bmiHeader.biSize          =   40;  
   vih.bmiHeader.biWidth         =   640;  
   vih.bmiHeader.biHeight        =   480;
   vih.bmiHeader.biPlanes        =   1;  
   vih.bmiHeader.biSizeImage     =   307200;  
   vih.bmiHeader.biClrImportant =   0;  
      vih.bmiHeader.biClrUsed   =   256;

//alter the pallete
   for (UINT i=0; i<256; i++)
   {
    vih.bmiColors[i].rgbBlue=(BYTE)i;
    vih.bmiColors[i].rgbRed=(BYTE)i;
    vih.bmiColors[i].rgbGreen=(BYTE)i;
    vih.bmiColors[i].rgbReserved=(BYTE)0;
    }
   pMediaType->SetType(&MEDIATYPE_Video);  
   pMediaType->SetFormatType(&FORMAT_VideoInfo);  
   pMediaType->SetFormat((BYTE*)&vih, sizeof(vih));  
   pMediaType->SetSubtype(&MEDIASUBTYPE_RGB8);  
   pMediaType->SetSampleSize(307200);

return NOERROR;

然后在checkTransform中确认是否是期望的输出

   BITMAPINFOHEADER *pNewType = HEADER(mtOut->Format());

   if ((pNewType->biPlanes==1)
    &&(pNewType->biBitCount==8)
    &&(pNewType->biWidth==640)
    &&(pNewType->biHeight==480)
    &&(pNewType->biClrUsed==256)
    &&(pNewType->biSizeImage==307200))
   {
    return S_OK;
   }

我的实现过程如下

// GetMediaType
//
// I support one type, namely the type of the input pin
// We must be connected to support the single output type
//
HRESULT CYUV2RGBfilter::GetMediaType(int iPosition, CMediaType *pMediaType)
{
    // Is the input pin connected

    if(m_pInput->IsConnected() == FALSE)
    {
        return E_UNEXPECTED;
    }

    // This should never happen

    if(iPosition < 0)
    {
        return E_INVALIDARG;
    }

    // Do we have more items to offer

    if(iPosition > 0)
    {
        return VFW_S_NO_MORE_ITEMS;
    }

    CheckPointer(pMediaType,E_POINTER);

if (iPosition == 0)
{
   HRESULT hr = m_pInput->ConnectionMediaType(pMediaType);
   if (FAILED(hr))
   {
    return hr;
   }
}
// make some appropriate change
ASSERT(pMediaType->formattype == FORMAT_VideoInfo);
pMediaType->subtype = MEDIASUBTYPE_RGB24;
VIDEOINFOHEADER *pVih =
reinterpret_cast<VIDEOINFOHEADER*>(pMediaType->pbFormat);
pVih->bmiHeader.biCompression = 0;
pVih->bmiHeader.biSizeImage = DIBSIZE(pVih->bmiHeader);
pVih->bmiHeader.biBitCount = 24;
pVih->bmiHeader.biHeight = 480;
pVih->bmiHeader.biWidth = 640;
return S_OK;
} // GetMediaType

//
// CheckInputType
//
// Check the input type is OK, return an error otherwise
//
HRESULT CYUV2RGBfilter::CheckInputType(const CMediaType *mtIn)
{
    CheckPointer(mtIn,E_POINTER);
   
    // Check this is a VIDEOINFO type

    if(*mtIn->FormatType() != FORMAT_VideoInfo)
    {
        return E_INVALIDARG;
    }

    if((IsEqualGUID(*mtIn->Type(), MEDIATYPE_Video)) &&
       (IsEqualGUID(*mtIn->Subtype(), MEDIASUBTYPE_YUY2)))
    {
        VIDEOINFO *pvi = (VIDEOINFO *) mtIn->Format();
        if ((pvi->bmiHeader.biBitCount == 16)
    &&(pvi->bmiHeader.biCompression==0))
    return S_OK;
   else
    return FALSE;
    }
    else
    {
        return FALSE;
    }
} // CheckInputType

// CheckTransform
//
// To be able to transform the formats must be compatible
//mtIn YUV2 16bit
//mtOut RGB24 24bit
HRESULT CYUV2RGBfilter::CheckTransform(const CMediaType *mtIn, const CMediaType *mtOut)
{
    CheckPointer(mtIn,E_POINTER);
    CheckPointer(mtOut,E_POINTER);

    HRESULT hr;
    if(FAILED(hr = CheckInputType(mtIn)))
    {
        return hr;
    }
   
    // format must be a VIDEOINFOHEADER
    if((*mtOut->FormatType() != FORMAT_VideoInfo)
   ||(mtOut->cbFormat<sizeof(VIDEOINFOHEADER ))
   ||(mtOut->subtype!=MEDIASUBTYPE_RGB24))
    {
        return E_INVALIDARG;
    }
   BITMAPINFOHEADER *pBmiOut = HEADER(mtOut->pbFormat);
   if ((pBmiOut->biPlanes!=1)
    ||(pBmiOut->biBitCount!=24)
    ||(pBmiOut->biCompression!=0)
    ||(pBmiOut->biWidth!=640)
    ||(pBmiOut->biHeight!=480))
   {
    return E_INVALIDARG;
   }

   return S_OK;
}
// CheckTransform

HRESULT CYUV2RGBfilter::DecideBufferSize(IMemAllocator *pAlloc, ALLOCATOR_PROPERTIES *pProperties)
{
    CheckPointer(pAlloc,E_POINTER);
    CheckPointer(pProperties,E_POINTER);

    // Is the input pin connected

    if(m_pInput->IsConnected() == FALSE)
    {
        return E_UNEXPECTED;
    }

    HRESULT hr = NOERROR;
    pProperties->cBuffers = 1;
    pProperties->cbBuffer = m_pInput->CurrentMediaType().GetSampleSize()*2; //output is double of the input samples

    ASSERT(pProperties->cbBuffer);

    // If we don't have fixed sized samples we must guess some size

    if(!m_pInput->CurrentMediaType().bFixedSizeSamples)
    {
        if(pProperties->cbBuffer < 100000)
        {
            // nothing more than a guess!!
            pProperties->cbBuffer = 100000;
        }
    }

    // Ask the allocator to reserve us some sample memory, NOTE the function
    // can succeed (that is return NOERROR) but still not have allocated the
    // memory that we requested, so we must check we got whatever we wanted

    ALLOCATOR_PROPERTIES Actual;

    hr = pAlloc->SetProperties(pProperties,&Actual);
    if(FAILED(hr))
    {
        return hr;
    }

    ASSERT(Actual.cBuffers == 1);

    if(pProperties->cBuffers > Actual.cBuffers ||
        pProperties->cbBuffer > Actual.cbBuffer)
    {
        return E_FAIL;
    }

    return NOERROR;

} // DecideBufferSize

//
// Transform
//
// Copy the input sample into the output sample
//
//
HRESULT CYUV2RGBfilter::Transform(IMediaSample *pIn, IMediaSample *pOut)
{
    CheckPointer(pIn,E_POINTER);
    CheckPointer(pOut,E_POINTER);

    // Copy the sample data
    BYTE *pSourceBuffer, *pDestBuffer;
    long lSourceSize = pIn->GetActualDataLength();
    long lDestSize = (long)(lSourceSize*1.5);

    pIn->GetPointer(&pSourceBuffer);
    pOut->GetPointer(&pDestBuffer);
//change data
    ConvertYUV2toRGB(pSourceBuffer,pDestBuffer,lSourceSize);
//memset(pDestBuffer,100,lDestSize);
    REFERENCE_TIME TimeStart, TimeEnd;
    if(NOERROR == pIn->GetTime(&TimeStart, &TimeEnd))
    {
        pOut->SetTime(&TimeStart, &TimeEnd);
    }

    LONGLONG MediaStart, MediaEnd;
    if(pIn->GetMediaTime(&MediaStart,&MediaEnd) == NOERROR)
    {
        pOut->SetMediaTime(&MediaStart,&MediaEnd);
    }

    // Copy the Sync point property

    HRESULT hr = pIn->IsSyncPoint();
    if(hr == S_OK)
    {
        pOut->SetSyncPoint(TRUE);
    }
    else if(hr == S_FALSE)
    {
        pOut->SetSyncPoint(FALSE);
    }
    else
    { // an unexpected error has occured...
        return E_UNEXPECTED;
    }

//
    AM_MEDIA_TYPE* pMediaType;
    pIn->GetMediaType(&pMediaType);
ChangeFormat(pMediaType);
    // Copy the media type
    pOut->SetMediaType(pMediaType);

    // Copy the preroll property

    hr = pIn->IsPreroll();
    if(hr == S_OK)
    {
        pOut->SetPreroll(TRUE);
    }
    else if(hr == S_FALSE)
    {
        pOut->SetPreroll(FALSE);
    }
    else
    { // an unexpected error has occured...
        return E_UNEXPECTED;
    }

    // Copy the discontinuity property

    hr = pIn->IsDiscontinuity();

    if(hr == S_OK)
    {
        pOut->SetDiscontinuity(TRUE);
    }
    else if(hr == S_FALSE)
    {
        pOut->SetDiscontinuity(FALSE);
    }
    else
    { // an unexpected error has occured...
        return E_UNEXPECTED;
    }

    // Copy the actual data length
//KASSERT((long)lDestSize <= pOut->GetSize());
    pOut->SetActualDataLength(lDestSize);

    return S_OK;

} // Transform

经过这些步骤就能得到符合功能要求的transform filter
同时经过以上步骤也能对filter开发有个大体的了解

部分类容参考了http://tieba.baidu.com/f?kz=143218826

转自：http://hi.baidu.com/gragonraja/blog/item/b5b6e182c848cc97f603a697 .html