BaseVideoFilter.cpp

/* 
 *      Copyright (C) 2003-2005 Gabest
 *      http://www.gabest.org
 *
 *  This Program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2, or (at your option)
 *  any later version.
 *   
 *  This Program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *  GNU General Public License for more details.
 *   
 *  You should have received a copy of the GNU General Public License
 *  along with GNU Make; see the file COPYING.  If not, write to
 *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. 
 *  http://www.gnu.org/copyleft/gpl.html
 *
 */

#include "StdAfx.h"
#include <mmintrin.h>
#include "BaseVideoFilter.h"
#include "..\..\..\DSUtil\DSUtil.h"
#include "..\..\..\DSUtil\MediaTypes.h"

#include <initguid.h>
#include "..\..\..\..\include\moreuuids.h"

//
// CBaseVideoFilter
//

CBaseVideoFilter::CBaseVideoFilter(TCHAR* pName, LPUNKNOWN lpunk, HRESULT* phr, REFCLSID clsid) 
        : CTransformFilter(pName, lpunk, clsid)
{
        if(phr) *phr = S_OK;

        if(!(m_pInput = new CBaseVideoInputPin(NAME("CBaseVideoInputPin"), this, phr, L"Video"))) *phr = E_OUTOFMEMORY;
        if(FAILED(*phr)) return;

        if(!(m_pOutput = new CBaseVideoOutputPin(NAME("CBaseVideoOutputPin"), this, phr, L"Output"))) *phr = E_OUTOFMEMORY;
        if(FAILED(*phr))  {delete m_pInput, m_pInput = NULL; return;}

        m_wout = m_win = m_w = 0;
        m_hout = m_hin = m_h = 0;
        m_arxout = m_arxin = m_arx = 0;
        m_aryout = m_aryin = m_ary = 0;
}

CBaseVideoFilter::~CBaseVideoFilter()
{
}

int CBaseVideoFilter::GetPinCount()
{
        return 2;
}

CBasePin* CBaseVideoFilter::GetPin(int n)
{
        switch(n)
        {
        case 0: return m_pInput;
        case 1: return m_pOutput;
        }
        return NULL;
}

HRESULT CBaseVideoFilter::Receive(IMediaSample* pIn)
{
        _mm_empty(); // just for safety

        CAutoLock cAutoLock(&m_csReceive);

        HRESULT hr;

    AM_SAMPLE2_PROPERTIES* const pProps = m_pInput->SampleProps();
    if(pProps->dwStreamId != AM_STREAM_MEDIA)
                return m_pOutput->Deliver(pIn);

        AM_MEDIA_TYPE* pmt;
        if(SUCCEEDED(pIn->GetMediaType(&pmt)) && pmt)
        {
                CMediaType mt(*pmt);
                m_pInput->SetMediaType(&mt);
                DeleteMediaType(pmt);
        }

        if(FAILED(hr = Transform(pIn)))
                return hr;

        return S_OK;
}

HRESULT CBaseVideoFilter::GetDeliveryBuffer(int w, int h, IMediaSample** ppOut)
{
        CheckPointer(ppOut, E_POINTER);

        HRESULT hr;

        if(FAILED(hr = ReconnectOutput(w, h)))
                return hr;

        if(FAILED(hr = m_pOutput->GetDeliveryBuffer(ppOut, NULL, NULL, 0)))
                return hr;

        AM_MEDIA_TYPE* pmt;
        if(SUCCEEDED((*ppOut)->GetMediaType(&pmt)) && pmt)
        {
                CMediaType mt = *pmt;
                m_pOutput->SetMediaType(&mt);
                DeleteMediaType(pmt);
        }

        (*ppOut)->SetDiscontinuity(FALSE);
        (*ppOut)->SetSyncPoint(TRUE);

        // FIXME: hell knows why but without this the overlay mixer starts very skippy
        // (don't enable this for other renderers, the old for example will go crazy if you do)
        if(GetCLSID(m_pOutput->GetConnected()) == CLSID_OverlayMixer)
                (*ppOut)->SetDiscontinuity(TRUE);

        return S_OK;
}

