/* * Copyright 2013 Jacek Caban for CodeWeavers * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library 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 * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ #include <stdarg.h> #define COBJMACROS #include "windef.h" #include "winbase.h" #include "dshow.h" #include "vfw.h" #include "aviriff.h" #include "qcap_main.h" #include "wine/debug.h" WINE_DEFAULT_DEBUG_CHANNEL(qcap); typedef struct { BaseFilter filter; IPersistPropertyBag IPersistPropertyBag_iface; BaseInputPin *in; BaseOutputPin *out; DWORD fcc_handler; HIC hic; VIDEOINFOHEADER *videoinfo; size_t videoinfo_size; DWORD driver_flags; DWORD max_frame_size; DWORD frame_cnt; } AVICompressor; static inline AVICompressor *impl_from_BaseFilter(BaseFilter *filter) { return CONTAINING_RECORD(filter, AVICompressor, filter); } static inline AVICompressor *impl_from_IBaseFilter(IBaseFilter *iface) { BaseFilter *filter = CONTAINING_RECORD(iface, BaseFilter, IBaseFilter_iface); return impl_from_BaseFilter(filter); } static inline AVICompressor *impl_from_BasePin(BasePin *pin) { return impl_from_IBaseFilter(pin->pinInfo.pFilter); } static HRESULT ensure_driver(AVICompressor *This) { if(This->hic) return S_OK; This->hic = ICOpen(FCC('v','i','d','c'), This->fcc_handler, ICMODE_COMPRESS); if(!This->hic) { FIXME("ICOpen failed\n"); return E_FAIL; } return S_OK; } static HRESULT fill_format_info(AVICompressor *This, VIDEOINFOHEADER *src_videoinfo) { DWORD size; ICINFO icinfo; HRESULT hres; hres = ensure_driver(This); if(hres != S_OK) return hres; size = ICGetInfo(This->hic, &icinfo, sizeof(icinfo)); if(size != sizeof(icinfo)) return E_FAIL; size = ICCompressGetFormatSize(This->hic, &src_videoinfo->bmiHeader); if(!size) { FIXME("ICCompressGetFormatSize failed\n"); return E_FAIL; } size += FIELD_OFFSET(VIDEOINFOHEADER, bmiHeader); This->videoinfo = heap_alloc(size); if(!This->videoinfo) return E_OUTOFMEMORY; This->videoinfo_size = size; This->driver_flags = icinfo.dwFlags; memset(This->videoinfo, 0, sizeof(*This->videoinfo)); ICCompressGetFormat(This->hic, &src_videoinfo->bmiHeader, &This->videoinfo->bmiHeader); This->videoinfo->dwBitRate = 10000000/src_videoinfo->AvgTimePerFrame * This->videoinfo->bmiHeader.biSizeImage * 8; This->videoinfo->AvgTimePerFrame = src_videoinfo->AvgTimePerFrame; This->max_frame_size = This->videoinfo->bmiHeader.biSizeImage; return S_OK; } static HRESULT WINAPI AVICompressor_QueryInterface(IBaseFilter *iface, REFIID riid, void **ppv) { AVICompressor *This = impl_from_IBaseFilter(iface); if(IsEqualIID(riid, &IID_IUnknown)) { TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv); *ppv = &This->filter.IBaseFilter_iface; }else if(IsEqualIID(riid, &IID_IPersist)) { TRACE("(%p)->(IID_IPersist %p)\n", This, ppv); *ppv = &This->filter.IBaseFilter_iface; }else if(IsEqualIID(riid, &IID_IMediaFilter)) { TRACE("(%p)->(IID_IMediaFilter %p)\n", This, ppv); *ppv = &This->filter.IBaseFilter_iface; }else if(IsEqualIID(riid, &IID_IBaseFilter)) { TRACE("(%p)->(IID_IBaseFilter %p)\n", This, ppv); *ppv = &This->filter.IBaseFilter_iface; }else if(IsEqualIID(riid, &IID_IPersistPropertyBag)) { TRACE("(%p)->(IID_IPersistPropertyBag %p)\n", This, ppv); *ppv = &This->IPersistPropertyBag_iface; }else { FIXME("no interface for %s\n", debugstr_guid(riid)); *ppv = NULL; return E_NOINTERFACE; } IUnknown_AddRef((IUnknown*)*ppv); return S_OK; } static ULONG WINAPI AVICompressor_Release(IBaseFilter *iface) { AVICompressor *This = impl_from_IBaseFilter(iface); ULONG ref = BaseFilterImpl_Release(&This->filter.IBaseFilter_iface); TRACE("(%p) ref=%d\n", This, ref); if(!ref) { if(This->hic) ICClose(This->hic); heap_free(This->videoinfo); if(This->in) BaseInputPinImpl_Release(&This->in->pin.IPin_iface); if(This->out) BaseOutputPinImpl_Release(&This->out->pin.IPin_iface); heap_free(This); } return ref; } static HRESULT WINAPI AVICompressor_Stop(IBaseFilter *iface) { AVICompressor *This = impl_from_IBaseFilter(iface); TRACE("(%p)\n", This); if(This->filter.state == State_Stopped) return S_OK; ICCompressEnd(This->hic); This->filter.state = State_Stopped; return S_OK; } static HRESULT WINAPI AVICompressor_Pause(IBaseFilter *iface) { AVICompressor *This = impl_from_IBaseFilter(iface); FIXME("(%p)\n", This); return E_NOTIMPL; } static HRESULT WINAPI AVICompressor_Run(IBaseFilter *iface, REFERENCE_TIME tStart) { AVICompressor *This = impl_from_IBaseFilter(iface); HRESULT hres; TRACE("(%p)->(%s)\n", This, wine_dbgstr_longlong(tStart)); if(This->filter.state == State_Running) return S_OK; hres = IMemAllocator_Commit(This->out->pAllocator); if(FAILED(hres)) { FIXME("Commit failed: %08x\n", hres); return hres; } This->frame_cnt = 0; This->filter.state = State_Running; return S_OK; } static HRESULT WINAPI AVICompressor_FindPin(IBaseFilter *iface, LPCWSTR Id, IPin **ppPin) { AVICompressor *This = impl_from_IBaseFilter(iface); FIXME("(%p)->(%s %p)\n", This, debugstr_w(Id), ppPin); return VFW_E_NOT_FOUND; } static HRESULT WINAPI AVICompressor_QueryFilterInfo(IBaseFilter *iface, FILTER_INFO *pInfo) { AVICompressor *This = impl_from_IBaseFilter(iface); FIXME("(%p)->(%p)\n", This, pInfo); return E_NOTIMPL; } static HRESULT WINAPI AVICompressor_QueryVendorInfo(IBaseFilter *iface, LPWSTR *pVendorInfo) { AVICompressor *This = impl_from_IBaseFilter(iface); FIXME("(%p)->(%p)\n", This, pVendorInfo); return E_NOTIMPL; } static const IBaseFilterVtbl AVICompressorVtbl = { AVICompressor_QueryInterface, BaseFilterImpl_AddRef, AVICompressor_Release, BaseFilterImpl_GetClassID, AVICompressor_Stop, AVICompressor_Pause, AVICompressor_Run, BaseFilterImpl_GetState, BaseFilterImpl_SetSyncSource, BaseFilterImpl_GetSyncSource, BaseFilterImpl_EnumPins, AVICompressor_FindPin, AVICompressor_QueryFilterInfo, BaseFilterImpl_JoinFilterGraph, AVICompressor_QueryVendorInfo }; static IPin* WINAPI AVICompressor_GetPin(BaseFilter *iface, int pos) { AVICompressor *This = impl_from_BaseFilter(iface); IPin *ret; TRACE("(%p)->(%d)\n", This, pos); switch(pos) { case 0: ret = &This->in->pin.IPin_iface; break; case 1: ret = &This->out->pin.IPin_iface; break; default: TRACE("No pin %d\n", pos); return NULL; }; IPin_AddRef(ret); return ret; } static LONG WINAPI AVICompressor_GetPinCount(BaseFilter *iface) { return 2; } static const BaseFilterFuncTable filter_func_table = { AVICompressor_GetPin, AVICompressor_GetPinCount }; static AVICompressor *impl_from_IPersistPropertyBag(IPersistPropertyBag *iface) { return CONTAINING_RECORD(iface, AVICompressor, IPersistPropertyBag_iface); } static HRESULT WINAPI AVICompressorPropertyBag_QueryInterface(IPersistPropertyBag *iface, REFIID riid, void **ppv) { AVICompressor *This = impl_from_IPersistPropertyBag(iface); return IBaseFilter_QueryInterface(&This->filter.IBaseFilter_iface, riid, ppv); } static ULONG WINAPI AVICompressorPropertyBag_AddRef(IPersistPropertyBag *iface) { AVICompressor *This = impl_from_IPersistPropertyBag(iface); return IBaseFilter_AddRef(&This->filter.IBaseFilter_iface); } static ULONG WINAPI AVICompressorPropertyBag_Release(IPersistPropertyBag *iface) { AVICompressor *This = impl_from_IPersistPropertyBag(iface); return IBaseFilter_Release(&This->filter.IBaseFilter_iface); } static HRESULT WINAPI AVICompressorPropertyBag_GetClassID(IPersistPropertyBag *iface, CLSID *pClassID) { AVICompressor *This = impl_from_IPersistPropertyBag(iface); return IBaseFilter_GetClassID(&This->filter.IBaseFilter_iface, pClassID); } static HRESULT WINAPI AVICompressorPropertyBag_InitNew(IPersistPropertyBag *iface) { AVICompressor *This = impl_from_IPersistPropertyBag(iface); FIXME("(%p)->()\n", This); return E_NOTIMPL; } static HRESULT WINAPI AVICompressorPropertyBag_Load(IPersistPropertyBag *iface, IPropertyBag *pPropBag, IErrorLog *pErrorLog) { AVICompressor *This = impl_from_IPersistPropertyBag(iface); BSTR str; VARIANT v; HRESULT hres; static const WCHAR fcc_handlerW[] = {'F','c','c','H','a','n','d','l','e','r',0}; TRACE("(%p)->(%p %p)\n", This, pPropBag, pErrorLog); V_VT(&v) = VT_EMPTY; hres = IPropertyBag_Read(pPropBag, fcc_handlerW, &v, NULL); if(FAILED(hres)) { WARN("Could not read FccHandler: %08x\n", hres); return hres; } if(V_VT(&v) != VT_BSTR) { FIXME("Got vt %d\n", V_VT(&v)); VariantClear(&v); return E_FAIL; } str = V_BSTR(&v); TRACE("FccHandler = %s\n", debugstr_w(str)); if(SysStringLen(str) != 4) { FIXME("Invalid FccHandler len\n"); SysFreeString(str); return E_FAIL; } This->fcc_handler = FCC(str[0], str[1], str[2], str[3]); SysFreeString(str); return S_OK; } static HRESULT WINAPI AVICompressorPropertyBag_Save(IPersistPropertyBag *iface, IPropertyBag *pPropBag, BOOL fClearDirty, BOOL fSaveAllProperties) { AVICompressor *This = impl_from_IPersistPropertyBag(iface); FIXME("(%p)->(%p %x %x)\n", This, pPropBag, fClearDirty, fSaveAllProperties); return E_NOTIMPL; } static const IPersistPropertyBagVtbl PersistPropertyBagVtbl = { AVICompressorPropertyBag_QueryInterface, AVICompressorPropertyBag_AddRef, AVICompressorPropertyBag_Release, AVICompressorPropertyBag_GetClassID, AVICompressorPropertyBag_InitNew, AVICompressorPropertyBag_Load, AVICompressorPropertyBag_Save }; static inline AVICompressor *impl_from_IPin(IPin *iface) { BasePin *bp = CONTAINING_RECORD(iface, BasePin, IPin_iface); return impl_from_IBaseFilter(bp->pinInfo.pFilter); } static HRESULT WINAPI AVICompressorIn_QueryInterface(IPin *iface, REFIID riid, void **ppv) { return BaseInputPinImpl_QueryInterface(iface, riid, ppv); } static ULONG WINAPI AVICompressorIn_AddRef(IPin *iface) { AVICompressor *This = impl_from_IPin(iface); return IBaseFilter_AddRef(&This->filter.IBaseFilter_iface); } static ULONG WINAPI AVICompressorIn_Release(IPin *iface) { AVICompressor *This = impl_from_IPin(iface); return IBaseFilter_Release(&This->filter.IBaseFilter_iface); } static HRESULT WINAPI AVICompressorIn_ReceiveConnection(IPin *iface, IPin *pConnector, const AM_MEDIA_TYPE *pmt) { AVICompressor *This = impl_from_IPin(iface); HRESULT hres; TRACE("(%p)->(%p AM_MEDIA_TYPE(%p))\n", This, pConnector, pmt); dump_AM_MEDIA_TYPE(pmt); hres = BaseInputPinImpl_ReceiveConnection(iface, pConnector, pmt); if(FAILED(hres)) return hres; hres = fill_format_info(This, (VIDEOINFOHEADER*)pmt->pbFormat); if(FAILED(hres)) BasePinImpl_Disconnect(iface); return hres; } static HRESULT WINAPI AVICompressorIn_Disconnect(IPin *iface) { AVICompressor *This = impl_from_IPin(iface); HRESULT hres; TRACE("(%p)\n", This); hres = BasePinImpl_Disconnect(iface); if(FAILED(hres)) return hres; heap_free(This->videoinfo); This->videoinfo = NULL; return S_OK; } static const IPinVtbl AVICompressorInputPinVtbl = { AVICompressorIn_QueryInterface, AVICompressorIn_AddRef, AVICompressorIn_Release, BaseInputPinImpl_Connect, AVICompressorIn_ReceiveConnection, AVICompressorIn_Disconnect, BasePinImpl_ConnectedTo, BasePinImpl_ConnectionMediaType, BasePinImpl_QueryPinInfo, BasePinImpl_QueryDirection, BasePinImpl_QueryId, BasePinImpl_QueryAccept, BasePinImpl_EnumMediaTypes, BasePinImpl_QueryInternalConnections, BaseInputPinImpl_EndOfStream, BaseInputPinImpl_BeginFlush, BaseInputPinImpl_EndFlush, BaseInputPinImpl_NewSegment }; static HRESULT WINAPI AVICompressorIn_CheckMediaType(BasePin *base, const AM_MEDIA_TYPE *pmt) { AVICompressor *This = impl_from_BasePin(base); VIDEOINFOHEADER *videoinfo; HRESULT hres; DWORD res; TRACE("(%p)->(AM_MEDIA_TYPE(%p))\n", base, pmt); dump_AM_MEDIA_TYPE(pmt); if(!IsEqualIID(&pmt->majortype, &MEDIATYPE_Video)) return S_FALSE; if(!IsEqualIID(&pmt->formattype, &FORMAT_VideoInfo)) { FIXME("formattype %s unsupported\n", debugstr_guid(&pmt->formattype)); return S_FALSE; } hres = ensure_driver(This); if(hres != S_OK) return hres; videoinfo = (VIDEOINFOHEADER*)pmt->pbFormat; res = ICCompressQuery(This->hic, &videoinfo->bmiHeader, NULL); return res == ICERR_OK ? S_OK : S_FALSE; } static LONG WINAPI AVICompressorIn_GetMediaTypeVersion(BasePin *base) { return 0; } static HRESULT WINAPI AVICompressorIn_GetMediaType(BasePin *base, int iPosition, AM_MEDIA_TYPE *amt) { TRACE("(%p)->(%d %p)\n", base, iPosition, amt); return S_FALSE; } static HRESULT WINAPI AVICompressorIn_Receive(BaseInputPin *base, IMediaSample *pSample) { AVICompressor *This = impl_from_BasePin(&base->pin); VIDEOINFOHEADER *src_videoinfo; REFERENCE_TIME start, stop; IMediaSample *out_sample; AM_MEDIA_TYPE *mt; IMediaSample2 *sample2; DWORD comp_flags = 0; BOOL is_preroll; BOOL sync_point; BYTE *ptr, *buf; DWORD res; HRESULT hres; TRACE("(%p)->(%p)\n", base, pSample); if(!This->hic) { FIXME("Driver not loaded\n"); return E_UNEXPECTED; } hres = IMediaSample_QueryInterface(pSample, &IID_IMediaSample2, (void**)&sample2); if(SUCCEEDED(hres)) { FIXME("Use IMediaSample2\n"); IMediaSample2_Release(sample2); } is_preroll = IMediaSample_IsPreroll(pSample) == S_OK; sync_point = IMediaSample_IsSyncPoint(pSample) == S_OK; hres = IMediaSample_GetTime(pSample, &start, &stop); if(FAILED(hres)) { WARN("GetTime failed: %08x\n", hres); return hres; } hres = IMediaSample_GetMediaType(pSample, &mt); if(FAILED(hres)) return hres; hres = IMediaSample_GetPointer(pSample, &ptr); if(FAILED(hres)) { WARN("GetPointer failed: %08x\n", hres); return hres; } hres = BaseOutputPinImpl_GetDeliveryBuffer(This->out, &out_sample, &start, &stop, 0); if(FAILED(hres)) return hres; hres = IMediaSample_GetPointer(out_sample, &buf); if(FAILED(hres)) return hres; if((This->driver_flags & VIDCF_TEMPORAL) && !(This->driver_flags & VIDCF_FASTTEMPORALC)) FIXME("Unsupported temporal compression\n"); src_videoinfo = (VIDEOINFOHEADER*)This->in->pin.mtCurrent.pbFormat; This->videoinfo->bmiHeader.biSizeImage = This->max_frame_size; res = ICCompress(This->hic, sync_point ? ICCOMPRESS_KEYFRAME : 0, &This->videoinfo->bmiHeader, buf, &src_videoinfo->bmiHeader, ptr, 0, &comp_flags, This->frame_cnt, 0, 0, NULL, NULL); if(res != ICERR_OK) { WARN("ICCompress failed: %d\n", res); IMediaSample_Release(out_sample); return E_FAIL; } IMediaSample_SetActualDataLength(out_sample, This->videoinfo->bmiHeader.biSizeImage); IMediaSample_SetPreroll(out_sample, is_preroll); IMediaSample_SetSyncPoint(out_sample, (comp_flags&AVIIF_KEYFRAME) != 0); IMediaSample_SetDiscontinuity(out_sample, (IMediaSample_IsDiscontinuity(pSample) == S_OK)); if (IMediaSample_GetMediaTime(pSample, &start, &stop) == S_OK) IMediaSample_SetMediaTime(out_sample, &start, &stop); else IMediaSample_SetMediaTime(out_sample, NULL, NULL); hres = BaseOutputPinImpl_Deliver(This->out, out_sample); if(FAILED(hres)) WARN("Deliver failed: %08x\n", hres); IMediaSample_Release(out_sample); This->frame_cnt++; return hres; } static const BaseInputPinFuncTable AVICompressorBaseInputPinVtbl = { { AVICompressorIn_CheckMediaType, NULL, AVICompressorIn_GetMediaTypeVersion, AVICompressorIn_GetMediaType }, AVICompressorIn_Receive }; static HRESULT WINAPI AVICompressorOut_QueryInterface(IPin *iface, REFIID riid, void **ppv) { return BaseInputPinImpl_QueryInterface(iface, riid, ppv); } static ULONG WINAPI AVICompressorOut_AddRef(IPin *iface) { AVICompressor *This = impl_from_IPin(iface); return IBaseFilter_AddRef(&This->filter.IBaseFilter_iface); } static ULONG WINAPI AVICompressorOut_Release(IPin *iface) { AVICompressor *This = impl_from_IPin(iface); return IBaseFilter_Release(&This->filter.IBaseFilter_iface); } static const IPinVtbl AVICompressorOutputPinVtbl = { AVICompressorOut_QueryInterface, AVICompressorOut_AddRef, AVICompressorOut_Release, BaseOutputPinImpl_Connect, BaseOutputPinImpl_ReceiveConnection, BaseOutputPinImpl_Disconnect, BasePinImpl_ConnectedTo, BasePinImpl_ConnectionMediaType, BasePinImpl_QueryPinInfo, BasePinImpl_QueryDirection, BasePinImpl_QueryId, BasePinImpl_QueryAccept, BasePinImpl_EnumMediaTypes, BasePinImpl_QueryInternalConnections, BaseOutputPinImpl_EndOfStream, BaseOutputPinImpl_BeginFlush, BaseOutputPinImpl_EndFlush, BasePinImpl_NewSegment }; static LONG WINAPI AVICompressorOut_GetMediaTypeVersion(BasePin *base) { FIXME("(%p)\n", base); return 0; } static HRESULT WINAPI AVICompressorOut_GetMediaType(BasePin *base, int iPosition, AM_MEDIA_TYPE *amt) { AVICompressor *This = impl_from_IBaseFilter(base->pinInfo.pFilter); TRACE("(%p)->(%d %p)\n", base, iPosition, amt); if(iPosition || !This->videoinfo) return S_FALSE; amt->majortype = MEDIATYPE_Video; amt->subtype = MEDIASUBTYPE_PCM; amt->bFixedSizeSamples = FALSE; amt->bTemporalCompression = (This->driver_flags & VIDCF_TEMPORAL) != 0; amt->lSampleSize = This->in->pin.mtCurrent.lSampleSize; amt->formattype = FORMAT_VideoInfo; amt->pUnk = NULL; amt->cbFormat = This->videoinfo_size; amt->pbFormat = (BYTE*)This->videoinfo; return S_OK; } static HRESULT WINAPI AVICompressorOut_DecideBufferSize(BaseOutputPin *base, IMemAllocator *alloc, ALLOCATOR_PROPERTIES *ppropInputRequest) { AVICompressor *This = impl_from_BasePin(&base->pin); ALLOCATOR_PROPERTIES actual; TRACE("(%p)\n", This); if (!ppropInputRequest->cBuffers) ppropInputRequest->cBuffers = 1; if (ppropInputRequest->cbBuffer < This->max_frame_size) ppropInputRequest->cbBuffer = This->max_frame_size; if (!ppropInputRequest->cbAlign) ppropInputRequest->cbAlign = 1; return IMemAllocator_SetProperties(alloc, ppropInputRequest, &actual); } static HRESULT WINAPI AVICompressorOut_DecideAllocator(BaseOutputPin *base, IMemInputPin *pPin, IMemAllocator **pAlloc) { TRACE("(%p)->(%p %p)\n", base, pPin, pAlloc); return BaseOutputPinImpl_DecideAllocator(base, pPin, pAlloc); } static HRESULT WINAPI AVICompressorOut_BreakConnect(BaseOutputPin *base) { FIXME("(%p)\n", base); return E_NOTIMPL; } static const BaseOutputPinFuncTable AVICompressorBaseOutputPinVtbl = { { NULL, BaseOutputPinImpl_AttemptConnection, AVICompressorOut_GetMediaTypeVersion, AVICompressorOut_GetMediaType }, AVICompressorOut_DecideBufferSize, AVICompressorOut_DecideAllocator, AVICompressorOut_BreakConnect }; IUnknown* WINAPI QCAP_createAVICompressor(IUnknown *outer, HRESULT *phr) { PIN_INFO in_pin_info = {NULL, PINDIR_INPUT, {'I','n','p','u','t',0}}; PIN_INFO out_pin_info = {NULL, PINDIR_OUTPUT, {'O','u','t','p','u','t',0}}; AVICompressor *compressor; HRESULT hres; TRACE("\n"); compressor = heap_alloc_zero(sizeof(*compressor)); if(!compressor) { *phr = E_NOINTERFACE; return NULL; } BaseFilter_Init(&compressor->filter, &AVICompressorVtbl, &CLSID_AVICo, (DWORD_PTR)(__FILE__ ": AVICompressor.csFilter"), &filter_func_table); compressor->IPersistPropertyBag_iface.lpVtbl = &PersistPropertyBagVtbl; in_pin_info.pFilter = &compressor->filter.IBaseFilter_iface; hres = BaseInputPin_Construct(&AVICompressorInputPinVtbl, sizeof(BaseInputPin), &in_pin_info, &AVICompressorBaseInputPinVtbl, &compressor->filter.csFilter, NULL, (IPin**)&compressor->in); if(FAILED(hres)) { IBaseFilter_Release(&compressor->filter.IBaseFilter_iface); *phr = hres; return NULL; } out_pin_info.pFilter = &compressor->filter.IBaseFilter_iface; hres = BaseOutputPin_Construct(&AVICompressorOutputPinVtbl, sizeof(BaseOutputPin), &out_pin_info, &AVICompressorBaseOutputPinVtbl, &compressor->filter.csFilter, (IPin**)&compressor->out); if(FAILED(hres)) { IBaseFilter_Release(&compressor->filter.IBaseFilter_iface); *phr = hres; return NULL; } *phr = S_OK; return (IUnknown*)&compressor->filter.IBaseFilter_iface; }