Directshow使用ffmpeg构建解码filter

Directshow作为windows平台的多媒体开发框架，个人感觉还是不错的。

我做的这个filter是继承于CTransformFilter类，单输入单输出，因为使用的是ffmpeg来解码，因此支持的解码类型就可以多种了，例如mpeg4，avc，mpeg2，我要描述的是关于mpep2-video的解码，闲言少叙，且看代码。

CTransformFilter是Directshow sdk提供的基类，是用来简化单输入单输出filter的开发，尤其是编解码可以继承于该类，来简化开发。

继承CTransformFilter类，需要实现其纯虚函数，查看源码transfrm.h，如下：

// =================================================================
// ----- override these bits ---------------------------------------
// =================================================================

// These must be supplied in a derived class

virtual HRESULT Transform(IMediaSample * pIn, IMediaSample *pOut);

// check if you can support mtIn
virtual HRESULT CheckInputType(const CMediaType* mtIn) PURE;

// check if you can support the transform from this input to this output
virtual HRESULT CheckTransform(const CMediaType* mtIn, const CMediaType* mtOut) PURE;

// this goes in the factory template table to create new instances
// static CCOMObject * CreateInstance(__inout_opt LPUNKNOWN, HRESULT *);

// call the SetProperties function with appropriate arguments
virtual HRESULT DecideBufferSize(
IMemAllocator * pAllocator,
__inout ALLOCATOR_PROPERTIES *pprop) PURE;

// override to suggest OUTPUT pin media types
virtual HRESULT GetMediaType(int iPosition, __inout CMediaType *pMediaType) PURE;

那就开始一个个贴代码吧，顺带再说一句CTransformFilter已经帮我们实现了两个pin，一个输入pin，一个输出pin，在其源码的定义里很清楚。

1. CheckInputType，检查输入格式

HRESULT	CXX::CheckInputType(const CMediaType * mtIn)
{
CheckPointer(mtIn,E_POINTER);
if((mtIn->majortype == MEDIATYPE_Video)
&& (mtIn->subtype == MEDIASUBTYPE_MPEG2_VIDEO)
&& (mtIn->formattype == FORMAT_MPEG2Video))
{
return S_OK;
}
return VFW_E_TYPE_NOT_ACCEPTED;
}

很简单，判断输入类型是否是mpeg2-video。

2.CheckTransform，检查输入类型CheckInputType，并且检查输出类型，这里指定为I420或YV12

HRESULT	CXX::CheckTransform(const CMediaType * mtIn, const CMediaType * mtOut)
{
HRESULT hr;

if(FAILED(hr = CheckInputType(mtIn)))
{
return hr;
}

if(*mtOut->Type() != MEDIATYPE_Video)
{
return VFW_E_TYPE_NOT_ACCEPTED;
}
if(*mtOut->Subtype() != MEDIASUBTYPE_IYUV)
{
return VFW_E_TYPE_NOT_ACCEPTED;
}
if(*mtOut->Subtype() != MEDIASUBTYPE_YV12)
{
return VFW_E_TYPE_NOT_ACCEPTED;
}
}

3. DecideBufferSize，设置buffer的大小及数目，并验证设置是否生效

HRESULT	CXX::DecideBufferSize(IMemAllocator * pAlloc, ALLOCATOR_PROPERTIES * pProperties)
{
HRESULT hr;

AM_MEDIA_TYPE mt;
hr = m_pOutput->ConnectionMediaType(&mt);
if(FAILED(hr))
{
return hr;
}
int imagesize = 0;
if(mt.formattype == FORMAT_VideoInfo)
//VIDEOINFOHEADER * pvih = (VIDEOINFOHEADER *)mt.pbFormat;
//BITMAPINFOHEADER * pbih = &pvih->bmiHeader;
//imagesize = pbih->biSizeImage;
imagesize = VIDEO_FRAME_MAX_SIZE;//这里用的固定大小，类似于1920*1080*4，上述注释的代码可以根据输出pin的媒体类型来计算实际的buffer大小
}else if(mt.formattype == FORMAT_VideoInfo2)
{
//VIDEOINFOHEADER2 * pvih2 = (VIDEOINFOHEADER2 *)mt.pbFormat;
//BITMAPINFOHEADER * pbih = &pvih2->bmiHeader;
//imagesize = pbih->biSizeImage;
imagesize = VIDEO_FRAME_MAX_SIZE;//同上注释
}else
{
ASSERT(FALSE);
}
pProperties->cbBuffer = imagesize * 2;
if(pProperties->cBuffers == 0)
{
pProperties->cBuffers = 1;
}
FreeMediaType(mt);

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

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

return S_OK;
}

4.Transform，实际工作的地方，把输入的码流通过ffmpeg转换为yuv图像，这段代码有点多啊