HRESULT CBaseVideoFilter::ReconnectOutput(int w, int h)
{
        CMediaType& mt = m_pOutput->CurrentMediaType();

        int w_org = m_w;
        int h_org = m_h;

        bool fForceReconnection = false;
        if(w != m_w || h != m_h)
        {
                fForceReconnection = true;
                m_w = w;
                m_h = h;
        }

        HRESULT hr = S_OK;

        if(fForceReconnection || m_w != m_wout || m_h != m_hout || m_arx != m_arxout || m_ary != m_aryout)
        {
                if(GetCLSID(m_pOutput->GetConnected()) == CLSID_VideoRenderer)
                {
                        NotifyEvent(EC_ERRORABORT, 0, 0);
                        return E_FAIL;
                }

                BITMAPINFOHEADER* bmi = NULL;

                if(mt.formattype == FORMAT_VideoInfo)
                {
                        VIDEOINFOHEADER* vih = (VIDEOINFOHEADER*)mt.Format();
                        SetRect(&vih->rcSource, 0, 0, m_w, m_h);
                        SetRect(&vih->rcTarget, 0, 0, m_w, m_h);
                        bmi = &vih->bmiHeader;
                        bmi->biXPelsPerMeter = m_w * m_ary;
                        bmi->biYPelsPerMeter = m_h * m_arx;
                }
                else if(mt.formattype == FORMAT_VideoInfo2)
                {
                        VIDEOINFOHEADER2* vih = (VIDEOINFOHEADER2*)mt.Format();
                        SetRect(&vih->rcSource, 0, 0, m_w, m_h);
                        SetRect(&vih->rcTarget, 0, 0, m_w, m_h);
                        bmi = &vih->bmiHeader;
                        vih->dwPictAspectRatioX = m_arx;
                        vih->dwPictAspectRatioY = m_ary;
                }

                bmi->biWidth = m_w;
                bmi->biHeight = m_h;
                bmi->biSizeImage = m_w*m_h*bmi->biBitCount>>3;

                hr = m_pOutput->GetConnected()->QueryAccept(&mt);
                ASSERT(SUCCEEDED(hr)); // should better not fail, after all "mt" is the current media type, just with a different resolution
HRESULT hr1 = 0, hr2 = 0;
                CComPtr<IMediaSample> pOut;
                if(SUCCEEDED(hr1 = m_pOutput->GetConnected()->ReceiveConnection(m_pOutput, &mt))
                && SUCCEEDED(hr2 = m_pOutput->GetDeliveryBuffer(&pOut, NULL, NULL, 0)))
                {
                        AM_MEDIA_TYPE* pmt;
                        if(SUCCEEDED(pOut->GetMediaType(&pmt)) && pmt)
                        {
                                CMediaType mt = *pmt;
                                m_pOutput->SetMediaType(&mt);
                                DeleteMediaType(pmt);
                        }
                        else // stupid overlay mixer won't let us know the new pitch...
                        {
                                long size = pOut->GetSize();
                                bmi->biWidth = size / bmi->biHeight * 8 / bmi->biBitCount;
                        }
                }
                else
                {
                        m_w = w_org;
                        m_h = h_org;
                        return E_FAIL;
                }

                m_wout = m_w;
                m_hout = m_h;
                m_arxout = m_arx;
                m_aryout = m_ary;

                // some renderers don't send this
                NotifyEvent(EC_VIDEO_SIZE_CHANGED, MAKELPARAM(m_w, m_h), 0);

                return S_OK;
        }

        return S_FALSE;
}

HRESULT CBaseVideoFilter::CopyBuffer(BYTE* pOut, BYTE* pIn, int w, int h, int pitchIn, const GUID& subtype)
{
        int abs_h = abs(h);
        BYTE* pInYUV[3] = {pIn, pIn + pitchIn*abs_h, pIn + pitchIn*abs_h + (pitchIn>>1)*(abs_h>>1)};
        return CopyBuffer(pOut, pInYUV, w, h, pitchIn, subtype);
}

