dlls/quartz/avidec.c

   1 /*
   2  * AVI Decompressor (VFW decompressors wrapper)
   3  *
   4  * Copyright 2004-2005 Christian Costa
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "quartz_private.h"
  22
  23 #include "uuids.h"
  24 #include "amvideo.h"
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "dshow.h"
  28 #include "strmif.h"
  29 #include "vfwmsgs.h"
  30 #include "vfw.h"
  31 #include "dvdmedia.h"
  32
  33 #include <assert.h>
  34
  35 #include "wine/debug.h"
  36
  37 WINE_DEFAULT_DEBUG_CHANNEL(quartz);
  38
  39 struct avi_decompressor
  40 {
  41     struct strmbase_filter filter;
  42
  43     struct strmbase_source source;
  44     IQualityControl source_IQualityControl_iface;
  45     struct strmbase_passthrough passthrough;
  46
  47     struct strmbase_sink sink;
  48
  49     HIC hvid;
  50     BITMAPINFOHEADER* pBihIn;
  51     REFERENCE_TIME late;
  52 };
  53
  54 static struct avi_decompressor *impl_from_strmbase_filter(struct strmbase_filter *iface)
  55 {
  56     return CONTAINING_RECORD(iface, struct avi_decompressor, filter);
  57 }
  58
  59 static HRESULT avi_decompressor_sink_query_interface(struct strmbase_pin *iface, REFIID iid, void **out)
  60 {
  61     struct avi_decompressor *filter = impl_from_strmbase_filter(iface->filter);
  62
  63     if (IsEqualGUID(iid, &IID_IMemInputPin))
  64         *out = &filter->sink.IMemInputPin_iface;
  65     else
  66         return E_NOINTERFACE;
  67
  68     IUnknown_AddRef((IUnknown *)*out);
  69     return S_OK;
  70 }
  71
  72 static HRESULT avi_decompressor_sink_query_accept(struct strmbase_pin *iface, const AM_MEDIA_TYPE *mt)
  73 {
  74     return S_OK;
  75 }
  76
  77 static HRESULT avi_decompressor_sink_end_flush(struct strmbase_sink *iface)
  78 {
  79     struct avi_decompressor *filter = impl_from_strmbase_filter(iface->pin.filter);
  80     filter->late = -1;
  81     if (filter->source.pin.peer)
  82         return IPin_EndFlush(filter->source.pin.peer);
  83     return S_OK;
  84 }
  85
  86 static int AVIDec_DropSample(struct avi_decompressor *This, REFERENCE_TIME tStart)
  87 {
  88     if (This->late < 0)
  89         return 0;
  90
  91     if (tStart < This->late) {
  92         TRACE("Dropping sample\n");
  93         return 1;
  94     }
  95     This->late = -1;
  96     return 0;
  97 }
  98
  99 static HRESULT WINAPI avi_decompressor_sink_Receive(struct strmbase_sink *iface, IMediaSample *pSample)
 100 {
 101     struct avi_decompressor *This = impl_from_strmbase_filter(iface->pin.filter);
 102     VIDEOINFOHEADER *source_format;
 103     HRESULT hr;
 104     DWORD res;
 105     IMediaSample* pOutSample = NULL;
 106     DWORD cbDstStream;
 107     LPBYTE pbDstStream;
 108     DWORD cbSrcStream;
 109     LPBYTE pbSrcStream;
 110     LONGLONG tStart, tStop;
 111     DWORD flags = 0;
 112
 113     /* We do not expect pin connection state to change while the filter is
 114      * running. This guarantee is necessary, since otherwise we would have to
 115      * take the filter lock, and we can't take the filter lock from a streaming
 116      * thread. */
 117     if (!This->source.pMemInputPin)
 118     {
 119         WARN("Source is not connected, returning VFW_E_NOT_CONNECTED.\n");
 120         return VFW_E_NOT_CONNECTED;
 121     }
 122
 123     source_format = (VIDEOINFOHEADER *)This->source.pin.mt.pbFormat;
 124
 125     if (This->filter.state == State_Stopped)
 126         return VFW_E_WRONG_STATE;
 127
 128     if (This->sink.flushing)
 129         return S_FALSE;
 130
 131     hr = IMediaSample_GetPointer(pSample, &pbSrcStream);
 132     if (FAILED(hr))
 133     {
 134         ERR("Cannot get pointer to sample data (%x)\n", hr);
 135         return hr;
 136     }
 137
 138     cbSrcStream = IMediaSample_GetActualDataLength(pSample);
 139
 140     TRACE("Sample data ptr = %p, size = %d\n", pbSrcStream, cbSrcStream);
 141
 142     /* Update input size to match sample size */
 143     This->pBihIn->biSizeImage = cbSrcStream;
 144
 145     hr = BaseOutputPinImpl_GetDeliveryBuffer(&This->source, &pOutSample, NULL, NULL, 0);
 146     if (FAILED(hr)) {
 147         ERR("Unable to get delivery buffer (%x)\n", hr);
 148         return hr;
 149     }
 150
 151     hr = IMediaSample_SetActualDataLength(pOutSample, 0);
 152     assert(hr == S_OK);
 153
 154     hr = IMediaSample_GetPointer(pOutSample, &pbDstStream);
 155     if (FAILED(hr)) {
 156         ERR("Unable to get pointer to buffer (%x)\n", hr);
 157         IMediaSample_Release(pOutSample);
 158         return hr;
 159     }
 160     cbDstStream = IMediaSample_GetSize(pOutSample);
 161     if (cbDstStream < source_format->bmiHeader.biSizeImage)
 162     {
 163         ERR("Sample size is too small (%u < %u).\n", cbDstStream, source_format->bmiHeader.biSizeImage);
 164         IMediaSample_Release(pOutSample);
 165         return E_FAIL;
 166     }
 167
 168     if (IMediaSample_IsPreroll(pSample) == S_OK)
 169         flags |= ICDECOMPRESS_PREROLL;
 170     if (IMediaSample_IsSyncPoint(pSample) != S_OK)
 171         flags |= ICDECOMPRESS_NOTKEYFRAME;
 172     hr = IMediaSample_GetTime(pSample, &tStart, &tStop);
 173     if (hr == S_OK && AVIDec_DropSample(This, tStart))
 174         flags |= ICDECOMPRESS_HURRYUP;
 175
 176     res = ICDecompress(This->hvid, flags, This->pBihIn, pbSrcStream, &source_format->bmiHeader, pbDstStream);
 177     if (res != ICERR_OK)
 178         ERR("Error occurred during the decompression (%x)\n", res);
 179
 180     /* Drop sample if it's intended to be dropped */
 181     if (flags & ICDECOMPRESS_HURRYUP) {
 182         IMediaSample_Release(pOutSample);
 183         return S_OK;
 184     }
 185
 186     IMediaSample_SetActualDataLength(pOutSample, source_format->bmiHeader.biSizeImage);
 187
 188     IMediaSample_SetPreroll(pOutSample, (IMediaSample_IsPreroll(pSample) == S_OK));
 189     IMediaSample_SetDiscontinuity(pOutSample, (IMediaSample_IsDiscontinuity(pSample) == S_OK));
 190     IMediaSample_SetSyncPoint(pOutSample, (IMediaSample_IsSyncPoint(pSample) == S_OK));
 191
 192     if (hr == S_OK)
 193         IMediaSample_SetTime(pOutSample, &tStart, &tStop);
 194     else if (hr == VFW_S_NO_STOP_TIME)
 195         IMediaSample_SetTime(pOutSample, &tStart, NULL);
 196     else
 197         IMediaSample_SetTime(pOutSample, NULL, NULL);
 198
 199     hr = IMemInputPin_Receive(This->source.pMemInputPin, pOutSample);
 200     if (hr != S_OK && hr != VFW_E_NOT_CONNECTED)
 201         ERR("Error sending sample (%x)\n", hr);
 202
 203     IMediaSample_Release(pOutSample);
 204     return hr;
 205 }
 206
 207 static HRESULT avi_decompressor_sink_connect(struct strmbase_sink *iface, IPin *peer, const AM_MEDIA_TYPE *pmt)
 208 {
 209     struct avi_decompressor *This = impl_from_strmbase_filter(iface->pin.filter);
 210     HRESULT hr = VFW_E_TYPE_NOT_ACCEPTED;
 211
 212     /* Check root (GUID w/o FOURCC) */
 213     if ((IsEqualIID(&pmt->majortype, &MEDIATYPE_Video)) &&
 214         (!memcmp(((const char *)&pmt->subtype)+4, ((const char *)&MEDIATYPE_Video)+4, sizeof(GUID)-4)))
 215     {
 216         VIDEOINFOHEADER *format1 = (VIDEOINFOHEADER *)pmt->pbFormat;
 217         VIDEOINFOHEADER2 *format2 = (VIDEOINFOHEADER2 *)pmt->pbFormat;
 218         BITMAPINFOHEADER *bmi;
 219
 220         if (IsEqualIID(&pmt->formattype, &FORMAT_VideoInfo))
 221             bmi = &format1->bmiHeader;
 222         else if (IsEqualIID(&pmt->formattype, &FORMAT_VideoInfo2))
 223             bmi = &format2->bmiHeader;
 224         else
 225             goto failed;
 226
 227         This->hvid = ICLocate(pmt->majortype.Data1, pmt->subtype.Data1, bmi, NULL, ICMODE_DECOMPRESS);
 228         if (This->hvid)
 229         {
 230             DWORD bih_size;
 231             DWORD result;
 232
 233             /* Copy bitmap header from media type to 1 for input and 1 for output */
 234             bih_size = bmi->biSize + bmi->biClrUsed * 4;
 235             This->pBihIn = CoTaskMemAlloc(bih_size);
 236             if (!This->pBihIn)
 237             {
 238                 hr = E_OUTOFMEMORY;
 239                 goto failed;
 240             }
 241             memcpy(This->pBihIn, bmi, bih_size);
 242
 243             if ((result = ICDecompressQuery(This->hvid, This->pBihIn, NULL)))
 244             {
 245                 WARN("No decompressor found, error %d.\n", result);
 246                 return VFW_E_TYPE_NOT_ACCEPTED;
 247             }
 248
 249             TRACE("Connection accepted\n");
 250             return S_OK;
 251         }
 252         TRACE("Unable to find a suitable VFW decompressor\n");
 253     }
 254
 255 failed:
 256
 257     TRACE("Connection refused\n");
 258     return hr;
 259 }
 260
 261 static void avi_decompressor_sink_disconnect(struct strmbase_sink *iface)
 262 {
 263     struct avi_decompressor *filter = impl_from_strmbase_filter(iface->pin.filter);
 264
 265     if (filter->hvid)
 266         ICClose(filter->hvid);
 267     CoTaskMemFree(filter->pBihIn);
 268     filter->hvid = NULL;
 269     filter->pBihIn = NULL;
 270 }
 271
 272 static const struct strmbase_sink_ops sink_ops =
 273 {
 274     .base.pin_query_interface = avi_decompressor_sink_query_interface,
 275     .base.pin_query_accept = avi_decompressor_sink_query_accept,
 276     .pfnReceive = avi_decompressor_sink_Receive,
 277     .sink_connect = avi_decompressor_sink_connect,
 278     .sink_disconnect = avi_decompressor_sink_disconnect,
 279     .sink_end_flush = avi_decompressor_sink_end_flush,
 280 };
 281
 282 static HRESULT avi_decompressor_source_query_interface(struct strmbase_pin *iface, REFIID iid, void **out)
 283 {
 284     struct avi_decompressor *filter = impl_from_strmbase_filter(iface->filter);
 285
 286     if (IsEqualGUID(iid, &IID_IQualityControl))
 287         *out = &filter->source_IQualityControl_iface;
 288     else if (IsEqualGUID(iid, &IID_IMediaSeeking))
 289         *out = &filter->passthrough.IMediaSeeking_iface;
 290     else
 291         return E_NOINTERFACE;
 292
 293     IUnknown_AddRef((IUnknown *)*out);
 294     return S_OK;
 295 }
 296
 297 static HRESULT avi_decompressor_source_query_accept(struct strmbase_pin *iface, const AM_MEDIA_TYPE *mt)
 298 {
 299     struct avi_decompressor *filter = impl_from_strmbase_filter(iface->filter);
 300     VIDEOINFOHEADER *sink_format, *format;
 301
 302     if (!filter->sink.pin.peer || !IsEqualGUID(&mt->formattype, &FORMAT_VideoInfo))
 303         return S_FALSE;
 304
 305     sink_format = (VIDEOINFOHEADER *)filter->sink.pin.mt.pbFormat;
 306     format = (VIDEOINFOHEADER *)mt->pbFormat;
 307
 308     if (ICDecompressQuery(filter->hvid, &sink_format->bmiHeader, &format->bmiHeader))
 309         return S_FALSE;
 310
 311     return S_OK;
 312 }
 313
 314 static HRESULT avi_decompressor_source_get_media_type(struct strmbase_pin *iface,
 315         unsigned int index, AM_MEDIA_TYPE *mt)
 316 {
 317     static const struct
 318     {
 319         const GUID *subtype;
 320         DWORD compression;
 321         WORD bpp;
 322     }
 323     formats[] =
 324     {
 325         {&MEDIASUBTYPE_CLJR, mmioFOURCC('C','L','J','R'), 8},
 326         {&MEDIASUBTYPE_UYVY, mmioFOURCC('U','Y','V','Y'), 16},
 327         {&MEDIASUBTYPE_YUY2, mmioFOURCC('Y','U','Y','2'), 16},
 328         {&MEDIASUBTYPE_RGB32, BI_RGB, 32},
 329         {&MEDIASUBTYPE_RGB24, BI_RGB, 24},
 330         {&MEDIASUBTYPE_RGB565, BI_BITFIELDS, 16},
 331         {&MEDIASUBTYPE_RGB555, BI_RGB, 16},
 332         {&MEDIASUBTYPE_RGB8, BI_RGB, 8},
 333     };
 334
 335     struct avi_decompressor *filter = impl_from_strmbase_filter(iface->filter);
 336     const VIDEOINFOHEADER *sink_format;
 337     VIDEOINFO *format;
 338
 339     if (!filter->sink.pin.peer)
 340         return VFW_S_NO_MORE_ITEMS;
 341
 342     sink_format = (VIDEOINFOHEADER *)filter->sink.pin.mt.pbFormat;
 343
 344     memset(mt, 0, sizeof(AM_MEDIA_TYPE));
 345
 346     if (index < ARRAY_SIZE(formats))
 347     {
 348         if (!(format = CoTaskMemAlloc(offsetof(VIDEOINFO, dwBitMasks[3]))))
 349             return E_OUTOFMEMORY;
 350         memset(format, 0, offsetof(VIDEOINFO, dwBitMasks[3]));
 351
 352         format->rcSource = sink_format->rcSource;
 353         format->rcTarget = sink_format->rcTarget;
 354         format->dwBitRate = sink_format->dwBitRate;
 355         format->dwBitErrorRate = sink_format->dwBitErrorRate;
 356         format->AvgTimePerFrame = sink_format->AvgTimePerFrame;
 357
 358         format->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
 359         format->bmiHeader.biWidth = sink_format->bmiHeader.biWidth;
 360         format->bmiHeader.biHeight = sink_format->bmiHeader.biHeight;
 361         format->bmiHeader.biPlanes = sink_format->bmiHeader.biPlanes;
 362         format->bmiHeader.biBitCount = formats[index].bpp;
 363         format->bmiHeader.biCompression = formats[index].compression;
 364         format->bmiHeader.biSizeImage = format->bmiHeader.biWidth
 365                 * format->bmiHeader.biHeight * formats[index].bpp / 8;
 366
 367         if (IsEqualGUID(formats[index].subtype, &MEDIASUBTYPE_RGB565))
 368         {
 369             format->dwBitMasks[iRED] = 0xf800;
 370             format->dwBitMasks[iGREEN] = 0x07e0;
 371             format->dwBitMasks[iBLUE] = 0x001f;
 372             mt->cbFormat = offsetof(VIDEOINFO, dwBitMasks[3]);
 373         }
 374         else
 375             mt->cbFormat = sizeof(VIDEOINFOHEADER);
 376
 377         mt->majortype = MEDIATYPE_Video;
 378         mt->subtype = *formats[index].subtype;
 379         mt->bFixedSizeSamples = TRUE;
 380         mt->lSampleSize = format->bmiHeader.biSizeImage;
 381         mt->formattype = FORMAT_VideoInfo;
 382         mt->pbFormat = (BYTE *)format;
 383
 384         return S_OK;
 385     }
 386
 387     if (index == ARRAY_SIZE(formats))
 388     {
 389         size_t size = ICDecompressGetFormatSize(filter->hvid, &sink_format->bmiHeader);
 390
 391         if (!size)
 392             return VFW_S_NO_MORE_ITEMS;
 393
 394         mt->cbFormat = offsetof(VIDEOINFOHEADER, bmiHeader) + size;
 395         if (!(format = CoTaskMemAlloc(mt->cbFormat)))
 396             return E_OUTOFMEMORY;
 397         memset(format, 0, mt->cbFormat);
 398
 399         format->rcSource = sink_format->rcSource;
 400         format->rcTarget = sink_format->rcTarget;
 401         format->dwBitRate = sink_format->dwBitRate;
 402         format->dwBitErrorRate = sink_format->dwBitErrorRate;
 403         format->AvgTimePerFrame = sink_format->AvgTimePerFrame;
 404
 405         if (ICDecompressGetFormat(filter->hvid, &sink_format->bmiHeader, &format->bmiHeader))
 406         {
 407             CoTaskMemFree(format);
 408             return VFW_S_NO_MORE_ITEMS;
 409         }
 410
 411         mt->majortype = MEDIATYPE_Video;
 412         mt->subtype = MEDIATYPE_Video;
 413         mt->subtype.Data1 = format->bmiHeader.biCompression;
 414         mt->bFixedSizeSamples = TRUE;
 415         mt->lSampleSize = format->bmiHeader.biSizeImage;
 416         mt->formattype = FORMAT_VideoInfo;
 417         mt->pbFormat = (BYTE *)format;
 418
 419         return S_OK;
 420     }
 421
 422     return VFW_S_NO_MORE_ITEMS;
 423 }
 424
 425 static HRESULT WINAPI avi_decompressor_source_DecideBufferSize(struct strmbase_source *iface,
 426         IMemAllocator *pAlloc, ALLOCATOR_PROPERTIES *ppropInputRequest)
 427 {
 428     const VIDEOINFOHEADER *source_format = (VIDEOINFOHEADER *)iface->pin.mt.pbFormat;
 429     ALLOCATOR_PROPERTIES actual;
 430
 431     if (!ppropInputRequest->cbAlign)
 432         ppropInputRequest->cbAlign = 1;
 433
 434     if (ppropInputRequest->cbBuffer < source_format->bmiHeader.biSizeImage)
 435         ppropInputRequest->cbBuffer = source_format->bmiHeader.biSizeImage;
 436
 437     if (!ppropInputRequest->cBuffers)
 438         ppropInputRequest->cBuffers = 1;
 439
 440     return IMemAllocator_SetProperties(pAlloc, ppropInputRequest, &actual);
 441 }
 442
 443 static const struct strmbase_source_ops source_ops =
 444 {
 445     .base.pin_query_interface = avi_decompressor_source_query_interface,
 446     .base.pin_query_accept = avi_decompressor_source_query_accept,
 447     .base.pin_get_media_type = avi_decompressor_source_get_media_type,
 448     .pfnAttemptConnection = BaseOutputPinImpl_AttemptConnection,
 449     .pfnDecideAllocator = BaseOutputPinImpl_DecideAllocator,
 450     .pfnDecideBufferSize = avi_decompressor_source_DecideBufferSize,
 451 };
 452
 453 static struct avi_decompressor *impl_from_source_IQualityControl(IQualityControl *iface)
 454 {
 455     return CONTAINING_RECORD(iface, struct avi_decompressor, source_IQualityControl_iface);
 456 }
 457
 458 static HRESULT WINAPI avi_decompressor_source_qc_QueryInterface(IQualityControl *iface,
 459         REFIID iid, void **out)
 460 {
 461     struct avi_decompressor *filter = impl_from_source_IQualityControl(iface);
 462     return IPin_QueryInterface(&filter->source.pin.IPin_iface, iid, out);
 463 }
 464
 465 static ULONG WINAPI avi_decompressor_source_qc_AddRef(IQualityControl *iface)
 466 {
 467     struct avi_decompressor *filter = impl_from_source_IQualityControl(iface);
 468     return IPin_AddRef(&filter->source.pin.IPin_iface);
 469 }
 470
 471 static ULONG WINAPI avi_decompressor_source_qc_Release(IQualityControl *iface)
 472 {
 473     struct avi_decompressor *filter = impl_from_source_IQualityControl(iface);
 474     return IPin_Release(&filter->source.pin.IPin_iface);
 475 }
 476
 477 static HRESULT WINAPI avi_decompressor_source_qc_Notify(IQualityControl *iface,
 478         IBaseFilter *sender, Quality q)
 479 {
 480     struct avi_decompressor *filter = impl_from_source_IQualityControl(iface);
 481
 482     TRACE("filter %p, sender %p, type %#x, proportion %u, late %s, timestamp %s.\n",
 483             filter, sender, q.Type, q.Proportion, debugstr_time(q.Late), debugstr_time(q.TimeStamp));
 484
 485     EnterCriticalSection(&filter->filter.stream_cs);
 486     if (q.Late > 0)
 487         filter->late = q.Late + q.TimeStamp;
 488     else
 489         filter->late = -1;
 490     LeaveCriticalSection(&filter->filter.stream_cs);
 491     return S_OK;
 492 }
 493
 494 static HRESULT WINAPI avi_decompressor_source_qc_SetSink(IQualityControl *iface, IQualityControl *sink)
 495 {
 496     struct avi_decompressor *filter = impl_from_source_IQualityControl(iface);
 497
 498     TRACE("filter %p, sink %p.\n", filter, sink);
 499
 500     return S_OK;
 501 }
 502
 503 static const IQualityControlVtbl source_qc_vtbl =
 504 {
 505     avi_decompressor_source_qc_QueryInterface,
 506     avi_decompressor_source_qc_AddRef,
 507     avi_decompressor_source_qc_Release,
 508     avi_decompressor_source_qc_Notify,
 509     avi_decompressor_source_qc_SetSink,
 510 };
 511
 512 static struct strmbase_pin *avi_decompressor_get_pin(struct strmbase_filter *iface, unsigned int index)
 513 {
 514     struct avi_decompressor *filter = impl_from_strmbase_filter(iface);
 515
 516     if (index == 0)
 517         return &filter->sink.pin;
 518     else if (index == 1)
 519         return &filter->source.pin;
 520     return NULL;
 521 }
 522
 523 static void avi_decompressor_destroy(struct strmbase_filter *iface)
 524 {
 525     struct avi_decompressor *filter = impl_from_strmbase_filter(iface);
 526
 527     if (filter->sink.pin.peer)
 528         IPin_Disconnect(filter->sink.pin.peer);
 529     IPin_Disconnect(&filter->sink.pin.IPin_iface);
 530
 531     if (filter->source.pin.peer)
 532         IPin_Disconnect(filter->source.pin.peer);
 533     IPin_Disconnect(&filter->source.pin.IPin_iface);
 534
 535     strmbase_sink_cleanup(&filter->sink);
 536     strmbase_source_cleanup(&filter->source);
 537     strmbase_passthrough_cleanup(&filter->passthrough);
 538
 539     strmbase_filter_cleanup(&filter->filter);
 540     free(filter);
 541 }
 542
 543 static HRESULT avi_decompressor_init_stream(struct strmbase_filter *iface)
 544 {
 545     struct avi_decompressor *filter = impl_from_strmbase_filter(iface);
 546     VIDEOINFOHEADER *source_format;
 547     LRESULT res;
 548     HRESULT hr;
 549
 550     if (!filter->source.pin.peer)
 551         return S_OK;
 552
 553     filter->late = -1;
 554
 555     source_format = (VIDEOINFOHEADER *)filter->sink.pin.mt.pbFormat;
 556     if ((res = ICDecompressBegin(filter->hvid, filter->pBihIn, &source_format->bmiHeader)))
 557     {
 558         ERR("ICDecompressBegin() failed, error %ld.\n", res);
 559         return E_FAIL;
 560     }
 561
 562     if (FAILED(hr = IMemAllocator_Commit(filter->source.pAllocator)))
 563         ERR("Failed to commit allocator, hr %#x.\n", hr);
 564
 565     return S_OK;
 566 }
 567
 568 static HRESULT avi_decompressor_cleanup_stream(struct strmbase_filter *iface)
 569 {
 570     struct avi_decompressor *filter = impl_from_strmbase_filter(iface);
 571     LRESULT res;
 572
 573     if (!filter->source.pin.peer)
 574         return S_OK;
 575
 576     if (filter->hvid && (res = ICDecompressEnd(filter->hvid)))
 577     {
 578         ERR("ICDecompressEnd() failed, error %ld.\n", res);
 579         return E_FAIL;
 580     }
 581
 582     IMemAllocator_Decommit(filter->source.pAllocator);
 583
 584     return S_OK;
 585 }
 586
 587 static const struct strmbase_filter_ops filter_ops =
 588 {
 589     .filter_get_pin = avi_decompressor_get_pin,
 590     .filter_destroy = avi_decompressor_destroy,
 591     .filter_init_stream = avi_decompressor_init_stream,
 592     .filter_cleanup_stream = avi_decompressor_cleanup_stream,
 593 };
 594
 595 HRESULT avi_dec_create(IUnknown *outer, IUnknown **out)
 596 {
 597     struct avi_decompressor *object;
 598
 599     if (!(object = calloc(1, sizeof(*object))))
 600         return E_OUTOFMEMORY;
 601
 602     strmbase_filter_init(&object->filter, outer, &CLSID_AVIDec, &filter_ops);
 603
 604     strmbase_sink_init(&object->sink, &object->filter, L"In", &sink_ops, NULL);
 605
 606     strmbase_source_init(&object->source, &object->filter, L"Out", &source_ops);
 607     object->source_IQualityControl_iface.lpVtbl = &source_qc_vtbl;
 608     strmbase_passthrough_init(&object->passthrough, (IUnknown *)&object->source.pin.IPin_iface);
 609     ISeekingPassThru_Init(&object->passthrough.ISeekingPassThru_iface, FALSE,
 610             &object->sink.pin.IPin_iface);
 611
 612     TRACE("Created AVI decompressor %p.\n", object);
 613     *out = &object->filter.IUnknown_inner;
 614
 615     return S_OK;
 616 }