HRESULT	CXX::Transform(IMediaSample * pIn, IMediaSample * pOut)
{
HRESULT	hr;

int frameSize = pIn->GetActualDataLength();
BYTE * frameData;
hr = pIn->GetPointer(&frameData);//获取输入码流数据
if(FAILED(hr))
{
return hr;
}

long lDestSize = pOut->GetSize();
BYTE * pDst;
hr = pOut->GetPointer(&pDst);//获取输出数据指针
if(FAILED(hr))
{
return hr;
}

int frameFinished;
int init = 0;
int width = 0;
int height = 0;
int decSize	= lDestSize;

AVPacket packet;//ffmpeg相关
av_init_packet(&packet);

packet.size = frameSize;//设置输入数据参数
packet.data = frameData;

if (packet.size > 0)
{
decSize = avcodec_decode_video2(mpCodecCtx, mpFrame, &frameFinished, &packet);
if (decSize < 0)
{
return E_FAIL;
}
else
{
if (frameFinished)
{
memset(mFrameBuff, 0x0, sizeof(mFrameBuff));
unsigned char *buf = mFrameBuff;

int height = mpFrame->height;
int width = mpFrame->width;
decSize = height * width * 3 / 2;

int a=0,i;

for (i=0; i<height; i++)
{
memcpy(buf+a,mpFrame->data[0] + i * mpFrame->linesize[0], width);
a+=width;
}
for (i=0; i<height/2; i++)
{
memcpy(buf+a,mpFrame->data[2] + i * mpFrame->linesize[2], width/2);/* 这边要说明下，我的mpeg2-video解码后的图像在mpFrmae->data里uv反了，因此下面拷贝数据的地方先是data[2]再是data[1]，最终的结果是拼接成一帧I420数据*/
a+=width/2;
}
for (i=0; i<height/2; i++)
{
memcpy(buf+a,mpFrame->data[1] + i * mpFrame->linesize[1], width/2);
a+=width/2;
}

//FILE* testDat = fopen("e:/test.dat", "ab+");
//fwrite(mFrameBuff, decSize, 1, testDat);
//fclose(testDat);
}
else
{
return E_FAIL;
}
}
}
else
{
return E_FAIL;
}

if(mInputFormatId != mOutputFormatId)//ffmpeg解码出来的是I420，可能render需要的是YV12，在这里做转换 
{
memset(mTempBuff, 0x0, sizeof(mTempBuff));
int currentSize = 0;
_changeFormat(mInputFormatId
, mOutputFormatId
, mWidth
, mHeight
, mIsTopBottom
, mFrameBuff
, mTempBuff
, ¤tSize);
memset(mFrameBuff, 0x0, sizeof(mFrameBuff));
memmove(mFrameBuff, mTempBuff, currentSize);
}

if(m_lPitchWidth)//render filter可能要求实际图像字节对齐，在这里做宽度拉伸
{
memset(mTempBuff, 0x0, sizeof(mTempBuff));
_changePitch(mOutputFormatId
, mHeight
, mWidth
, mFrameBuff
, m_lPitchWidth
, mTempBuff
, &decSize);
memmove(pDst, mTempBuff, decSize);
}
else
{
memmove(pDst, mFrameBuff, decSize);
}

hr = pOut->SetActualDataLength(decSize);
if(FAILED(hr))
{
return hr;
}

REFERENCE_TIME rtStart;
REFERENCE_TIME rtStop;
pIn->GetTime(&rtStart, &rtStop);
pOut->SetTime(&rtStart, &rtStop);

pOut->SetDiscontinuity(FALSE);
pOut->SetPreroll(FALSE);
pOut->SetSyncPoint(TRUE);

return S_OK;
}

上面的格式转换，以及宽度拉伸的函数由于是第三方库，因此没有贴出来。

另外还需要介绍的是SetMediaType函数以及GetMediaType。

GetMediaType即输出pin支持的媒体类型，这里就看transform filter做的是不是很强大，支持多少种输出格式，以下仅仅示例