HRESULT CBaseVideoFilter::CopyBuffer(BYTE* pOut, BYTE** ppIn, int w, int h, int pitchIn, const GUID& subtype)
{
        BITMAPINFOHEADER bihOut;
        ExtractBIH(&m_pOutput->CurrentMediaType(), &bihOut);

        int pitchOut = 0;

        if(bihOut.biCompression == BI_RGB || bihOut.biCompression == BI_BITFIELDS)
        {
                pitchOut = bihOut.biWidth*bihOut.biBitCount>>3;

                if(bihOut.biHeight > 0)
                {
                        pOut += pitchOut*(h-1);
                        pitchOut = -pitchOut;
                        if(h < 0) h = -h;
                }
        }

        if(h < 0)
        {
                h = -h;
                ppIn[0] += pitchIn*(h-1);
                ppIn[1] += (pitchIn>>1)*((h>>1)-1);
                ppIn[2] += (pitchIn>>1)*((h>>1)-1);
                pitchIn = -pitchIn;
        }

        if(subtype == MEDIASUBTYPE_I420 || subtype == MEDIASUBTYPE_IYUV || subtype == MEDIASUBTYPE_YV12)
        {
                BYTE* pIn = ppIn[0];
                BYTE* pInU = ppIn[1];
                BYTE* pInV = ppIn[2];

                if(subtype == MEDIASUBTYPE_YV12) {BYTE* tmp = pInU; pInU = pInV; pInV = tmp;}

                BYTE* pOutU = pOut + bihOut.biWidth*h;
                BYTE* pOutV = pOut + bihOut.biWidth*h*5/4;

                if(bihOut.biCompression == '21VY') {BYTE* tmp = pOutU; pOutU = pOutV; pOutV = tmp;}

                ASSERT(w <= abs(pitchIn));

                if(bihOut.biCompression == '2YUY')
                {
                        BitBltFromI420ToYUY2(w, h, pOut, bihOut.biWidth*2, pIn, pInU, pInV, pitchIn);
                }
                else if(bihOut.biCompression == '024I' || bihOut.biCompression == 'VUYI' || bihOut.biCompression == '21VY')
                {
                        BitBltFromI420ToI420(w, h, pOut, pOutU, pOutV, bihOut.biWidth, pIn, pInU, pInV, pitchIn);
                }
                else if(bihOut.biCompression == BI_RGB || bihOut.biCompression == BI_BITFIELDS)
                {
                        if(!BitBltFromI420ToRGB(w, h, pOut, pitchOut, bihOut.biBitCount, pIn, pInU, pInV, pitchIn))
                        {
                                for(DWORD y = 0; y < h; y++, pOut += pitchOut)
                                        memset(pOut, 0, pitchOut);
                        }
                }
        }
        else if(subtype == MEDIASUBTYPE_YUY2)
        {
                if(bihOut.biCompression == '2YUY')
                {
                        BitBltFromYUY2ToYUY2(w, h, pOut, bihOut.biWidth*2, ppIn[0], pitchIn);
                }
                else if(bihOut.biCompression == BI_RGB || bihOut.biCompression == BI_BITFIELDS)
                {
                        if(!BitBltFromYUY2ToRGB(w, h, pOut, pitchOut, bihOut.biBitCount, ppIn[0], pitchIn))
                        {
                                for(DWORD y = 0; y < h; y++, pOut += pitchOut)
                                        memset(pOut, 0, pitchOut);
                        }
                }
        }
        else if(subtype == MEDIASUBTYPE_ARGB32 || subtype == MEDIASUBTYPE_RGB32 || subtype == MEDIASUBTYPE_RGB24 || subtype == MEDIASUBTYPE_RGB565)
        {
                int sbpp = 
                        subtype == MEDIASUBTYPE_ARGB32 || subtype == MEDIASUBTYPE_RGB32 ? 32 :
                        subtype == MEDIASUBTYPE_RGB24 ? 24 :
                        subtype == MEDIASUBTYPE_RGB565 ? 16 : 0;

                if(bihOut.biCompression == '2YUY')
                {
                        // TODO
                        // BitBltFromRGBToYUY2();
                }
                else if(bihOut.biCompression == BI_RGB || bihOut.biCompression == BI_BITFIELDS)
                {
                        if(!BitBltFromRGBToRGB(w, h, pOut, pitchOut, bihOut.biBitCount, ppIn[0], pitchIn, sbpp))
                        {
                                for(DWORD y = 0; y < h; y++, pOut += pitchOut)
                                        memset(pOut, 0, pitchOut);
                        }
                }
        }
        else
        {
                return VFW_E_TYPE_NOT_ACCEPTED;
        }

        return S_OK;
}

