dlls/qcap/avico.c

   1 /*
   2  * Copyright 2013 Jacek Caban for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include <stdarg.h>
  20
  21 #define COBJMACROS
  22
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "dshow.h"
  26 #include "vfw.h"
  27 #include "aviriff.h"
  28
  29 #include "qcap_main.h"
  30
  31 #include "wine/debug.h"
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(qcap);
  34
  35 typedef struct {
  36     BaseFilter filter;
  37     IPersistPropertyBag IPersistPropertyBag_iface;
  38
  39     BaseInputPin *in;
  40     BaseOutputPin *out;
  41
  42     DWORD fcc_handler;
  43     HIC hic;
  44
  45     VIDEOINFOHEADER *videoinfo;
  46     size_t videoinfo_size;
  47     DWORD driver_flags;
  48
  49     DWORD frame_cnt;
  50 } AVICompressor;
  51
  52 static inline AVICompressor *impl_from_BaseFilter(BaseFilter *filter)
  53 {
  54     return CONTAINING_RECORD(filter, AVICompressor, filter);
  55 }
  56
  57 static inline AVICompressor *impl_from_IBaseFilter(IBaseFilter *iface)
  58 {
  59     BaseFilter *filter = CONTAINING_RECORD(iface, BaseFilter, IBaseFilter_iface);
  60     return impl_from_BaseFilter(filter);
  61 }
  62
  63 static inline AVICompressor *impl_from_BasePin(BasePin *pin)
  64 {
  65     return impl_from_IBaseFilter(pin->pinInfo.pFilter);
  66 }
  67
  68 static HRESULT ensure_driver(AVICompressor *This)
  69 {
  70     if(This->hic)
  71         return S_OK;
  72
  73     This->hic = ICOpen(FCC('v','i','d','c'), This->fcc_handler, ICMODE_COMPRESS);
  74     if(!This->hic) {
  75         FIXME("ICOpen failed\n");
  76         return E_FAIL;
  77     }
  78
  79     return S_OK;
  80 }
  81
  82 static HRESULT fill_format_info(AVICompressor *This, VIDEOINFOHEADER *src_videoinfo)
  83 {
  84     DWORD size;
  85     ICINFO icinfo;
  86     HRESULT hres;
  87
  88     hres = ensure_driver(This);
  89     if(hres != S_OK)
  90         return hres;
  91
  92     size = ICGetInfo(This->hic, &icinfo, sizeof(icinfo));
  93     if(size != sizeof(icinfo))
  94         return E_FAIL;
  95
  96     size = ICCompressGetFormatSize(This->hic, &src_videoinfo->bmiHeader);
  97     if(!size) {
  98         FIXME("ICCompressGetFormatSize failed\n");
  99         return E_FAIL;
 100     }
 101
 102     size += FIELD_OFFSET(VIDEOINFOHEADER, bmiHeader);
 103     This->videoinfo = heap_alloc(size);
 104     if(!This->videoinfo)
 105         return E_OUTOFMEMORY;
 106
 107     This->videoinfo_size = size;
 108     This->driver_flags = icinfo.dwFlags;
 109     memset(This->videoinfo, 0, sizeof(*This->videoinfo));
 110     ICCompressGetFormat(This->hic, &src_videoinfo->bmiHeader, &This->videoinfo->bmiHeader);
 111
 112     This->videoinfo->dwBitRate = 10000000/src_videoinfo->AvgTimePerFrame * This->videoinfo->bmiHeader.biSizeImage * 8;
 113     This->videoinfo->AvgTimePerFrame = src_videoinfo->AvgTimePerFrame;
 114     return S_OK;
 115 }
 116
 117 static HRESULT WINAPI AVICompressor_QueryInterface(IBaseFilter *iface, REFIID riid, void **ppv)
 118 {
 119     AVICompressor *This = impl_from_IBaseFilter(iface);
 120
 121     if(IsEqualIID(riid, &IID_IUnknown)) {
 122         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
 123         *ppv = &This->filter.IBaseFilter_iface;
 124     }else if(IsEqualIID(riid, &IID_IPersist)) {
 125         TRACE("(%p)->(IID_IPersist %p)\n", This, ppv);
 126         *ppv = &This->filter.IBaseFilter_iface;
 127     }else if(IsEqualIID(riid, &IID_IMediaFilter)) {
 128         TRACE("(%p)->(IID_IMediaFilter %p)\n", This, ppv);
 129         *ppv = &This->filter.IBaseFilter_iface;
 130     }else if(IsEqualIID(riid, &IID_IBaseFilter)) {
 131         TRACE("(%p)->(IID_IBaseFilter %p)\n", This, ppv);
 132         *ppv = &This->filter.IBaseFilter_iface;
 133     }else if(IsEqualIID(riid, &IID_IPersistPropertyBag)) {
 134         TRACE("(%p)->(IID_IPersistPropertyBag %p)\n", This, ppv);
 135         *ppv = &This->IPersistPropertyBag_iface;
 136     }else {
 137         FIXME("no interface for %s\n", debugstr_guid(riid));
 138         *ppv = NULL;
 139         return E_NOINTERFACE;
 140     }
 141
 142     IUnknown_AddRef((IUnknown*)*ppv);
 143     return S_OK;
 144
 145 }
 146
 147 static ULONG WINAPI AVICompressor_Release(IBaseFilter *iface)
 148 {
 149     AVICompressor *This = impl_from_IBaseFilter(iface);
 150     ULONG ref = BaseFilterImpl_Release(&This->filter.IBaseFilter_iface);
 151
 152     TRACE("(%p) ref=%d\n", This, ref);
 153
 154     if(!ref) {
 155         if(This->hic)
 156             ICClose(This->hic);
 157         heap_free(This->videoinfo);
 158         if(This->in)
 159             BaseInputPinImpl_Release(&This->in->pin.IPin_iface);
 160         if(This->out)
 161             BaseOutputPinImpl_Release(&This->out->pin.IPin_iface);
 162         heap_free(This);
 163     }
 164
 165     return ref;
 166 }
 167
 168 static HRESULT WINAPI AVICompressor_Stop(IBaseFilter *iface)
 169 {
 170     AVICompressor *This = impl_from_IBaseFilter(iface);
 171
 172     TRACE("(%p)\n", This);
 173
 174     if(This->filter.state == State_Stopped)
 175         return S_OK;
 176
 177     ICCompressEnd(This->hic);
 178     This->filter.state = State_Stopped;
 179     return S_OK;
 180 }
 181
 182 static HRESULT WINAPI AVICompressor_Pause(IBaseFilter *iface)
 183 {
 184     AVICompressor *This = impl_from_IBaseFilter(iface);
 185     FIXME("(%p)\n", This);
 186     return E_NOTIMPL;
 187 }
 188
 189 static HRESULT WINAPI AVICompressor_Run(IBaseFilter *iface, REFERENCE_TIME tStart)
 190 {
 191     AVICompressor *This = impl_from_IBaseFilter(iface);
 192     HRESULT hres;
 193
 194     TRACE("(%p)->(%s)\n", This, wine_dbgstr_longlong(tStart));
 195
 196     if(This->filter.state == State_Running)
 197         return S_OK;
 198
 199     hres = IMemAllocator_Commit(This->out->pAllocator);
 200     if(FAILED(hres)) {
 201         FIXME("Commit failed: %08x\n", hres);
 202         return hres;
 203     }
 204
 205     This->frame_cnt = 0;
 206
 207     This->filter.state = State_Running;
 208     return S_OK;
 209 }
 210
 211 static HRESULT WINAPI AVICompressor_FindPin(IBaseFilter *iface, LPCWSTR Id, IPin **ppPin)
 212 {
 213     AVICompressor *This = impl_from_IBaseFilter(iface);
 214     FIXME("(%p)->(%s %p)\n", This, debugstr_w(Id), ppPin);
 215     return VFW_E_NOT_FOUND;
 216 }
 217
 218 static HRESULT WINAPI AVICompressor_QueryFilterInfo(IBaseFilter *iface, FILTER_INFO *pInfo)
 219 {
 220     AVICompressor *This = impl_from_IBaseFilter(iface);
 221     FIXME("(%p)->(%p)\n", This, pInfo);
 222     return E_NOTIMPL;
 223 }
 224
 225 static HRESULT WINAPI AVICompressor_QueryVendorInfo(IBaseFilter *iface, LPWSTR *pVendorInfo)
 226 {
 227     AVICompressor *This = impl_from_IBaseFilter(iface);
 228     FIXME("(%p)->(%p)\n", This, pVendorInfo);
 229     return E_NOTIMPL;
 230 }
 231
 232 static const IBaseFilterVtbl AVICompressorVtbl = {
 233     AVICompressor_QueryInterface,
 234     BaseFilterImpl_AddRef,
 235     AVICompressor_Release,
 236     BaseFilterImpl_GetClassID,
 237     AVICompressor_Stop,
 238     AVICompressor_Pause,
 239     AVICompressor_Run,
 240     BaseFilterImpl_GetState,
 241     BaseFilterImpl_SetSyncSource,
 242     BaseFilterImpl_GetSyncSource,
 243     BaseFilterImpl_EnumPins,
 244     AVICompressor_FindPin,
 245     AVICompressor_QueryFilterInfo,
 246     BaseFilterImpl_JoinFilterGraph,
 247     AVICompressor_QueryVendorInfo
 248 };
 249
 250 static IPin* WINAPI AVICompressor_GetPin(BaseFilter *iface, int pos)
 251 {
 252     AVICompressor *This = impl_from_BaseFilter(iface);
 253     IPin *ret;
 254
 255     TRACE("(%p)->(%d)\n", This, pos);
 256
 257     switch(pos) {
 258     case 0:
 259         ret = &This->in->pin.IPin_iface;
 260         break;
 261     case 1:
 262         ret = &This->out->pin.IPin_iface;
 263         break;
 264     default:
 265         TRACE("No pin %d\n", pos);
 266         return NULL;
 267     };
 268
 269     IPin_AddRef(ret);
 270     return ret;
 271 }
 272
 273 static LONG WINAPI AVICompressor_GetPinCount(BaseFilter *iface)
 274 {
 275     return 2;
 276 }
 277
 278 static const BaseFilterFuncTable filter_func_table = {
 279     AVICompressor_GetPin,
 280     AVICompressor_GetPinCount
 281 };
 282
 283 static AVICompressor *impl_from_IPersistPropertyBag(IPersistPropertyBag *iface)
 284 {
 285     return CONTAINING_RECORD(iface, AVICompressor, IPersistPropertyBag_iface);
 286 }
 287
 288 static HRESULT WINAPI AVICompressorPropertyBag_QueryInterface(IPersistPropertyBag *iface, REFIID riid, void **ppv)
 289 {
 290     AVICompressor *This = impl_from_IPersistPropertyBag(iface);
 291     return IBaseFilter_QueryInterface(&This->filter.IBaseFilter_iface, riid, ppv);
 292 }
 293
 294 static ULONG WINAPI AVICompressorPropertyBag_AddRef(IPersistPropertyBag *iface)
 295 {
 296     AVICompressor *This = impl_from_IPersistPropertyBag(iface);
 297     return IBaseFilter_AddRef(&This->filter.IBaseFilter_iface);
 298 }
 299
 300 static ULONG WINAPI AVICompressorPropertyBag_Release(IPersistPropertyBag *iface)
 301 {
 302     AVICompressor *This = impl_from_IPersistPropertyBag(iface);
 303     return IBaseFilter_Release(&This->filter.IBaseFilter_iface);
 304 }
 305
 306 static HRESULT WINAPI AVICompressorPropertyBag_GetClassID(IPersistPropertyBag *iface, CLSID *pClassID)
 307 {
 308     AVICompressor *This = impl_from_IPersistPropertyBag(iface);
 309     return IBaseFilter_GetClassID(&This->filter.IBaseFilter_iface, pClassID);
 310 }
 311
 312 static HRESULT WINAPI AVICompressorPropertyBag_InitNew(IPersistPropertyBag *iface)
 313 {
 314     AVICompressor *This = impl_from_IPersistPropertyBag(iface);
 315     FIXME("(%p)->()\n", This);
 316     return E_NOTIMPL;
 317 }
 318
 319 static HRESULT WINAPI AVICompressorPropertyBag_Load(IPersistPropertyBag *iface, IPropertyBag *pPropBag, IErrorLog *pErrorLog)
 320 {
 321     AVICompressor *This = impl_from_IPersistPropertyBag(iface);
 322     BSTR str;
 323     VARIANT v;
 324     HRESULT hres;
 325
 326     static const WCHAR fcc_handlerW[] = {'F','c','c','H','a','n','d','l','e','r',0};
 327
 328     TRACE("(%p)->(%p %p)\n", This, pPropBag, pErrorLog);
 329
 330     V_VT(&v) = VT_EMPTY;
 331     hres = IPropertyBag_Read(pPropBag, fcc_handlerW, &v, NULL);
 332     if(FAILED(hres)) {
 333         WARN("Could not read FccHandler: %08x\n", hres);
 334         return hres;
 335     }
 336
 337     if(V_VT(&v) != VT_BSTR) {
 338         FIXME("Got vt %d\n", V_VT(&v));
 339         VariantClear(&v);
 340         return E_FAIL;
 341     }
 342
 343     str = V_BSTR(&v);
 344     TRACE("FccHandler = %s\n", debugstr_w(str));
 345     if(SysStringLen(str) != 4) {
 346         FIXME("Invalid FccHandler len\n");
 347         SysFreeString(str);
 348         return E_FAIL;
 349     }
 350
 351     This->fcc_handler = FCC(str[0], str[1], str[2], str[3]);
 352     SysFreeString(str);
 353     return S_OK;
 354 }
 355
 356 static HRESULT WINAPI AVICompressorPropertyBag_Save(IPersistPropertyBag *iface, IPropertyBag *pPropBag,
 357         BOOL fClearDirty, BOOL fSaveAllProperties)
 358 {
 359     AVICompressor *This = impl_from_IPersistPropertyBag(iface);
 360     FIXME("(%p)->(%p %x %x)\n", This, pPropBag, fClearDirty, fSaveAllProperties);
 361     return E_NOTIMPL;
 362 }
 363
 364 static const IPersistPropertyBagVtbl PersistPropertyBagVtbl = {
 365     AVICompressorPropertyBag_QueryInterface,
 366     AVICompressorPropertyBag_AddRef,
 367     AVICompressorPropertyBag_Release,
 368     AVICompressorPropertyBag_GetClassID,
 369     AVICompressorPropertyBag_InitNew,
 370     AVICompressorPropertyBag_Load,
 371     AVICompressorPropertyBag_Save
 372 };
 373
 374 static inline AVICompressor *impl_from_IPin(IPin *iface)
 375 {
 376     BasePin *bp = CONTAINING_RECORD(iface, BasePin, IPin_iface);
 377     return impl_from_IBaseFilter(bp->pinInfo.pFilter);
 378 }
 379
 380 static HRESULT WINAPI AVICompressorIn_QueryInterface(IPin *iface, REFIID riid, void **ppv)
 381 {
 382     return BaseInputPinImpl_QueryInterface(iface, riid, ppv);
 383 }
 384
 385 static ULONG WINAPI AVICompressorIn_AddRef(IPin *iface)
 386 {
 387     AVICompressor *This = impl_from_IPin(iface);
 388     return IBaseFilter_AddRef(&This->filter.IBaseFilter_iface);
 389 }
 390
 391 static ULONG WINAPI AVICompressorIn_Release(IPin *iface)
 392 {
 393     AVICompressor *This = impl_from_IPin(iface);
 394     return IBaseFilter_Release(&This->filter.IBaseFilter_iface);
 395 }
 396
 397 static HRESULT WINAPI AVICompressorIn_ReceiveConnection(IPin *iface,
 398         IPin *pConnector, const AM_MEDIA_TYPE *pmt)
 399 {
 400     AVICompressor *This = impl_from_IPin(iface);
 401     HRESULT hres;
 402
 403     TRACE("(%p)->(%p AM_MEDIA_TYPE(%p))\n", This, pConnector, pmt);
 404     dump_AM_MEDIA_TYPE(pmt);
 405
 406     hres = BaseInputPinImpl_ReceiveConnection(iface, pConnector, pmt);
 407     if(FAILED(hres))
 408         return hres;
 409
 410     hres = fill_format_info(This, (VIDEOINFOHEADER*)pmt->pbFormat);
 411     if(FAILED(hres))
 412         BasePinImpl_Disconnect(iface);
 413     return hres;
 414 }
 415
 416 static HRESULT WINAPI AVICompressorIn_Disconnect(IPin *iface)
 417 {
 418     AVICompressor *This = impl_from_IPin(iface);
 419     HRESULT hres;
 420
 421     TRACE("(%p)\n", This);
 422
 423     hres = BasePinImpl_Disconnect(iface);
 424     if(FAILED(hres))
 425         return hres;
 426
 427     heap_free(This->videoinfo);
 428     This->videoinfo = NULL;
 429     return S_OK;
 430 }
 431
 432 static const IPinVtbl AVICompressorInputPinVtbl = {
 433     AVICompressorIn_QueryInterface,
 434     AVICompressorIn_AddRef,
 435     AVICompressorIn_Release,
 436     BaseInputPinImpl_Connect,
 437     AVICompressorIn_ReceiveConnection,
 438     AVICompressorIn_Disconnect,
 439     BasePinImpl_ConnectedTo,
 440     BasePinImpl_ConnectionMediaType,
 441     BasePinImpl_QueryPinInfo,
 442     BasePinImpl_QueryDirection,
 443     BasePinImpl_QueryId,
 444     BasePinImpl_QueryAccept,
 445     BasePinImpl_EnumMediaTypes,
 446     BasePinImpl_QueryInternalConnections,
 447     BaseInputPinImpl_EndOfStream,
 448     BaseInputPinImpl_BeginFlush,
 449     BaseInputPinImpl_EndFlush,
 450     BaseInputPinImpl_NewSegment
 451 };
 452
 453 static HRESULT WINAPI AVICompressorIn_CheckMediaType(BasePin *base, const AM_MEDIA_TYPE *pmt)
 454 {
 455     AVICompressor *This = impl_from_BasePin(base);
 456     VIDEOINFOHEADER *videoinfo;
 457     HRESULT hres;
 458     DWORD res;
 459
 460     TRACE("(%p)->(AM_MEDIA_TYPE(%p))\n", base, pmt);
 461     dump_AM_MEDIA_TYPE(pmt);
 462
 463     if(!IsEqualIID(&pmt->majortype, &MEDIATYPE_Video))
 464         return S_FALSE;
 465
 466     if(!IsEqualIID(&pmt->formattype, &FORMAT_VideoInfo)) {
 467         FIXME("formattype %s unsupported\n", debugstr_guid(&pmt->formattype));
 468         return S_FALSE;
 469     }
 470
 471     hres = ensure_driver(This);
 472     if(hres != S_OK)
 473         return hres;
 474
 475     videoinfo = (VIDEOINFOHEADER*)pmt->pbFormat;
 476     res = ICCompressQuery(This->hic, &videoinfo->bmiHeader, NULL);
 477     return res == ICERR_OK ? S_OK : S_FALSE;
 478 }
 479
 480 static LONG WINAPI AVICompressorIn_GetMediaTypeVersion(BasePin *base)
 481 {
 482     return 0;
 483 }
 484
 485 static HRESULT WINAPI AVICompressorIn_GetMediaType(BasePin *base, int iPosition, AM_MEDIA_TYPE *amt)
 486 {
 487     TRACE("(%p)->(%d %p)\n", base, iPosition, amt);
 488     return S_FALSE;
 489 }
 490
 491 static HRESULT WINAPI AVICompressorIn_Receive(BaseInputPin *base, IMediaSample *pSample)
 492 {
 493     AVICompressor *This = impl_from_BasePin(&base->pin);
 494     VIDEOINFOHEADER *src_videoinfo;
 495     REFERENCE_TIME start, stop;
 496     IMediaSample *out_sample;
 497     AM_MEDIA_TYPE *mt;
 498     IMediaSample2 *sample2;
 499     DWORD comp_flags = 0;
 500     BOOL is_preroll;
 501     BOOL sync_point;
 502     BYTE *ptr, *buf;
 503     DWORD res;
 504     HRESULT hres;
 505
 506     TRACE("(%p)->(%p)\n", base, pSample);
 507
 508     if(!This->hic) {
 509         FIXME("Driver not loaded\n");
 510         return E_UNEXPECTED;
 511     }
 512
 513     hres = IMediaSample_QueryInterface(pSample, &IID_IMediaSample2, (void**)&sample2);
 514     if(SUCCEEDED(hres)) {
 515         FIXME("Use IMediaSample2\n");
 516         IMediaSample2_Release(sample2);
 517     }
 518
 519     is_preroll = IMediaSample_IsPreroll(pSample) == S_OK;
 520     sync_point = IMediaSample_IsSyncPoint(pSample) == S_OK;
 521
 522     hres = IMediaSample_GetTime(pSample, &start, &stop);
 523     if(FAILED(hres)) {
 524         WARN("GetTime failed: %08x\n", hres);
 525         return hres;
 526     }
 527
 528     hres = IMediaSample_GetMediaType(pSample, &mt);
 529     if(FAILED(hres))
 530         return hres;
 531
 532     hres = IMediaSample_GetPointer(pSample, &ptr);
 533     if(FAILED(hres)) {
 534         WARN("GetPointer failed: %08x\n", hres);
 535         return hres;
 536     }
 537
 538     hres = BaseOutputPinImpl_GetDeliveryBuffer(This->out, &out_sample, &start, &stop, 0);
 539     if(FAILED(hres))
 540         return hres;
 541
 542     hres = IMediaSample_GetPointer(out_sample, &buf);
 543     if(FAILED(hres))
 544         return hres;
 545
 546     if((This->driver_flags & VIDCF_TEMPORAL) && !(This->driver_flags & VIDCF_FASTTEMPORALC))
 547         FIXME("Unsupported temporal compression\n");
 548
 549     src_videoinfo = (VIDEOINFOHEADER*)This->in->pin.mtCurrent.pbFormat;
 550     res = ICCompress(This->hic, sync_point ? ICCOMPRESS_KEYFRAME : 0, &This->videoinfo->bmiHeader, buf,
 551             &src_videoinfo->bmiHeader, ptr, 0, &comp_flags, This->frame_cnt, 0, 0, NULL, NULL);
 552     if(res != ICERR_OK) {
 553         WARN("ICCompress failed: %d\n", res);
 554         IMediaSample_Release(out_sample);
 555         return E_FAIL;
 556     }
 557
 558     IMediaSample_SetActualDataLength(out_sample, This->videoinfo->bmiHeader.biSizeImage);
 559     IMediaSample_SetPreroll(out_sample, is_preroll);
 560     IMediaSample_SetSyncPoint(out_sample, (comp_flags&AVIIF_KEYFRAME) != 0);
 561     IMediaSample_SetDiscontinuity(out_sample, (IMediaSample_IsDiscontinuity(pSample) == S_OK));
 562
 563     if (IMediaSample_GetMediaTime(pSample, &start, &stop) == S_OK)
 564         IMediaSample_SetMediaTime(out_sample, &start, &stop);
 565     else
 566         IMediaSample_SetMediaTime(out_sample, NULL, NULL);
 567
 568     hres = BaseOutputPinImpl_Deliver(This->out, out_sample);
 569     if(FAILED(hres))
 570         WARN("Deliver failed: %08x\n", hres);
 571
 572     IMediaSample_Release(out_sample);
 573     This->frame_cnt++;
 574     return hres;
 575 }
 576
 577 static const BaseInputPinFuncTable AVICompressorBaseInputPinVtbl = {
 578     {
 579         AVICompressorIn_CheckMediaType,
 580         NULL,
 581         AVICompressorIn_GetMediaTypeVersion,
 582         AVICompressorIn_GetMediaType
 583     },
 584     AVICompressorIn_Receive
 585 };
 586
 587 static HRESULT WINAPI AVICompressorOut_QueryInterface(IPin *iface, REFIID riid, void **ppv)
 588 {
 589     return BaseInputPinImpl_QueryInterface(iface, riid, ppv);
 590 }
 591
 592 static ULONG WINAPI AVICompressorOut_AddRef(IPin *iface)
 593 {
 594     AVICompressor *This = impl_from_IPin(iface);
 595     return IBaseFilter_AddRef(&This->filter.IBaseFilter_iface);
 596 }
 597
 598 static ULONG WINAPI AVICompressorOut_Release(IPin *iface)
 599 {
 600     AVICompressor *This = impl_from_IPin(iface);
 601     return IBaseFilter_Release(&This->filter.IBaseFilter_iface);
 602 }
 603
 604 static const IPinVtbl AVICompressorOutputPinVtbl = {
 605     AVICompressorOut_QueryInterface,
 606     AVICompressorOut_AddRef,
 607     AVICompressorOut_Release,
 608     BaseOutputPinImpl_Connect,
 609     BaseOutputPinImpl_ReceiveConnection,
 610     BaseOutputPinImpl_Disconnect,
 611     BasePinImpl_ConnectedTo,
 612     BasePinImpl_ConnectionMediaType,
 613     BasePinImpl_QueryPinInfo,
 614     BasePinImpl_QueryDirection,
 615     BasePinImpl_QueryId,
 616     BasePinImpl_QueryAccept,
 617     BasePinImpl_EnumMediaTypes,
 618     BasePinImpl_QueryInternalConnections,
 619     BaseOutputPinImpl_EndOfStream,
 620     BaseOutputPinImpl_BeginFlush,
 621     BaseOutputPinImpl_EndFlush,
 622     BasePinImpl_NewSegment
 623 };
 624
 625 static LONG WINAPI AVICompressorOut_GetMediaTypeVersion(BasePin *base)
 626 {
 627     FIXME("(%p)\n", base);
 628     return 0;
 629 }
 630
 631 static HRESULT WINAPI AVICompressorOut_GetMediaType(BasePin *base, int iPosition, AM_MEDIA_TYPE *amt)
 632 {
 633     AVICompressor *This = impl_from_IBaseFilter(base->pinInfo.pFilter);
 634
 635     TRACE("(%p)->(%d %p)\n", base, iPosition, amt);
 636
 637     if(iPosition || !This->videoinfo)
 638         return S_FALSE;
 639
 640     amt->majortype = MEDIATYPE_Video;
 641     amt->subtype = MEDIASUBTYPE_PCM;
 642     amt->bFixedSizeSamples = FALSE;
 643     amt->bTemporalCompression = (This->driver_flags & VIDCF_TEMPORAL) != 0;
 644     amt->lSampleSize = This->in->pin.mtCurrent.lSampleSize;
 645     amt->formattype = FORMAT_VideoInfo;
 646     amt->pUnk = NULL;
 647     amt->cbFormat = This->videoinfo_size;
 648     amt->pbFormat = (BYTE*)This->videoinfo;
 649     return S_OK;
 650 }
 651
 652 static HRESULT WINAPI AVICompressorOut_DecideBufferSize(BaseOutputPin *base, IMemAllocator *alloc, ALLOCATOR_PROPERTIES *ppropInputRequest)
 653 {
 654     AVICompressor *This = impl_from_BasePin(&base->pin);
 655     ALLOCATOR_PROPERTIES actual;
 656
 657     TRACE("(%p)\n", This);
 658
 659     if (!ppropInputRequest->cBuffers)
 660         ppropInputRequest->cBuffers = 1;
 661     if (ppropInputRequest->cbBuffer < This->videoinfo->bmiHeader.biSizeImage)
 662         ppropInputRequest->cbBuffer = This->videoinfo->bmiHeader.biSizeImage;
 663     if (!ppropInputRequest->cbAlign)
 664         ppropInputRequest->cbAlign = 1;
 665
 666     return IMemAllocator_SetProperties(alloc, ppropInputRequest, &actual);
 667 }
 668
 669 static HRESULT WINAPI AVICompressorOut_DecideAllocator(BaseOutputPin *base,
 670         IMemInputPin *pPin, IMemAllocator **pAlloc)
 671 {
 672     TRACE("(%p)->(%p %p)\n", base, pPin, pAlloc);
 673     return BaseOutputPinImpl_DecideAllocator(base, pPin, pAlloc);
 674 }
 675
 676 static HRESULT WINAPI AVICompressorOut_BreakConnect(BaseOutputPin *base)
 677 {
 678     FIXME("(%p)\n", base);
 679     return E_NOTIMPL;
 680 }
 681
 682 static const BaseOutputPinFuncTable AVICompressorBaseOutputPinVtbl = {
 683     {
 684         NULL,
 685         BaseOutputPinImpl_AttemptConnection,
 686         AVICompressorOut_GetMediaTypeVersion,
 687         AVICompressorOut_GetMediaType
 688     },
 689     AVICompressorOut_DecideBufferSize,
 690     AVICompressorOut_DecideAllocator,
 691     AVICompressorOut_BreakConnect
 692 };
 693
 694 IUnknown* WINAPI QCAP_createAVICompressor(IUnknown *outer, HRESULT *phr)
 695 {
 696     PIN_INFO in_pin_info  = {NULL, PINDIR_INPUT,  {'I','n','p','u','t',0}};
 697     PIN_INFO out_pin_info = {NULL, PINDIR_OUTPUT, {'O','u','t','p','u','t',0}};
 698     AVICompressor *compressor;
 699     HRESULT hres;
 700
 701     TRACE("\n");
 702
 703     compressor = heap_alloc_zero(sizeof(*compressor));
 704     if(!compressor) {
 705         *phr = E_NOINTERFACE;
 706         return NULL;
 707     }
 708
 709     BaseFilter_Init(&compressor->filter, &AVICompressorVtbl, &CLSID_AVICo,
 710             (DWORD_PTR)(__FILE__ ": AVICompressor.csFilter"), &filter_func_table);
 711
 712     compressor->IPersistPropertyBag_iface.lpVtbl = &PersistPropertyBagVtbl;
 713
 714     in_pin_info.pFilter = &compressor->filter.IBaseFilter_iface;
 715     hres = BaseInputPin_Construct(&AVICompressorInputPinVtbl, sizeof(BaseInputPin), &in_pin_info,
 716             &AVICompressorBaseInputPinVtbl, &compressor->filter.csFilter, NULL, (IPin**)&compressor->in);
 717     if(FAILED(hres)) {
 718         IBaseFilter_Release(&compressor->filter.IBaseFilter_iface);
 719         *phr = hres;
 720         return NULL;
 721     }
 722
 723     out_pin_info.pFilter = &compressor->filter.IBaseFilter_iface;
 724     hres = BaseOutputPin_Construct(&AVICompressorOutputPinVtbl, sizeof(BaseOutputPin), &out_pin_info,
 725             &AVICompressorBaseOutputPinVtbl, &compressor->filter.csFilter, (IPin**)&compressor->out);
 726     if(FAILED(hres)) {
 727         IBaseFilter_Release(&compressor->filter.IBaseFilter_iface);
 728         *phr = hres;
 729         return NULL;
 730     }
 731
 732     *phr = S_OK;
 733     return (IUnknown*)&compressor->filter.IBaseFilter_iface;
 734 }