HRESULT CXX::GetMediaType(int iPosition, CMediaType * pMediaType)
{
if(iPosition < 0)
{
return E_INVALIDARG;
}

if(iPosition >= 2)
{
return VFW_S_NO_MORE_ITEMS;
}
{
GUID 	SubType;
WORD	biBitCount;
DWORD	biCompression;
LONG	biWidth = mWidth;

if(iPosition == 0)
{
// IYUV
SubType = MEDIASUBTYPE_IYUV;
biCompression = MAKEFOURCC('I', 'Y', 'U', 'V');
biBitCount = 12;
biWidth = mWidth;
}
else if(iPosition == 1)
{
// YV12
SubType = MEDIASUBTYPE_YV12;
biCompression = MAKEFOURCC('Y', 'V', '1', '2');
biBitCount = 12;
biWidth = mWidth;
}

AM_MEDIA_TYPE mt;
VIDEOINFOHEADER2 vih;

mt.majortype			= MEDIATYPE_Video;
mt.subtype				= SubType;
mOutputFormatId = _subtypeToFormatId(&mt.subtype);

mt.formattype			= FORMAT_VideoInfo2;
mt.pbFormat				= (BYTE*)&vih;
mt.cbFormat				= sizeof(VIDEOINFOHEADER2);

mt.bFixedSizeSamples	= TRUE;
mt.bTemporalCompression	= FALSE;
mt.lSampleSize			= mWidth * mHeight * biBitCount / 8;
mt.pUnk = NULL;

VIDEOINFOHEADER2 * pvih2 = (VIDEOINFOHEADER2 *)mt.pbFormat;
ZeroMemory(pvih2, sizeof(VIDEOINFOHEADER2));

SetRectEmpty(&(pvih2->rcSource));
SetRectEmpty(&(pvih2->rcTarget));

pvih2->bmiHeader.biWidth		= mWidth;
pvih2->bmiHeader.biHeight		= mHeight;
mIsTopBottom = pvih2->bmiHeader.biHeight < 0 ? true : false;//对于yuv要转换为rgb时有用，需要知道第一个像素点是在top-down还是bottom-up
pvih2->bmiHeader.biPlanes		= 1;
pvih2->bmiHeader.biSize			= sizeof(BITMAPINFOHEADER);
pvih2->bmiHeader.biBitCount		= biBitCount;
pvih2->bmiHeader.biCompression	= biCompression;
pvih2->bmiHeader.biSizeImage	= mWidth * mHeight * biBitCount / 8;

pvih2->dwCopyProtectFlags = 0;
pvih2->dwInterlaceFlags = AMINTERLACE_IsInterlaced | AMINTERLACE_DisplayModeBobOnly;
pvih2->dwPictAspectRatioX = mAspectX * mWidth;
pvih2->dwPictAspectRatioY = mAspectY * mHeight;
pvih2->dwControlFlags = 0;
pvih2->dwReserved2 = 0;

pMediaType->Set(mt);

}
return NOERROR;
}

SetMediaType函数，协商完成后设置具体的类型

HRESULT CXX::SetMediaType(PIN_DIRECTION direction, const CMediaType *pMediaType)
{
LPBITMAPINFOHEADER lpbi = HEADER(pMediaType->Format());
VIDEOINFOHEADER2 *vinfo2 = NULL;
MPEG2VIDEOINFO *mpeg2vinfo = NULL;
BITMAPINFOHEADER *binfo  = NULL;
long lPitchWidth  = 0;
long lPitchHeight = 0;

if(direction == PINDIR_INPUT)
{
AM_MEDIA_TYPE mt;
mt = (AM_MEDIA_TYPE)(*pMediaType);
if(pMediaType->formattype == FORMAT_MPEG2Video)
{
mpeg2vinfo = (MPEG2VIDEOINFO*)pMediaType->pbFormat;
vinfo2 = &mpeg2vinfo->hdr;
}

if(vinfo2)
{
mWidth  = vinfo2->rcSource.right;
mHeight = vinfo2->rcSource.bottom;
if(mWidth  < 0)
{
mWidth *= -1;
}
if(mHeight < 0)
{
mHeight *= -1;
}

mAspectX = vinfo2->dwPictAspectRatioX;//此处为图像拉伸比例
mAspectY = vinfo2->dwPictAspectRatioY;
}
}
else // （direction == PINDIR_OUTPUT)
{
AM_MEDIA_TYPE mt;
mt = (AM_MEDIA_TYPE)(*pMediaType);

if(pMediaType->formattype == FORMAT_VideoInfo2)
{
vinfo2 = (VIDEOINFOHEADER2*)pMediaType->pbFormat;
binfo = &vinfo2->bmiHeader;
}

if(binfo)
{
lPitchWidth  = binfo->biWidth;
lPitchHeight = binfo->biHeight;
if(lPitchWidth  < 0)
{
lPitchWidth *= -1;
}
if(lPitchHeight < 0)
{
lPitchHeight *= -1;
}
}
m_lPitchWidth  = lPitchWidth;//实际协商后的宽度，可能和实际图像的宽度不一致，因为需要字节对齐
m_lPitchHeight = lPitchHeight;

binfo->biWidth = mWidth;
binfo->biHeight = mHeight;
}

// Pass the call up to my base class
HRESULT hr = CTransformFilter::SetMediaType(direction, pMediaType);
if(SUCCEEDED(hr))
{
return NOERROR;
}
else
{
return hr;
}
}

ffmpeg的初始化及释放，单独贴出，可以放在构造函数、析构函数里面，

// init ffmpeg
av_register_all();

mpCodec = avcodec_find_decoder(AV_CODEC_ID_MPEG2VIDEO);
if(mpCodec == NULL)
{
return;
}

mpCodecCtx = avcodec_alloc_context3(mpCodec);
if(mpCodecCtx == NULL)
{
return;
}

if(avcodec_open2(mpCodecCtx, mpCodec, NULL) < 0)
{
return ;
}

mpFrame = avcodec_alloc_frame();
if(mpFrame == NULL)
{
return;
}

if (mpCodecCtx)
{
avcodec_close(mpCodecCtx);
av_free(mpCodecCtx);
}

if (mpFrame)
{
avcodec_free_frame(&mpFrame);
}

至于用于filter注册的几个函数就不贴代码了。以上代码仅仅作为参考，应该很少有和我的需求相像的，只是描述在做编解码Transform filter时的大致流程，以及各个虚函数可以用来做什么工作，仅此而已啊。