HRESULT CBaseVideoFilter::CheckInputType(const CMediaType* mtIn)
{
        BITMAPINFOHEADER bih;
        ExtractBIH(mtIn, &bih);

        return mtIn->majortype == MEDIATYPE_Video 
                && (mtIn->subtype == MEDIASUBTYPE_YV12 
                 || mtIn->subtype == MEDIASUBTYPE_I420 
                 || mtIn->subtype == MEDIASUBTYPE_IYUV
                 || mtIn->subtype == MEDIASUBTYPE_YUY2
                 || mtIn->subtype == MEDIASUBTYPE_ARGB32
                 || mtIn->subtype == MEDIASUBTYPE_RGB32
                 || mtIn->subtype == MEDIASUBTYPE_RGB24
                 || mtIn->subtype == MEDIASUBTYPE_RGB565)
                && (mtIn->formattype == FORMAT_VideoInfo 
                 || mtIn->formattype == FORMAT_VideoInfo2)
                && bih.biHeight > 0
                ? S_OK
                : VFW_E_TYPE_NOT_ACCEPTED;
}

HRESULT CBaseVideoFilter::CheckTransform(const CMediaType* mtIn, const CMediaType* mtOut)
{
        if(FAILED(CheckInputType(mtIn)) || mtOut->majortype != MEDIATYPE_Video)
                return VFW_E_TYPE_NOT_ACCEPTED;

        if(mtIn->majortype == MEDIATYPE_Video 
        && (mtIn->subtype == MEDIASUBTYPE_YV12 
         || mtIn->subtype == MEDIASUBTYPE_I420 
         || mtIn->subtype == MEDIASUBTYPE_IYUV))
        {
                if(mtOut->subtype != MEDIASUBTYPE_YV12
                && mtOut->subtype != MEDIASUBTYPE_I420
                && mtOut->subtype != MEDIASUBTYPE_IYUV
                && mtOut->subtype != MEDIASUBTYPE_YUY2
                && mtOut->subtype != MEDIASUBTYPE_ARGB32
                && mtOut->subtype != MEDIASUBTYPE_RGB32
                && mtOut->subtype != MEDIASUBTYPE_RGB24
                && mtOut->subtype != MEDIASUBTYPE_RGB565)
                        return VFW_E_TYPE_NOT_ACCEPTED;
        }
        else if(mtIn->majortype == MEDIATYPE_Video 
        && (mtIn->subtype == MEDIASUBTYPE_YUY2))
        {
                if(mtOut->subtype != MEDIASUBTYPE_YUY2
                && mtOut->subtype != MEDIASUBTYPE_ARGB32
                && mtOut->subtype != MEDIASUBTYPE_RGB32
                && mtOut->subtype != MEDIASUBTYPE_RGB24
                && mtOut->subtype != MEDIASUBTYPE_RGB565)
                        return VFW_E_TYPE_NOT_ACCEPTED;
        }
        else if(mtIn->majortype == MEDIATYPE_Video 
        && (mtIn->subtype == MEDIASUBTYPE_ARGB32
        || mtIn->subtype == MEDIASUBTYPE_RGB32
        || mtIn->subtype == MEDIASUBTYPE_RGB24
        || mtIn->subtype == MEDIASUBTYPE_RGB565))
        {
                if(mtOut->subtype != MEDIASUBTYPE_ARGB32
                && mtOut->subtype != MEDIASUBTYPE_RGB32
                && mtOut->subtype != MEDIASUBTYPE_RGB24
                && mtOut->subtype != MEDIASUBTYPE_RGB565)
                        return VFW_E_TYPE_NOT_ACCEPTED;
        }

        return S_OK;
}

