dlls/strmbase/pin.c

   1 /*
   2  * Generic Implementation of IPin Interface
   3  *
   4  * Copyright 2003 Robert Shearman
   5  * Copyright 2010 Aric Stewart, CodeWeavers
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include "strmbase_private.h"
  23
  24 WINE_DEFAULT_DEBUG_CHANNEL(quartz);
  25
  26 static const IMemInputPinVtbl MemInputPin_Vtbl;
  27
  28 typedef HRESULT (*SendPinFunc)( IPin *to, LPVOID arg );
  29
  30 struct enum_media_types
  31 {
  32     IEnumMediaTypes IEnumMediaTypes_iface;
  33     LONG refcount;
  34
  35     unsigned int index, count;
  36     struct strmbase_pin *pin;
  37 };
  38
  39 static const IEnumMediaTypesVtbl enum_media_types_vtbl;
  40
  41 static HRESULT enum_media_types_create(struct strmbase_pin *pin, IEnumMediaTypes **out)
  42 {
  43     struct enum_media_types *object;
  44     AM_MEDIA_TYPE mt;
  45
  46     if (!out)
  47         return E_POINTER;
  48
  49     if (!(object = heap_alloc_zero(sizeof(*object))))
  50     {
  51         *out = NULL;
  52         return E_OUTOFMEMORY;
  53     }
  54
  55     object->IEnumMediaTypes_iface.lpVtbl = &enum_media_types_vtbl;
  56     object->refcount = 1;
  57     object->pin = pin;
  58     IPin_AddRef(&pin->IPin_iface);
  59
  60     if (pin->ops->pin_get_media_type)
  61     {
  62         while (pin->ops->pin_get_media_type(pin, object->count, &mt) == S_OK)
  63         {
  64             FreeMediaType(&mt);
  65             ++object->count;
  66         }
  67     }
  68
  69     TRACE("Created enumerator %p.\n", object);
  70     *out = &object->IEnumMediaTypes_iface;
  71
  72     return S_OK;
  73 }
  74
  75 static struct enum_media_types *impl_from_IEnumMediaTypes(IEnumMediaTypes *iface)
  76 {
  77     return CONTAINING_RECORD(iface, struct enum_media_types, IEnumMediaTypes_iface);
  78 }
  79
  80 static HRESULT WINAPI enum_media_types_QueryInterface(IEnumMediaTypes *iface, REFIID iid, void **out)
  81 {
  82     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
  83
  84     if (IsEqualGUID(iid, &IID_IUnknown) || IsEqualGUID(iid, &IID_IEnumMediaTypes))
  85     {
  86         IEnumMediaTypes_AddRef(iface);
  87         *out = iface;
  88         return S_OK;
  89     }
  90
  91     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
  92     *out = NULL;
  93     return E_NOINTERFACE;
  94 }
  95
  96 static ULONG WINAPI enum_media_types_AddRef(IEnumMediaTypes *iface)
  97 {
  98     struct enum_media_types *enummt = impl_from_IEnumMediaTypes(iface);
  99     ULONG refcount = InterlockedIncrement(&enummt->refcount);
 100     TRACE("%p increasing refcount to %u.\n", enummt, refcount);
 101     return refcount;
 102 }
 103
 104 static ULONG WINAPI enum_media_types_Release(IEnumMediaTypes *iface)
 105 {
 106     struct enum_media_types *enummt = impl_from_IEnumMediaTypes(iface);
 107     ULONG refcount = InterlockedDecrement(&enummt->refcount);
 108
 109     TRACE("%p decreasing refcount to %u.\n", enummt, refcount);
 110     if (!refcount)
 111     {
 112         IPin_Release(&enummt->pin->IPin_iface);
 113         heap_free(enummt);
 114     }
 115     return refcount;
 116 }
 117
 118 static HRESULT WINAPI enum_media_types_Next(IEnumMediaTypes *iface, ULONG count,
 119         AM_MEDIA_TYPE **mts, ULONG *ret_count)
 120 {
 121     struct enum_media_types *enummt = impl_from_IEnumMediaTypes(iface);
 122     AM_MEDIA_TYPE mt;
 123     unsigned int i;
 124     HRESULT hr;
 125
 126     TRACE("enummt %p, count %u, mts %p, ret_count %p.\n", enummt, count, mts, ret_count);
 127
 128     if (!enummt->pin->ops->pin_get_media_type)
 129     {
 130         if (ret_count)
 131             *ret_count = 0;
 132         return count ? S_FALSE : S_OK;
 133     }
 134
 135     for (i = 0; i < count; ++i)
 136     {
 137         hr = enummt->pin->ops->pin_get_media_type(enummt->pin, enummt->index + i, &mt);
 138         if (hr == S_OK)
 139         {
 140             if ((mts[i] = CoTaskMemAlloc(sizeof(AM_MEDIA_TYPE))))
 141                 *mts[i] = mt;
 142             else
 143                 hr = E_OUTOFMEMORY;
 144         }
 145         if (FAILED(hr))
 146         {
 147             while (i--)
 148                 DeleteMediaType(mts[i]);
 149             *ret_count = 0;
 150             return E_OUTOFMEMORY;
 151         }
 152         else if (hr != S_OK)
 153             break;
 154
 155         if (TRACE_ON(quartz))
 156         {
 157             TRACE("Returning media type %u:\n", enummt->index + i);
 158             strmbase_dump_media_type(mts[i]);
 159         }
 160     }
 161
 162     if (count != 1 || ret_count)
 163         *ret_count = i;
 164     enummt->index += i;
 165     return i == count ? S_OK : S_FALSE;
 166 }
 167
 168 static HRESULT WINAPI enum_media_types_Skip(IEnumMediaTypes *iface, ULONG count)
 169 {
 170     struct enum_media_types *enummt = impl_from_IEnumMediaTypes(iface);
 171
 172     TRACE("enummt %p, count %u.\n", enummt, count);
 173
 174     enummt->index += count;
 175
 176     return enummt->index > enummt->count ? S_FALSE : S_OK;
 177 }
 178
 179 static HRESULT WINAPI enum_media_types_Reset(IEnumMediaTypes *iface)
 180 {
 181     struct enum_media_types *enummt = impl_from_IEnumMediaTypes(iface);
 182     AM_MEDIA_TYPE mt;
 183
 184     TRACE("enummt %p.\n", enummt);
 185
 186     enummt->count = 0;
 187     if (enummt->pin->ops->pin_get_media_type)
 188     {
 189         while (enummt->pin->ops->pin_get_media_type(enummt->pin, enummt->count, &mt) == S_OK)
 190         {
 191             FreeMediaType(&mt);
 192             ++enummt->count;
 193         }
 194     }
 195
 196     enummt->index = 0;
 197
 198     return S_OK;
 199 }
 200
 201 static HRESULT WINAPI enum_media_types_Clone(IEnumMediaTypes *iface, IEnumMediaTypes **out)
 202 {
 203     struct enum_media_types *enummt = impl_from_IEnumMediaTypes(iface);
 204     HRESULT hr;
 205
 206     TRACE("enummt %p, out %p.\n", enummt, out);
 207
 208     if (FAILED(hr = enum_media_types_create(enummt->pin, out)))
 209         return hr;
 210     return IEnumMediaTypes_Skip(*out, enummt->index);
 211 }
 212
 213 static const IEnumMediaTypesVtbl enum_media_types_vtbl =
 214 {
 215     enum_media_types_QueryInterface,
 216     enum_media_types_AddRef,
 217     enum_media_types_Release,
 218     enum_media_types_Next,
 219     enum_media_types_Skip,
 220     enum_media_types_Reset,
 221     enum_media_types_Clone,
 222 };
 223
 224 static inline struct strmbase_pin *impl_from_IPin(IPin *iface)
 225 {
 226     return CONTAINING_RECORD(iface, struct strmbase_pin, IPin_iface);
 227 }
 228
 229 /** Helper function, there are a lot of places where the error code is inherited
 230  * The following rules apply:
 231  *
 232  * Return the first received error code (E_NOTIMPL is ignored)
 233  * If no errors occur: return the first received non-error-code that isn't S_OK
 234  */
 235 static HRESULT updatehres( HRESULT original, HRESULT new )
 236 {
 237     if (FAILED( original ) || new == E_NOTIMPL)
 238         return original;
 239
 240     if (FAILED( new ) || original == S_OK)
 241         return new;
 242
 243     return original;
 244 }
 245
 246 /** Sends a message from a pin further to other, similar pins
 247  * fnMiddle is called on each pin found further on the stream.
 248  * fnEnd (can be NULL) is called when the message can't be sent any further (this is a renderer or source)
 249  *
 250  * If the pin given is an input pin, the message will be sent downstream to other input pins
 251  * If the pin given is an output pin, the message will be sent upstream to other output pins
 252  */
 253 static HRESULT SendFurther(struct strmbase_sink *sink, SendPinFunc func, void *arg)
 254 {
 255     struct strmbase_pin *pin;
 256     HRESULT hr = S_OK;
 257     unsigned int i;
 258
 259     for (i = 0; (pin = sink->pin.filter->ops->filter_get_pin(sink->pin.filter, i)); ++i)
 260     {
 261         if (pin->dir == PINDIR_OUTPUT && pin->peer)
 262             hr = updatehres(hr, func(pin->peer, arg));
 263     }
 264
 265     return hr;
 266 }
 267
 268 static HRESULT WINAPI pin_QueryInterface(IPin *iface, REFIID iid, void **out)
 269 {
 270     struct strmbase_pin *pin = impl_from_IPin(iface);
 271     HRESULT hr;
 272
 273     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
 274
 275     *out = NULL;
 276
 277     if (pin->ops->pin_query_interface && SUCCEEDED(hr = pin->ops->pin_query_interface(pin, iid, out)))
 278         return hr;
 279
 280     if (IsEqualIID(iid, &IID_IUnknown) || IsEqualIID(iid, &IID_IPin))
 281         *out = iface;
 282     else
 283     {
 284         WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
 285         return E_NOINTERFACE;
 286     }
 287
 288     IUnknown_AddRef((IUnknown *)*out);
 289     return S_OK;
 290 }
 291
 292 static ULONG WINAPI pin_AddRef(IPin *iface)
 293 {
 294     struct strmbase_pin *pin = impl_from_IPin(iface);
 295     return IBaseFilter_AddRef(&pin->filter->IBaseFilter_iface);
 296 }
 297
 298 static ULONG WINAPI pin_Release(IPin *iface)
 299 {
 300     struct strmbase_pin *pin = impl_from_IPin(iface);
 301     return IBaseFilter_Release(&pin->filter->IBaseFilter_iface);
 302 }
 303
 304 static HRESULT WINAPI pin_ConnectedTo(IPin * iface, IPin ** ppPin)
 305 {
 306     struct strmbase_pin *This = impl_from_IPin(iface);
 307     HRESULT hr;
 308
 309     TRACE("pin %p %s:%s, peer %p.\n", This, debugstr_w(This->filter->name), debugstr_w(This->name), ppPin);
 310
 311     EnterCriticalSection(&This->filter->filter_cs);
 312     {
 313         if (This->peer)
 314         {
 315             *ppPin = This->peer;
 316             IPin_AddRef(*ppPin);
 317             hr = S_OK;
 318         }
 319         else
 320         {
 321             hr = VFW_E_NOT_CONNECTED;
 322             *ppPin = NULL;
 323         }
 324     }
 325     LeaveCriticalSection(&This->filter->filter_cs);
 326
 327     return hr;
 328 }
 329
 330 static HRESULT WINAPI pin_ConnectionMediaType(IPin *iface, AM_MEDIA_TYPE *pmt)
 331 {
 332     struct strmbase_pin *This = impl_from_IPin(iface);
 333     HRESULT hr;
 334
 335     TRACE("pin %p %s:%s, pmt %p.\n", This, debugstr_w(This->filter->name), debugstr_w(This->name), pmt);
 336
 337     EnterCriticalSection(&This->filter->filter_cs);
 338     {
 339         if (This->peer)
 340         {
 341             CopyMediaType(pmt, &This->mt);
 342             strmbase_dump_media_type(pmt);
 343             hr = S_OK;
 344         }
 345         else
 346         {
 347             ZeroMemory(pmt, sizeof(*pmt));
 348             hr = VFW_E_NOT_CONNECTED;
 349         }
 350     }
 351     LeaveCriticalSection(&This->filter->filter_cs);
 352
 353     return hr;
 354 }
 355
 356 static HRESULT WINAPI pin_QueryPinInfo(IPin *iface, PIN_INFO *info)
 357 {
 358     struct strmbase_pin *pin = impl_from_IPin(iface);
 359
 360     TRACE("pin %p %s:%s, info %p.\n", pin, debugstr_w(pin->filter->name), debugstr_w(pin->name), info);
 361
 362     info->dir = pin->dir;
 363     IBaseFilter_AddRef(info->pFilter = &pin->filter->IBaseFilter_iface);
 364     lstrcpyW(info->achName, pin->name);
 365
 366     return S_OK;
 367 }
 368
 369 static HRESULT WINAPI pin_QueryDirection(IPin *iface, PIN_DIRECTION *dir)
 370 {
 371     struct strmbase_pin *pin = impl_from_IPin(iface);
 372
 373     TRACE("pin %p %s:%s, dir %p.\n", pin, debugstr_w(pin->filter->name), debugstr_w(pin->name), dir);
 374
 375     *dir = pin->dir;
 376
 377     return S_OK;
 378 }
 379
 380 static HRESULT WINAPI pin_QueryId(IPin *iface, WCHAR **id)
 381 {
 382     struct strmbase_pin *pin = impl_from_IPin(iface);
 383
 384     TRACE("pin %p %s:%s, id %p.\n", pin, debugstr_w(pin->filter->name), debugstr_w(pin->name), id);
 385
 386     if (!(*id = CoTaskMemAlloc((lstrlenW(pin->name) + 1) * sizeof(WCHAR))))
 387         return E_OUTOFMEMORY;
 388
 389     lstrcpyW(*id, pin->name);
 390
 391     return S_OK;
 392 }
 393
 394 static BOOL query_accept(struct strmbase_pin *pin, const AM_MEDIA_TYPE *mt)
 395 {
 396     if (pin->ops->pin_query_accept && pin->ops->pin_query_accept(pin, mt) != S_OK)
 397         return FALSE;
 398     return TRUE;
 399 }
 400
 401 static HRESULT WINAPI pin_QueryAccept(IPin *iface, const AM_MEDIA_TYPE *mt)
 402 {
 403     struct strmbase_pin *pin = impl_from_IPin(iface);
 404
 405     TRACE("pin %p %s:%s, mt %p.\n", pin, debugstr_w(pin->filter->name), debugstr_w(pin->name), mt);
 406     strmbase_dump_media_type(mt);
 407
 408     return query_accept(pin, mt) ? S_OK : S_FALSE;
 409 }
 410
 411 static HRESULT WINAPI pin_EnumMediaTypes(IPin *iface, IEnumMediaTypes **enum_media_types)
 412 {
 413     struct strmbase_pin *pin = impl_from_IPin(iface);
 414     AM_MEDIA_TYPE mt;
 415     HRESULT hr;
 416
 417     TRACE("pin %p %s:%s, enum_media_types %p.\n", pin, debugstr_w(pin->filter->name),
 418             debugstr_w(pin->name), enum_media_types);
 419
 420     if (pin->ops->pin_get_media_type)
 421     {
 422         if (FAILED(hr = pin->ops->pin_get_media_type(pin, 0, &mt)))
 423             return hr;
 424         if (hr == S_OK)
 425             FreeMediaType(&mt);
 426     }
 427
 428     return enum_media_types_create(pin, enum_media_types);
 429 }
 430
 431 static HRESULT WINAPI pin_QueryInternalConnections(IPin *iface, IPin **pins, ULONG *count)
 432 {
 433     struct strmbase_pin *pin = impl_from_IPin(iface);
 434
 435     TRACE("pin %p %s:%s, pins %p, count %p.\n", pin, debugstr_w(pin->filter->name),
 436             debugstr_w(pin->name), pins, count);
 437
 438     return E_NOTIMPL; /* to tell caller that all input pins connected to all output pins */
 439 }
 440
 441 /*** OutputPin implementation ***/
 442
 443 static inline struct strmbase_source *impl_source_from_IPin( IPin *iface )
 444 {
 445     return CONTAINING_RECORD(iface, struct strmbase_source, pin.IPin_iface);
 446 }
 447
 448 static BOOL compare_media_types(const AM_MEDIA_TYPE *req_mt, const AM_MEDIA_TYPE *pin_mt)
 449 {
 450     if (!req_mt)
 451         return TRUE;
 452
 453     if (!IsEqualGUID(&req_mt->majortype, &pin_mt->majortype)
 454             && !IsEqualGUID(&req_mt->majortype, &GUID_NULL))
 455         return FALSE;
 456
 457     if (!IsEqualGUID(&req_mt->subtype, &pin_mt->subtype)
 458             && !IsEqualGUID(&req_mt->subtype, &GUID_NULL))
 459         return FALSE;
 460
 461     if (!IsEqualGUID(&req_mt->formattype, &pin_mt->formattype)
 462             && !IsEqualGUID(&req_mt->formattype, &GUID_NULL))
 463         return FALSE;
 464
 465     return TRUE;
 466 }
 467
 468 static HRESULT WINAPI source_Connect(IPin *iface, IPin *peer, const AM_MEDIA_TYPE *mt)
 469 {
 470     struct strmbase_source *pin = impl_source_from_IPin(iface);
 471     AM_MEDIA_TYPE candidate, *candidate_ptr;
 472     IEnumMediaTypes *enummt;
 473     PIN_DIRECTION dir;
 474     unsigned int i;
 475     ULONG count;
 476     HRESULT hr;
 477
 478     TRACE("pin %p %s:%s, peer %p, mt %p.\n", pin, debugstr_w(pin->pin.filter->name),
 479             debugstr_w(pin->pin.name), peer, mt);
 480     strmbase_dump_media_type(mt);
 481
 482     if (!peer)
 483         return E_POINTER;
 484
 485     IPin_QueryDirection(peer, &dir);
 486     if (dir != PINDIR_INPUT)
 487     {
 488         WARN("Attempt to connect to another source pin, returning VFW_E_INVALID_DIRECTION.\n");
 489         return VFW_E_INVALID_DIRECTION;
 490     }
 491
 492     EnterCriticalSection(&pin->pin.filter->filter_cs);
 493
 494     if (pin->pin.peer)
 495     {
 496         LeaveCriticalSection(&pin->pin.filter->filter_cs);
 497         WARN("Pin is already connected, returning VFW_E_ALREADY_CONNECTED.\n");
 498         return VFW_E_ALREADY_CONNECTED;
 499     }
 500
 501     if (pin->pin.filter->state != State_Stopped)
 502     {
 503         LeaveCriticalSection(&pin->pin.filter->filter_cs);
 504         WARN("Filter is not stopped; returning VFW_E_NOT_STOPPED.\n");
 505         return VFW_E_NOT_STOPPED;
 506     }
 507
 508     /* We don't check the subtype here. The rationale (as given by the DirectX
 509      * documentation) is that the format type is supposed to provide at least
 510      * as much information as the subtype. */
 511     if (mt && !IsEqualGUID(&mt->majortype, &GUID_NULL)
 512             && !IsEqualGUID(&mt->formattype, &GUID_NULL))
 513     {
 514         hr = pin->pFuncsTable->pfnAttemptConnection(pin, peer, mt);
 515         LeaveCriticalSection(&pin->pin.filter->filter_cs);
 516         return hr;
 517     }
 518
 519     if (pin->pFuncsTable->base.pin_get_media_type)
 520     {
 521         for (i = 0; pin->pFuncsTable->base.pin_get_media_type(&pin->pin, i, &candidate) == S_OK; ++i)
 522         {
 523             strmbase_dump_media_type(&candidate);
 524             if (compare_media_types(mt, &candidate)
 525                     && pin->pFuncsTable->pfnAttemptConnection(pin, peer, &candidate) == S_OK)
 526             {
 527                 LeaveCriticalSection(&pin->pin.filter->filter_cs);
 528                 FreeMediaType(&candidate);
 529                 return S_OK;
 530             }
 531             FreeMediaType(&candidate);
 532         }
 533     }
 534
 535     if (SUCCEEDED(IPin_EnumMediaTypes(peer, &enummt)))
 536     {
 537         while (IEnumMediaTypes_Next(enummt, 1, &candidate_ptr, &count) == S_OK)
 538         {
 539             if (compare_media_types(mt, candidate_ptr)
 540                     && pin->pFuncsTable->pfnAttemptConnection(pin, peer, candidate_ptr) == S_OK)
 541             {
 542                 LeaveCriticalSection(&pin->pin.filter->filter_cs);
 543                 DeleteMediaType(candidate_ptr);
 544                 IEnumMediaTypes_Release(enummt);
 545                 return S_OK;
 546             }
 547             DeleteMediaType(candidate_ptr);
 548         }
 549
 550         IEnumMediaTypes_Release(enummt);
 551     }
 552
 553     LeaveCriticalSection(&pin->pin.filter->filter_cs);
 554
 555     return VFW_E_NO_ACCEPTABLE_TYPES;
 556 }
 557
 558 static HRESULT WINAPI source_ReceiveConnection(IPin *iface, IPin *peer, const AM_MEDIA_TYPE *mt)
 559 {
 560     struct strmbase_source *pin = impl_source_from_IPin(iface);
 561
 562     WARN("pin %p %s:%s, peer %p, mt %p, unexpected call.\n", pin,
 563             debugstr_w(pin->pin.filter->name), debugstr_w(pin->pin.name), peer, mt);
 564
 565     return E_UNEXPECTED;
 566 }
 567
 568 static HRESULT WINAPI source_Disconnect(IPin *iface)
 569 {
 570     HRESULT hr;
 571     struct strmbase_source *This = impl_source_from_IPin(iface);
 572
 573     TRACE("pin %p %s:%s.\n", This, debugstr_w(This->pin.filter->name), debugstr_w(This->pin.name));
 574
 575     EnterCriticalSection(&This->pin.filter->filter_cs);
 576     {
 577         if (This->pin.filter->state != State_Stopped)
 578         {
 579             LeaveCriticalSection(&This->pin.filter->filter_cs);
 580             WARN("Filter is not stopped; returning VFW_E_NOT_STOPPED.\n");
 581             return VFW_E_NOT_STOPPED;
 582         }
 583
 584         if (This->pFuncsTable->source_disconnect)
 585             This->pFuncsTable->source_disconnect(This);
 586
 587         if (This->pMemInputPin)
 588         {
 589             IMemInputPin_Release(This->pMemInputPin);
 590             This->pMemInputPin = NULL;
 591         }
 592
 593         if (This->pAllocator)
 594         {
 595             IMemAllocator_Release(This->pAllocator);
 596             This->pAllocator = NULL;
 597         }
 598
 599         if (This->pin.peer)
 600         {
 601             IPin_Release(This->pin.peer);
 602             This->pin.peer = NULL;
 603             FreeMediaType(&This->pin.mt);
 604             ZeroMemory(&This->pin.mt, sizeof(This->pin.mt));
 605             hr = S_OK;
 606         }
 607         else
 608             hr = S_FALSE;
 609     }
 610     LeaveCriticalSection(&This->pin.filter->filter_cs);
 611
 612     return hr;
 613 }
 614
 615 static HRESULT WINAPI source_EndOfStream(IPin *iface)
 616 {
 617     struct strmbase_source *pin = impl_source_from_IPin(iface);
 618
 619     WARN("pin %p %s:%s, unexpected call.\n", pin, debugstr_w(pin->pin.filter->name), debugstr_w(pin->pin.name));
 620
 621     /* not supposed to do anything in an output pin */
 622
 623     return E_UNEXPECTED;
 624 }
 625
 626 static HRESULT WINAPI source_BeginFlush(IPin *iface)
 627 {
 628     struct strmbase_source *pin = impl_source_from_IPin(iface);
 629
 630     WARN("pin %p %s:%s, unexpected call.\n", pin, debugstr_w(pin->pin.filter->name), debugstr_w(pin->pin.name));
 631
 632     /* not supposed to do anything in an output pin */
 633
 634     return E_UNEXPECTED;
 635 }
 636
 637 static HRESULT WINAPI source_EndFlush(IPin *iface)
 638 {
 639     struct strmbase_source *pin = impl_source_from_IPin(iface);
 640
 641     WARN("pin %p %s:%s, unexpected call.\n", pin, debugstr_w(pin->pin.filter->name), debugstr_w(pin->pin.name));
 642
 643     /* not supposed to do anything in an output pin */
 644
 645     return E_UNEXPECTED;
 646 }
 647
 648 static HRESULT WINAPI source_NewSegment(IPin * iface, REFERENCE_TIME start, REFERENCE_TIME stop, double rate)
 649 {
 650     struct strmbase_source *pin = impl_source_from_IPin(iface);
 651
 652     TRACE("pin %p %s:%s, start %s, stop %s, rate %.16e.\n", pin, debugstr_w(pin->pin.filter->name),
 653             debugstr_w(pin->pin.name), debugstr_time(start), debugstr_time(stop), rate);
 654
 655     return S_OK;
 656 }
 657
 658 static const IPinVtbl source_vtbl =
 659 {
 660     pin_QueryInterface,
 661     pin_AddRef,
 662     pin_Release,
 663     source_Connect,
 664     source_ReceiveConnection,
 665     source_Disconnect,
 666     pin_ConnectedTo,
 667     pin_ConnectionMediaType,
 668     pin_QueryPinInfo,
 669     pin_QueryDirection,
 670     pin_QueryId,
 671     pin_QueryAccept,
 672     pin_EnumMediaTypes,
 673     pin_QueryInternalConnections,
 674     source_EndOfStream,
 675     source_BeginFlush,
 676     source_EndFlush,
 677     source_NewSegment,
 678 };
 679
 680 HRESULT WINAPI BaseOutputPinImpl_GetDeliveryBuffer(struct strmbase_source *This,
 681         IMediaSample **ppSample, REFERENCE_TIME *tStart, REFERENCE_TIME *tStop, DWORD dwFlags)
 682 {
 683     HRESULT hr;
 684
 685     TRACE("(%p)->(%p, %p, %p, %x)\n", This, ppSample, tStart, tStop, dwFlags);
 686
 687     if (!This->pin.peer)
 688         hr = VFW_E_NOT_CONNECTED;
 689     else
 690     {
 691         hr = IMemAllocator_GetBuffer(This->pAllocator, ppSample, tStart, tStop, dwFlags);
 692
 693         if (SUCCEEDED(hr))
 694             hr = IMediaSample_SetTime(*ppSample, tStart, tStop);
 695     }
 696
 697     return hr;
 698 }
 699
 700 HRESULT WINAPI BaseOutputPinImpl_InitAllocator(struct strmbase_source *This, IMemAllocator **pMemAlloc)
 701 {
 702     return CoCreateInstance(&CLSID_MemoryAllocator, NULL, CLSCTX_INPROC_SERVER, &IID_IMemAllocator, (LPVOID*)pMemAlloc);
 703 }
 704
 705 HRESULT WINAPI BaseOutputPinImpl_DecideAllocator(struct strmbase_source *This,
 706         IMemInputPin *pPin, IMemAllocator **pAlloc)
 707 {
 708     HRESULT hr;
 709
 710     hr = IMemInputPin_GetAllocator(pPin, pAlloc);
 711
 712     if (hr == VFW_E_NO_ALLOCATOR)
 713         /* Input pin provides no allocator, use standard memory allocator */
 714         hr = BaseOutputPinImpl_InitAllocator(This, pAlloc);
 715
 716     if (SUCCEEDED(hr))
 717     {
 718         ALLOCATOR_PROPERTIES rProps;
 719         ZeroMemory(&rProps, sizeof(ALLOCATOR_PROPERTIES));
 720
 721         IMemInputPin_GetAllocatorRequirements(pPin, &rProps);
 722         hr = This->pFuncsTable->pfnDecideBufferSize(This, *pAlloc, &rProps);
 723     }
 724
 725     if (SUCCEEDED(hr))
 726         hr = IMemInputPin_NotifyAllocator(pPin, *pAlloc, FALSE);
 727
 728     return hr;
 729 }
 730
 731 /*** The Construct functions ***/
 732
 733 /* Function called as a helper to IPin_Connect */
 734 /* specific AM_MEDIA_TYPE - it cannot be NULL */
 735 HRESULT WINAPI BaseOutputPinImpl_AttemptConnection(struct strmbase_source *This,
 736         IPin *pReceivePin, const AM_MEDIA_TYPE *pmt)
 737 {
 738     HRESULT hr;
 739     IMemAllocator * pMemAlloc = NULL;
 740
 741     TRACE("(%p)->(%p, %p)\n", This, pReceivePin, pmt);
 742
 743     if (!query_accept(&This->pin, pmt))
 744         return VFW_E_TYPE_NOT_ACCEPTED;
 745
 746     This->pin.peer = pReceivePin;
 747     IPin_AddRef(pReceivePin);
 748     CopyMediaType(&This->pin.mt, pmt);
 749
 750     hr = IPin_ReceiveConnection(pReceivePin, &This->pin.IPin_iface, pmt);
 751
 752     /* get the IMemInputPin interface we will use to deliver samples to the
 753      * connected pin */
 754     if (SUCCEEDED(hr))
 755     {
 756         This->pMemInputPin = NULL;
 757         hr = IPin_QueryInterface(pReceivePin, &IID_IMemInputPin, (LPVOID)&This->pMemInputPin);
 758
 759         if (SUCCEEDED(hr))
 760         {
 761             hr = This->pFuncsTable->pfnDecideAllocator(This, This->pMemInputPin, &pMemAlloc);
 762             if (SUCCEEDED(hr))
 763                 This->pAllocator = pMemAlloc;
 764             else if (pMemAlloc)
 765                 IMemAllocator_Release(pMemAlloc);
 766         }
 767
 768         /* break connection if we couldn't get the allocator */
 769         if (FAILED(hr))
 770         {
 771             if (This->pMemInputPin)
 772                 IMemInputPin_Release(This->pMemInputPin);
 773             This->pMemInputPin = NULL;
 774
 775             IPin_Disconnect(pReceivePin);
 776         }
 777     }
 778
 779     if (FAILED(hr))
 780     {
 781         IPin_Release(This->pin.peer);
 782         This->pin.peer = NULL;
 783         FreeMediaType(&This->pin.mt);
 784     }
 785
 786     TRACE(" -- %x\n", hr);
 787     return hr;
 788 }
 789
 790 void strmbase_source_init(struct strmbase_source *pin, struct strmbase_filter *filter,
 791         const WCHAR *name, const struct strmbase_source_ops *func_table)
 792 {
 793     memset(pin, 0, sizeof(*pin));
 794     pin->pin.IPin_iface.lpVtbl = &source_vtbl;
 795     pin->pin.filter = filter;
 796     pin->pin.dir = PINDIR_OUTPUT;
 797     lstrcpyW(pin->pin.name, name);
 798     pin->pin.ops = &func_table->base;
 799     pin->pFuncsTable = func_table;
 800 }
 801
 802 void strmbase_source_cleanup(struct strmbase_source *pin)
 803 {
 804     FreeMediaType(&pin->pin.mt);
 805     if (pin->pAllocator)
 806         IMemAllocator_Release(pin->pAllocator);
 807     pin->pAllocator = NULL;
 808 }
 809
 810 static struct strmbase_sink *impl_sink_from_IPin(IPin *iface)
 811 {
 812     return CONTAINING_RECORD(iface, struct strmbase_sink, pin.IPin_iface);
 813 }
 814
 815 static HRESULT WINAPI sink_Connect(IPin *iface, IPin *peer, const AM_MEDIA_TYPE *mt)
 816 {
 817     struct strmbase_sink *pin = impl_sink_from_IPin(iface);
 818
 819     WARN("pin %p %s:%s, peer %p, mt %p, unexpected call.\n", pin, debugstr_w(pin->pin.name),
 820             debugstr_w(pin->pin.filter->name), peer, mt);
 821
 822     return E_UNEXPECTED;
 823 }
 824
 825
 826 static HRESULT WINAPI sink_ReceiveConnection(IPin *iface, IPin *pReceivePin, const AM_MEDIA_TYPE *pmt)
 827 {
 828     struct strmbase_sink *This = impl_sink_from_IPin(iface);
 829     PIN_DIRECTION pindirReceive;
 830     HRESULT hr = S_OK;
 831
 832     TRACE("pin %p %s:%s, peer %p, mt %p.\n", This, debugstr_w(This->pin.filter->name),
 833             debugstr_w(This->pin.name), pReceivePin, pmt);
 834     strmbase_dump_media_type(pmt);
 835
 836     if (!pmt)
 837         return E_POINTER;
 838
 839     EnterCriticalSection(&This->pin.filter->filter_cs);
 840     {
 841         if (This->pin.filter->state != State_Stopped)
 842         {
 843             LeaveCriticalSection(&This->pin.filter->filter_cs);
 844             WARN("Filter is not stopped; returning VFW_E_NOT_STOPPED.\n");
 845             return VFW_E_NOT_STOPPED;
 846         }
 847
 848         if (This->pin.peer)
 849             hr = VFW_E_ALREADY_CONNECTED;
 850
 851         if (SUCCEEDED(hr) && !query_accept(&This->pin, pmt))
 852             hr = VFW_E_TYPE_NOT_ACCEPTED; /* FIXME: shouldn't we just map common errors onto
 853                                            * VFW_E_TYPE_NOT_ACCEPTED and pass the value on otherwise? */
 854
 855         if (SUCCEEDED(hr))
 856         {
 857             IPin_QueryDirection(pReceivePin, &pindirReceive);
 858
 859             if (pindirReceive != PINDIR_OUTPUT)
 860             {
 861                 ERR("Can't connect from non-output pin\n");
 862                 hr = VFW_E_INVALID_DIRECTION;
 863             }
 864         }
 865
 866         if (SUCCEEDED(hr) && This->pFuncsTable->sink_connect)
 867             hr = This->pFuncsTable->sink_connect(This, pReceivePin, pmt);
 868
 869         if (SUCCEEDED(hr))
 870         {
 871             CopyMediaType(&This->pin.mt, pmt);
 872             This->pin.peer = pReceivePin;
 873             IPin_AddRef(pReceivePin);
 874         }
 875     }
 876     LeaveCriticalSection(&This->pin.filter->filter_cs);
 877
 878     return hr;
 879 }
 880
 881 static HRESULT WINAPI sink_Disconnect(IPin *iface)
 882 {
 883     struct strmbase_sink *pin = impl_sink_from_IPin(iface);
 884     HRESULT hr;
 885
 886     TRACE("pin %p %s:%s.\n", pin, debugstr_w(pin->pin.filter->name), debugstr_w(pin->pin.name));
 887
 888     EnterCriticalSection(&pin->pin.filter->filter_cs);
 889
 890     if (pin->pin.filter->state != State_Stopped)
 891     {
 892         LeaveCriticalSection(&pin->pin.filter->filter_cs);
 893         WARN("Filter is not stopped; returning VFW_E_NOT_STOPPED.\n");
 894         return VFW_E_NOT_STOPPED;
 895     }
 896
 897     if (pin->pin.peer)
 898     {
 899         if (pin->pFuncsTable->sink_disconnect)
 900             pin->pFuncsTable->sink_disconnect(pin);
 901
 902         if (pin->pAllocator)
 903         {
 904             IMemAllocator_Release(pin->pAllocator);
 905             pin->pAllocator = NULL;
 906         }
 907
 908         IPin_Release(pin->pin.peer);
 909         pin->pin.peer = NULL;
 910         FreeMediaType(&pin->pin.mt);
 911         memset(&pin->pin.mt, 0, sizeof(AM_MEDIA_TYPE));
 912         hr = S_OK;
 913     }
 914     else
 915         hr = S_FALSE;
 916
 917     LeaveCriticalSection(&pin->pin.filter->filter_cs);
 918
 919     return hr;
 920 }
 921
 922 static HRESULT deliver_endofstream(IPin* pin, LPVOID unused)
 923 {
 924     return IPin_EndOfStream( pin );
 925 }
 926
 927 static HRESULT WINAPI sink_EndOfStream(IPin *iface)
 928 {
 929     struct strmbase_sink *pin = impl_sink_from_IPin(iface);
 930     HRESULT hr = S_OK;
 931
 932     TRACE("pin %p %s:%s.\n", pin, debugstr_w(pin->pin.filter->name), debugstr_w(pin->pin.name));
 933
 934     if (pin->pFuncsTable->sink_eos)
 935     {
 936         EnterCriticalSection(&pin->pin.filter->stream_cs);
 937         hr = pin->pFuncsTable->sink_eos(pin);
 938         LeaveCriticalSection(&pin->pin.filter->stream_cs);
 939         return hr;
 940     }
 941
 942     EnterCriticalSection(&pin->pin.filter->filter_cs);
 943     if (pin->flushing)
 944         hr = S_FALSE;
 945     LeaveCriticalSection(&pin->pin.filter->filter_cs);
 946
 947     if (hr == S_OK)
 948         hr = SendFurther(pin, deliver_endofstream, NULL);
 949     return hr;
 950 }
 951
 952 static HRESULT deliver_beginflush(IPin* pin, LPVOID unused)
 953 {
 954     return IPin_BeginFlush( pin );
 955 }
 956
 957 static HRESULT WINAPI sink_BeginFlush(IPin *iface)
 958 {
 959     struct strmbase_sink *pin = impl_sink_from_IPin(iface);
 960     HRESULT hr;
 961
 962     TRACE("pin %p %s:%s.\n", pin, debugstr_w(pin->pin.filter->name), debugstr_w(pin->pin.name));
 963
 964     EnterCriticalSection(&pin->pin.filter->filter_cs);
 965
 966     pin->flushing = TRUE;
 967
 968     if (pin->pFuncsTable->sink_begin_flush)
 969         hr = pin->pFuncsTable->sink_begin_flush(pin);
 970     else
 971         hr = SendFurther(pin, deliver_beginflush, NULL);
 972
 973     LeaveCriticalSection(&pin->pin.filter->filter_cs);
 974
 975     return hr;
 976 }
 977
 978 static HRESULT deliver_endflush(IPin* pin, LPVOID unused)
 979 {
 980     return IPin_EndFlush( pin );
 981 }
 982
 983 static HRESULT WINAPI sink_EndFlush(IPin * iface)
 984 {
 985     struct strmbase_sink *pin = impl_sink_from_IPin(iface);
 986     HRESULT hr;
 987
 988     TRACE("pin %p %s:%s.\n", pin, debugstr_w(pin->pin.filter->name), debugstr_w(pin->pin.name));
 989
 990     EnterCriticalSection(&pin->pin.filter->filter_cs);
 991
 992     pin->flushing = FALSE;
 993
 994     if (pin->pFuncsTable->sink_end_flush)
 995         hr = pin->pFuncsTable->sink_end_flush(pin);
 996     else
 997         hr = SendFurther(pin, deliver_endflush, NULL);
 998
 999     LeaveCriticalSection(&pin->pin.filter->filter_cs);
1000
1001     return hr;
1002 }
1003
1004 typedef struct newsegmentargs
1005 {
1006     REFERENCE_TIME tStart, tStop;
1007     double rate;
1008 } newsegmentargs;
1009
1010 static HRESULT deliver_newsegment(IPin *pin, LPVOID data)
1011 {
1012     newsegmentargs *args = data;
1013     return IPin_NewSegment(pin, args->tStart, args->tStop, args->rate);
1014 }
1015
1016 static HRESULT WINAPI sink_NewSegment(IPin *iface, REFERENCE_TIME start, REFERENCE_TIME stop, double rate)
1017 {
1018     struct strmbase_sink *pin = impl_sink_from_IPin(iface);
1019     newsegmentargs args;
1020
1021     TRACE("pin %p %s:%s, start %s, stop %s, rate %.16e.\n", pin, debugstr_w(pin->pin.filter->name),
1022             debugstr_w(pin->pin.name), debugstr_time(start), debugstr_time(stop), rate);
1023
1024     if (pin->pFuncsTable->sink_new_segment)
1025         return pin->pFuncsTable->sink_new_segment(pin, start, stop, rate);
1026
1027     args.tStart = start;
1028     args.tStop = stop;
1029     args.rate = rate;
1030
1031     return SendFurther(pin, deliver_newsegment, &args);
1032 }
1033
1034 static const IPinVtbl sink_vtbl =
1035 {
1036     pin_QueryInterface,
1037     pin_AddRef,
1038     pin_Release,
1039     sink_Connect,
1040     sink_ReceiveConnection,
1041     sink_Disconnect,
1042     pin_ConnectedTo,
1043     pin_ConnectionMediaType,
1044     pin_QueryPinInfo,
1045     pin_QueryDirection,
1046     pin_QueryId,
1047     pin_QueryAccept,
1048     pin_EnumMediaTypes,
1049     pin_QueryInternalConnections,
1050     sink_EndOfStream,
1051     sink_BeginFlush,
1052     sink_EndFlush,
1053     sink_NewSegment,
1054 };
1055
1056 /*** IMemInputPin implementation ***/
1057
1058 static inline struct strmbase_sink *impl_from_IMemInputPin(IMemInputPin *iface)
1059 {
1060     return CONTAINING_RECORD(iface, struct strmbase_sink, IMemInputPin_iface);
1061 }
1062
1063 static HRESULT WINAPI MemInputPin_QueryInterface(IMemInputPin * iface, REFIID riid, LPVOID * ppv)
1064 {
1065     struct strmbase_sink *This = impl_from_IMemInputPin(iface);
1066
1067     return IPin_QueryInterface(&This->pin.IPin_iface, riid, ppv);
1068 }
1069
1070 static ULONG WINAPI MemInputPin_AddRef(IMemInputPin * iface)
1071 {
1072     struct strmbase_sink *This = impl_from_IMemInputPin(iface);
1073
1074     return IPin_AddRef(&This->pin.IPin_iface);
1075 }
1076
1077 static ULONG WINAPI MemInputPin_Release(IMemInputPin * iface)
1078 {
1079     struct strmbase_sink *This = impl_from_IMemInputPin(iface);
1080
1081     return IPin_Release(&This->pin.IPin_iface);
1082 }
1083
1084 static HRESULT WINAPI MemInputPin_GetAllocator(IMemInputPin * iface, IMemAllocator ** ppAllocator)
1085 {
1086     struct strmbase_sink *This = impl_from_IMemInputPin(iface);
1087
1088     TRACE("pin %p %s:%s, allocator %p.\n", This, debugstr_w(This->pin.filter->name),
1089             debugstr_w(This->pin.name), ppAllocator);
1090
1091     *ppAllocator = This->pAllocator;
1092     if (*ppAllocator)
1093         IMemAllocator_AddRef(*ppAllocator);
1094
1095     return *ppAllocator ? S_OK : VFW_E_NO_ALLOCATOR;
1096 }
1097
1098 static HRESULT WINAPI MemInputPin_NotifyAllocator(IMemInputPin * iface, IMemAllocator * pAllocator, BOOL bReadOnly)
1099 {
1100     struct strmbase_sink *This = impl_from_IMemInputPin(iface);
1101
1102     TRACE("pin %p %s:%s, allocator %p, read_only %d.\n", This, debugstr_w(This->pin.filter->name),
1103             debugstr_w(This->pin.name), pAllocator, bReadOnly);
1104
1105     if (bReadOnly)
1106         FIXME("Read only flag not handled yet!\n");
1107
1108     /* FIXME: Should we release the allocator on disconnection? */
1109     if (!pAllocator)
1110     {
1111         WARN("Null allocator\n");
1112         return E_POINTER;
1113     }
1114
1115     if (This->preferred_allocator && pAllocator != This->preferred_allocator)
1116         return E_FAIL;
1117
1118     if (This->pAllocator)
1119         IMemAllocator_Release(This->pAllocator);
1120     This->pAllocator = pAllocator;
1121     if (This->pAllocator)
1122         IMemAllocator_AddRef(This->pAllocator);
1123
1124     return S_OK;
1125 }
1126
1127 static HRESULT WINAPI MemInputPin_GetAllocatorRequirements(IMemInputPin *iface, ALLOCATOR_PROPERTIES *props)
1128 {
1129     struct strmbase_sink *pin = impl_from_IMemInputPin(iface);
1130
1131     TRACE("pin %p %s:%s, props %p.\n", pin, debugstr_w(pin->pin.filter->name),
1132             debugstr_w(pin->pin.name), props);
1133
1134     /* override this method if you have any specific requirements */
1135
1136     return E_NOTIMPL;
1137 }
1138
1139 static HRESULT WINAPI MemInputPin_Receive(IMemInputPin *iface, IMediaSample *sample)
1140 {
1141     struct strmbase_sink *pin = impl_from_IMemInputPin(iface);
1142     HRESULT hr = S_FALSE;
1143
1144     TRACE("pin %p %s:%s, sample %p.\n", pin, debugstr_w(pin->pin.filter->name),
1145             debugstr_w(pin->pin.name), sample);
1146
1147     if (pin->pFuncsTable->pfnReceive)
1148     {
1149         EnterCriticalSection(&pin->pin.filter->stream_cs);
1150         hr = pin->pFuncsTable->pfnReceive(pin, sample);
1151         LeaveCriticalSection(&pin->pin.filter->stream_cs);
1152     }
1153     return hr;
1154 }
1155
1156 static HRESULT WINAPI MemInputPin_ReceiveMultiple(IMemInputPin * iface, IMediaSample ** pSamples, LONG nSamples, LONG *nSamplesProcessed)
1157 {
1158     HRESULT hr = S_OK;
1159
1160     for (*nSamplesProcessed = 0; *nSamplesProcessed < nSamples; (*nSamplesProcessed)++)
1161     {
1162         hr = IMemInputPin_Receive(iface, pSamples[*nSamplesProcessed]);
1163         if (hr != S_OK)
1164             break;
1165     }
1166
1167     return hr;
1168 }
1169
1170 static HRESULT WINAPI MemInputPin_ReceiveCanBlock(IMemInputPin * iface)
1171 {
1172     struct strmbase_sink *pin = impl_from_IMemInputPin(iface);
1173
1174     TRACE("pin %p %s:%s.\n", pin, debugstr_w(pin->pin.filter->name), debugstr_w(pin->pin.name));
1175
1176     return S_OK;
1177 }
1178
1179 static const IMemInputPinVtbl MemInputPin_Vtbl =
1180 {
1181     MemInputPin_QueryInterface,
1182     MemInputPin_AddRef,
1183     MemInputPin_Release,
1184     MemInputPin_GetAllocator,
1185     MemInputPin_NotifyAllocator,
1186     MemInputPin_GetAllocatorRequirements,
1187     MemInputPin_Receive,
1188     MemInputPin_ReceiveMultiple,
1189     MemInputPin_ReceiveCanBlock
1190 };
1191
1192 void strmbase_sink_init(struct strmbase_sink *pin, struct strmbase_filter *filter,
1193         const WCHAR *name, const struct strmbase_sink_ops *func_table, IMemAllocator *allocator)
1194 {
1195     memset(pin, 0, sizeof(*pin));
1196     pin->pin.IPin_iface.lpVtbl = &sink_vtbl;
1197     pin->pin.filter = filter;
1198     pin->pin.dir = PINDIR_INPUT;
1199     lstrcpyW(pin->pin.name, name);
1200     pin->pin.ops = &func_table->base;
1201     pin->pFuncsTable = func_table;
1202     pin->pAllocator = pin->preferred_allocator = allocator;
1203     if (pin->preferred_allocator)
1204         IMemAllocator_AddRef(pin->preferred_allocator);
1205     pin->IMemInputPin_iface.lpVtbl = &MemInputPin_Vtbl;
1206 }
1207
1208 void strmbase_sink_cleanup(struct strmbase_sink *pin)
1209 {
1210     FreeMediaType(&pin->pin.mt);
1211     if (pin->pAllocator)
1212         IMemAllocator_Release(pin->pAllocator);
1213     pin->pAllocator = NULL;
1214     pin->pin.IPin_iface.lpVtbl = NULL;
1215 }