HRESULT CBaseVideoFilter::CheckOutputType(const CMediaType& mtOut)
{
        int wout = 0, hout = 0, arxout = 0, aryout = 0;
        return ExtractDim(&mtOut, wout, hout, arxout, aryout)
                && m_h == abs((int)hout)
                && mtOut.subtype != MEDIASUBTYPE_ARGB32
                ? S_OK
                : VFW_E_TYPE_NOT_ACCEPTED;
}

HRESULT CBaseVideoFilter::DecideBufferSize(IMemAllocator* pAllocator, ALLOCATOR_PROPERTIES* pProperties)
{
        if(m_pInput->IsConnected() == FALSE) return E_UNEXPECTED;

        BITMAPINFOHEADER bih;
        ExtractBIH(&m_pOutput->CurrentMediaType(), &bih);

        pProperties->cBuffers = 1;
        pProperties->cbBuffer = bih.biSizeImage;
        pProperties->cbAlign = 1;
        pProperties->cbPrefix = 0;

        HRESULT hr;
        ALLOCATOR_PROPERTIES Actual;
    if(FAILED(hr = pAllocator->SetProperties(pProperties, &Actual))) 
                return hr;

    return pProperties->cBuffers > Actual.cBuffers || pProperties->cbBuffer > Actual.cbBuffer
                ? E_FAIL
                : NOERROR;
}

HRESULT CBaseVideoFilter::GetMediaType(int iPosition, CMediaType* pmt)
{
    if(m_pInput->IsConnected() == FALSE) return E_UNEXPECTED;

        struct {const GUID* subtype; WORD biPlanes, biBitCount; DWORD biCompression;} fmts[] =
        {
                {&MEDIASUBTYPE_YV12, 3, 12, '21VY'},
                {&MEDIASUBTYPE_I420, 3, 12, '024I'},
                {&MEDIASUBTYPE_IYUV, 3, 12, 'VUYI'},
                {&MEDIASUBTYPE_YUY2, 1, 16, '2YUY'},
                {&MEDIASUBTYPE_ARGB32, 1, 32, BI_RGB},
                {&MEDIASUBTYPE_RGB32, 1, 32, BI_RGB},
                {&MEDIASUBTYPE_RGB24, 1, 24, BI_RGB},
                {&MEDIASUBTYPE_RGB565, 1, 16, BI_RGB},
                {&MEDIASUBTYPE_RGB555, 1, 16, BI_RGB},
                {&MEDIASUBTYPE_ARGB32, 1, 32, BI_BITFIELDS},
                {&MEDIASUBTYPE_RGB32, 1, 32, BI_BITFIELDS},
                {&MEDIASUBTYPE_RGB24, 1, 24, BI_BITFIELDS},
                {&MEDIASUBTYPE_RGB565, 1, 16, BI_BITFIELDS},
                {&MEDIASUBTYPE_RGB555, 1, 16, BI_BITFIELDS},
        };

        // this will make sure we won't connect to the old renderer in dvd mode
        // that renderer can't switch the format dynamically

        bool fFoundDVDNavigator = false;
        CComPtr<IBaseFilter> pBF = this;
        CComPtr<IPin> pPin = m_pInput;
        for(; !fFoundDVDNavigator && (pBF = GetFilterFromPin(GetUpStreamPin(pBF, pPin))); pPin = GetFirstPin(pBF))
        fFoundDVDNavigator = GetCLSID(pBF) == CLSID_DVDNavigator;

        if(fFoundDVDNavigator || m_pInput->CurrentMediaType().formattype == FORMAT_VideoInfo2)
                iPosition = iPosition*2;

        //

        if(iPosition < 0) return E_INVALIDARG;
        if(iPosition >= 2*countof(fmts)) return VFW_S_NO_MORE_ITEMS;

        pmt->majortype = MEDIATYPE_Video;
        pmt->subtype = *fmts[iPosition/2].subtype;

        int w = m_win, h = m_hin, arx = m_arxin, ary = m_aryin;
        GetOutputSize(w, h, arx, ary);

        BITMAPINFOHEADER bihOut;
        memset(&bihOut, 0, sizeof(bihOut));
        bihOut.biSize = sizeof(bihOut);
        bihOut.biWidth = w;
        bihOut.biHeight = h;
        bihOut.biPlanes = fmts[iPosition/2].biPlanes;
        bihOut.biBitCount = fmts[iPosition/2].biBitCount;
        bihOut.biCompression = fmts[iPosition/2].biCompression;
        bihOut.biSizeImage = w*h*bihOut.biBitCount>>3;

        if(iPosition&1)
        {
                pmt->formattype = FORMAT_VideoInfo;
                VIDEOINFOHEADER* vih = (VIDEOINFOHEADER*)pmt->AllocFormatBuffer(sizeof(VIDEOINFOHEADER));
                memset(vih, 0, sizeof(VIDEOINFOHEADER));
                vih->bmiHeader = bihOut;
                vih->bmiHeader.biXPelsPerMeter = vih->bmiHeader.biWidth * ary;
                vih->bmiHeader.biYPelsPerMeter = vih->bmiHeader.biHeight * arx;
        }
        else
        {
                pmt->formattype = FORMAT_VideoInfo2;
                VIDEOINFOHEADER2* vih = (VIDEOINFOHEADER2*)pmt->AllocFormatBuffer(sizeof(VIDEOINFOHEADER2));
                memset(vih, 0, sizeof(VIDEOINFOHEADER2));
                vih->bmiHeader = bihOut;
                vih->dwPictAspectRatioX = arx;
                vih->dwPictAspectRatioY = ary;
                vih->dwCopyProtectFlags &= ~AMCOPYPROTECT_RestrictDuplication; // hehe
        }

        CMediaType& mt = m_pInput->CurrentMediaType();

        // these fields have the same field offset in all four structs
        ((VIDEOINFOHEADER*)pmt->Format())->AvgTimePerFrame = ((VIDEOINFOHEADER*)mt.Format())->AvgTimePerFrame;
        ((VIDEOINFOHEADER*)pmt->Format())->dwBitRate = ((VIDEOINFOHEADER*)mt.Format())->dwBitRate;
        ((VIDEOINFOHEADER*)pmt->Format())->dwBitErrorRate = ((VIDEOINFOHEADER*)mt.Format())->dwBitErrorRate;

        CorrectMediaType(pmt);

        return S_OK;
}

HRESULT CBaseVideoFilter::SetMediaType(PIN_DIRECTION dir, const CMediaType* pmt)
{
        if(dir == PINDIR_INPUT)
        {
                m_w = m_h = m_arx = m_ary = 0;
                ExtractDim(pmt, m_w, m_h, m_arx, m_ary);
                m_win = m_w;
                m_hin = m_h;
                m_arxin = m_arx;
                m_aryin = m_ary;
                GetOutputSize(m_w, m_h, m_arx, m_ary);
        }
        else if(dir == PINDIR_OUTPUT)
        {
                int wout = 0, hout = 0, arxout = 0, aryout = 0;
                ExtractDim(pmt, wout, hout, arxout, aryout);
                if(m_w == wout && m_h == hout && m_arx == arxout && m_ary == aryout)
                {
                        m_wout = wout;
                        m_hout = hout;
                        m_arxout = arxout;
                        m_aryout = aryout;
                }
        }

        return __super::SetMediaType(dir, pmt);
}

//
// CBaseVideoInputAllocator
//
        
CBaseVideoInputAllocator::CBaseVideoInputAllocator(HRESULT* phr)
        : CMemAllocator(NAME("CBaseVideoInputAllocator"), NULL, phr)
{
        if(phr) *phr = S_OK;
}

void CBaseVideoInputAllocator::SetMediaType(const CMediaType& mt)
{
        m_mt = mt;
}

STDMETHODIMP CBaseVideoInputAllocator::GetBuffer(IMediaSample** ppBuffer, REFERENCE_TIME* pStartTime, REFERENCE_TIME* pEndTime, DWORD dwFlags)
{
        if(!m_bCommitted)
        return VFW_E_NOT_COMMITTED;

        HRESULT hr = __super::GetBuffer(ppBuffer, pStartTime, pEndTime, dwFlags);

        if(SUCCEEDED(hr) && m_mt.majortype != GUID_NULL)
        {
                (*ppBuffer)->SetMediaType(&m_mt);
                m_mt.majortype = GUID_NULL;
        }

        return hr;
}

//
// CBaseVideoInputPin
//

CBaseVideoInputPin::CBaseVideoInputPin(TCHAR* pObjectName, CBaseVideoFilter* pFilter, HRESULT* phr, LPCWSTR pName) 
        : CTransformInputPin(pObjectName, pFilter, phr, pName)
        , m_pAllocator(NULL)
{
}

CBaseVideoInputPin::~CBaseVideoInputPin()
{
        delete m_pAllocator;
}

STDMETHODIMP CBaseVideoInputPin::GetAllocator(IMemAllocator** ppAllocator)
{
    CheckPointer(ppAllocator, E_POINTER);

    if(m_pAllocator == NULL)
        {
                HRESULT hr = S_OK;
        m_pAllocator = new CBaseVideoInputAllocator(&hr);
        m_pAllocator->AddRef();
    }

    (*ppAllocator = m_pAllocator)->AddRef();

    return S_OK;
} 

STDMETHODIMP CBaseVideoInputPin::ReceiveConnection(IPin* pConnector, const AM_MEDIA_TYPE* pmt)
{
        CAutoLock cObjectLock(m_pLock);

        if(m_Connected)
        {
                CMediaType mt(*pmt);

                if(FAILED(CheckMediaType(&mt)))
                        return VFW_E_TYPE_NOT_ACCEPTED;

                ALLOCATOR_PROPERTIES props, actual;

                CComPtr<IMemAllocator> pMemAllocator;
                if(FAILED(GetAllocator(&pMemAllocator))
                || FAILED(pMemAllocator->Decommit())
                || FAILED(pMemAllocator->GetProperties(&props)))
                        return E_FAIL;

                BITMAPINFOHEADER bih;
                if(ExtractBIH(pmt, &bih) && bih.biSizeImage)
                        props.cbBuffer = bih.biSizeImage;

                if(FAILED(pMemAllocator->SetProperties(&props, &actual))
                || FAILED(pMemAllocator->Commit())
                || props.cbBuffer != actual.cbBuffer)
                        return E_FAIL;

                if(m_pAllocator) 
                        m_pAllocator->SetMediaType(mt);

                return SetMediaType(&mt) == S_OK
                        ? S_OK
                        : VFW_E_TYPE_NOT_ACCEPTED;
        }

        return __super::ReceiveConnection(pConnector, pmt);
}

//
// CBaseVideoOutputPin
//

CBaseVideoOutputPin::CBaseVideoOutputPin(TCHAR* pObjectName, CBaseVideoFilter* pFilter, HRESULT* phr, LPCWSTR pName)
        : CTransformOutputPin(pObjectName, pFilter, phr, pName)
{
}

HRESULT CBaseVideoOutputPin::CheckMediaType(const CMediaType* mtOut)
{
        if(IsConnected())
        {
                HRESULT hr = ((CBaseVideoFilter*)m_pFilter)->CheckOutputType(*mtOut);
                if(FAILED(hr)) return hr;
        }

        return __super::CheckMediaType(mtOut);
}

---