git.oblomov.eu Git - wine/blob - dlls/qcap/pin.c

   1 /*
   2  * Generic Implementation of IPin Interface
   3  *
   4  * Copyright 2003 Robert Shearman
   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 <stdarg.h>
  22
  23 #define COBJMACROS
  24
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "wtypes.h"
  28 #include "wingdi.h"
  29 #include "winuser.h"
  30 #include "dshow.h"
  31
  32 #include "qcap_main.h"
  33 #include "pin.h"
  34
  35 #include "wine/debug.h"
  36 #include "wine/unicode.h"
  37 #include "uuids.h"
  38 #include "vfwmsgs.h"
  39 #include <assert.h>
  40
  41 WINE_DEFAULT_DEBUG_CHANNEL(qcap);
  42
  43 #define ALIGNDOWN(value,boundary) ((value) & ~(boundary-1))
  44 #define ALIGNUP(value,boundary) (ALIGNDOWN(value - 1, boundary) + boundary)
  45
  46 static void Copy_PinInfo(PIN_INFO * pDest, const PIN_INFO * pSrc)
  47 {
  48     /* Tempting to just do a memcpy, but the name field is
  49        128 characters long! We will probably never exceed 10
  50        most of the time, so we are better off copying
  51        each field manually */
  52     strcpyW(pDest->achName, pSrc->achName);
  53     pDest->dir = pSrc->dir;
  54     pDest->pFilter = pSrc->pFilter;
  55 }
  56
  57 HRESULT WINAPI IPinImpl_ConnectedTo(IPin * iface, IPin ** ppPin)
  58 {
  59     HRESULT hr;
  60     IPinImpl *This = (IPinImpl *)iface;
  61
  62 /*  TRACE("(%p)\n", ppPin);*/
  63
  64     EnterCriticalSection(This->pCritSec);
  65     {
  66         if (This->pConnectedTo)
  67         {
  68             *ppPin = This->pConnectedTo;
  69             IPin_AddRef(*ppPin);
  70             hr = S_OK;
  71         }
  72         else
  73             hr = VFW_E_NOT_CONNECTED;
  74     }
  75     LeaveCriticalSection(This->pCritSec);
  76
  77     return hr;
  78 }
  79
  80 HRESULT WINAPI IPinImpl_ConnectionMediaType(IPin * iface, AM_MEDIA_TYPE * pmt)
  81 {
  82     HRESULT hr;
  83     IPinImpl *This = (IPinImpl *)iface;
  84
  85     TRACE("(%p/%p)->(%p)\n", This, iface, pmt);
  86
  87     EnterCriticalSection(This->pCritSec);
  88     {
  89         if (This->pConnectedTo)
  90         {
  91             CopyMediaType(pmt, &This->mtCurrent);
  92             hr = S_OK;
  93         }
  94         else
  95         {
  96             ZeroMemory(pmt, sizeof(*pmt));
  97             hr = VFW_E_NOT_CONNECTED;
  98         }
  99     }
 100     LeaveCriticalSection(This->pCritSec);
 101
 102     return hr;
 103 }
 104
 105 HRESULT WINAPI IPinImpl_QueryPinInfo(IPin * iface, PIN_INFO * pInfo)
 106 {
 107     IPinImpl *This = (IPinImpl *)iface;
 108
 109     TRACE("(%p/%p)->(%p)\n", This, iface, pInfo);
 110
 111     Copy_PinInfo(pInfo, &This->pinInfo);
 112     IBaseFilter_AddRef(pInfo->pFilter);
 113
 114     return S_OK;
 115 }
 116
 117 HRESULT WINAPI IPinImpl_QueryDirection(IPin * iface, PIN_DIRECTION * pPinDir)
 118 {
 119     IPinImpl *This = (IPinImpl *)iface;
 120
 121     TRACE("(%p/%p)->(%p)\n", This, iface, pPinDir);
 122
 123     *pPinDir = This->pinInfo.dir;
 124
 125     return S_OK;
 126 }
 127
 128 HRESULT WINAPI IPinImpl_QueryId(IPin * iface, LPWSTR * Id)
 129 {
 130     IPinImpl *This = (IPinImpl *)iface;
 131
 132     TRACE("(%p/%p)->(%p)\n", This, iface, Id);
 133
 134     *Id = CoTaskMemAlloc((strlenW(This->pinInfo.achName) + 1) * sizeof(WCHAR));
 135     if (!*Id)
 136         return E_OUTOFMEMORY;
 137
 138     strcpyW(*Id, This->pinInfo.achName);
 139
 140     return S_OK;
 141 }
 142
 143 HRESULT WINAPI IPinImpl_QueryAccept(IPin * iface, const AM_MEDIA_TYPE * pmt)
 144 {
 145     IPinImpl *This = (IPinImpl *)iface;
 146
 147     TRACE("(%p/%p)->(%p)\n", This, iface, pmt);
 148
 149     if (!This->fnQueryAccept) return S_OK;
 150
 151     return (This->fnQueryAccept(This->pUserData, pmt) == S_OK ? S_OK : S_FALSE);
 152 }
 153
 154 /* Function called as a helper to IPin_Connect */
 155 /* specific AM_MEDIA_TYPE - it cannot be NULL */
 156 /* NOTE: not part of standard interface */
 157 static HRESULT OutputPin_ConnectSpecific(IPin * iface, IPin * pReceivePin, const AM_MEDIA_TYPE * pmt)
 158 {
 159     OutputPin *This = (OutputPin *)iface;
 160     HRESULT hr;
 161     IMemAllocator * pMemAlloc = NULL;
 162     ALLOCATOR_PROPERTIES actual; /* FIXME: should we put the actual props back in to This? */
 163
 164     TRACE("(%p, %p)\n", pReceivePin, pmt);
 165     dump_AM_MEDIA_TYPE(pmt);
 166
 167     /* FIXME: call queryacceptproc */
 168
 169     This->pin.pConnectedTo = pReceivePin;
 170     IPin_AddRef(pReceivePin);
 171     CopyMediaType(&This->pin.mtCurrent, pmt);
 172
 173     hr = IPin_ReceiveConnection(pReceivePin, iface, pmt);
 174
 175     /* get the IMemInputPin interface we will use to deliver samples to the
 176      * connected pin */
 177     if (SUCCEEDED(hr))
 178     {
 179         hr = IPin_QueryInterface(pReceivePin, &IID_IMemInputPin, (LPVOID)&This->pMemInputPin);
 180
 181         if (SUCCEEDED(hr))
 182             hr = IMemInputPin_GetAllocator(This->pMemInputPin, &pMemAlloc);
 183
 184         if (hr == VFW_E_NO_ALLOCATOR)
 185         {
 186             /* Input pin provides no allocator, use standard memory allocator */
 187             hr = CoCreateInstance(&CLSID_MemoryAllocator, NULL, CLSCTX_INPROC_SERVER, &IID_IMemAllocator, (LPVOID*)&pMemAlloc);
 188
 189             if (SUCCEEDED(hr))
 190             {
 191                 hr = IMemInputPin_NotifyAllocator(This->pMemInputPin, pMemAlloc, FALSE);
 192             }
 193         }
 194
 195         if (SUCCEEDED(hr))
 196             hr = IMemAllocator_SetProperties(pMemAlloc, &This->allocProps, &actual);
 197
 198         if (pMemAlloc)
 199             IMemAllocator_Release(pMemAlloc);
 200
 201         /* break connection if we couldn't get the allocator */
 202         if (FAILED(hr))
 203             IPin_Disconnect(pReceivePin);
 204     }
 205
 206     if (FAILED(hr))
 207     {
 208         IPin_Release(This->pin.pConnectedTo);
 209         This->pin.pConnectedTo = NULL;
 210         DeleteMediaType(&This->pin.mtCurrent);
 211     }
 212
 213     TRACE(" -- %x\n", hr);
 214     return hr;
 215 }
 216
 217 HRESULT OutputPin_Init(const PIN_INFO * pPinInfo, const ALLOCATOR_PROPERTIES * props,
 218                        LPVOID pUserData, QUERYACCEPTPROC pQueryAccept,
 219                        LPCRITICAL_SECTION pCritSec, OutputPin * pPinImpl)
 220 {
 221     TRACE("\n");
 222
 223     /* Common attributes */
 224     pPinImpl->pin.refCount = 1;
 225     pPinImpl->pin.pConnectedTo = NULL;
 226     pPinImpl->pin.fnQueryAccept = pQueryAccept;
 227     pPinImpl->pin.pUserData = pUserData;
 228     pPinImpl->pin.pCritSec = pCritSec;
 229     Copy_PinInfo(&pPinImpl->pin.pinInfo, pPinInfo);
 230
 231     /* Output pin attributes */
 232     pPinImpl->pMemInputPin = NULL;
 233     pPinImpl->pConnectSpecific = OutputPin_ConnectSpecific;
 234     if (props)
 235     {
 236         pPinImpl->allocProps = *props;
 237         if (pPinImpl->allocProps.cbAlign == 0)
 238             pPinImpl->allocProps.cbAlign = 1;
 239     }
 240     else
 241         ZeroMemory(&pPinImpl->allocProps, sizeof(pPinImpl->allocProps));
 242
 243     return S_OK;
 244 }
 245
 246 HRESULT WINAPI OutputPin_Connect(IPin * iface, IPin * pReceivePin, const AM_MEDIA_TYPE * pmt)
 247 {
 248     HRESULT hr;
 249     OutputPin *This = (OutputPin *)iface;
 250
 251     TRACE("(%p/%p)->(%p, %p)\n", This, iface, pReceivePin, pmt);
 252     dump_AM_MEDIA_TYPE(pmt);
 253
 254     /* If we try to connect to ourself, we will definitely deadlock.
 255      * There are other cases where we could deadlock too, but this
 256      * catches the obvious case */
 257     assert(pReceivePin != iface);
 258
 259     EnterCriticalSection(This->pin.pCritSec);
 260     {
 261         /* if we have been a specific type to connect with, then we can either connect
 262          * with that or fail. We cannot choose different AM_MEDIA_TYPE */
 263         if (pmt && !IsEqualGUID(&pmt->majortype, &GUID_NULL) && !IsEqualGUID(&pmt->subtype, &GUID_NULL))
 264             hr = This->pConnectSpecific(iface, pReceivePin, pmt);
 265         else
 266         {
 267             /* negotiate media type */
 268
 269             IEnumMediaTypes * pEnumCandidates;
 270             AM_MEDIA_TYPE * pmtCandidate; /* Candidate media type */
 271
 272             if (SUCCEEDED(hr = IPin_EnumMediaTypes(iface, &pEnumCandidates)))
 273             {
 274                 hr = VFW_E_NO_ACCEPTABLE_TYPES; /* Assume the worst, but set to S_OK if connected successfully */
 275
 276                 /* try this filter's media types first */
 277                 while (S_OK == IEnumMediaTypes_Next(pEnumCandidates, 1, &pmtCandidate, NULL))
 278                 {
 279                     if (( !pmt || CompareMediaTypes(pmt, pmtCandidate, TRUE) ) &&
 280                         (This->pConnectSpecific(iface, pReceivePin, pmtCandidate) == S_OK))
 281                     {
 282                         hr = S_OK;
 283                         TRACE("o_o\n");
 284                         DeleteMediaType(pmtCandidate);
 285                         break;
 286                     }
 287                     DeleteMediaType(pmtCandidate);
 288                 }
 289                 IEnumMediaTypes_Release(pEnumCandidates);
 290             }
 291
 292             /* then try receiver filter's media types */
 293             if (hr != S_OK && SUCCEEDED(hr = IPin_EnumMediaTypes(pReceivePin, &pEnumCandidates))) /* if we haven't already connected successfully */
 294             {
 295                 hr = VFW_E_NO_ACCEPTABLE_TYPES; /* Assume the worst, but set to S_OK if connected successfully */
 296
 297                 while (S_OK == IEnumMediaTypes_Next(pEnumCandidates, 1, &pmtCandidate, NULL))
 298                 {
 299                     if (( !pmt || CompareMediaTypes(pmt, pmtCandidate, TRUE) ) &&
 300                         (This->pConnectSpecific(iface, pReceivePin, pmtCandidate) == S_OK))
 301                     {
 302                         hr = S_OK;
 303                         DeleteMediaType(pmtCandidate);
 304                         break;
 305                     }
 306                     DeleteMediaType(pmtCandidate);
 307                 } /* while */
 308                 IEnumMediaTypes_Release(pEnumCandidates);
 309             } /* if not found */
 310         } /* if negotiate media type */
 311     } /* if succeeded */
 312     LeaveCriticalSection(This->pin.pCritSec);
 313
 314     TRACE(" -- %x\n", hr);
 315     return hr;
 316 }
 317
 318 HRESULT WINAPI OutputPin_ReceiveConnection(IPin * iface, IPin * pReceivePin, const AM_MEDIA_TYPE * pmt)
 319 {
 320     ERR("Incoming connection on an output pin! (%p, %p)\n", pReceivePin, pmt);
 321
 322     return E_UNEXPECTED;
 323 }
 324
 325 HRESULT WINAPI OutputPin_Disconnect(IPin * iface)
 326 {
 327     HRESULT hr;
 328     OutputPin *This = (OutputPin *)iface;
 329
 330     TRACE("()\n");
 331
 332     EnterCriticalSection(This->pin.pCritSec);
 333     {
 334         if (This->pMemInputPin)
 335         {
 336             IMemInputPin_Release(This->pMemInputPin);
 337             This->pMemInputPin = NULL;
 338         }
 339         if (This->pin.pConnectedTo)
 340         {
 341             IPin_Release(This->pin.pConnectedTo);
 342             This->pin.pConnectedTo = NULL;
 343             hr = S_OK;
 344         }
 345         else
 346             hr = S_FALSE;
 347     }
 348     LeaveCriticalSection(This->pin.pCritSec);
 349
 350     return hr;
 351 }
 352
 353 HRESULT OutputPin_GetDeliveryBuffer(OutputPin * This, IMediaSample ** ppSample, REFERENCE_TIME * tStart, REFERENCE_TIME * tStop, DWORD dwFlags)
 354 {
 355     HRESULT hr;
 356
 357     TRACE("(%p, %p, %p, %x)\n", ppSample, tStart, tStop, dwFlags);
 358
 359     EnterCriticalSection(This->pin.pCritSec);
 360     {
 361         if (!This->pin.pConnectedTo)
 362             hr = VFW_E_NOT_CONNECTED;
 363         else
 364         {
 365             IMemAllocator * pAlloc = NULL;
 366
 367             hr = IMemInputPin_GetAllocator(This->pMemInputPin, &pAlloc);
 368
 369             if (SUCCEEDED(hr))
 370                 hr = IMemAllocator_GetBuffer(pAlloc, ppSample, tStart, tStop, dwFlags);
 371
 372             if (SUCCEEDED(hr))
 373                 hr = IMediaSample_SetTime(*ppSample, tStart, tStop);
 374
 375             if (pAlloc)
 376                 IMemAllocator_Release(pAlloc);
 377         }
 378     }
 379     LeaveCriticalSection(This->pin.pCritSec);
 380
 381     return hr;
 382 }
 383
 384 HRESULT OutputPin_SendSample(OutputPin * This, IMediaSample * pSample)
 385 {
 386     HRESULT hr = S_OK;
 387     IMemInputPin * pMemConnected = NULL;
 388
 389     EnterCriticalSection(This->pin.pCritSec);
 390     {
 391         if (!This->pin.pConnectedTo || !This->pMemInputPin)
 392             hr = VFW_E_NOT_CONNECTED;
 393         else
 394         {
 395             /* we don't have the lock held when using This->pMemInputPin,
 396              * so we need to AddRef it to stop it being deleted while we are
 397              * using it. */
 398             pMemConnected = This->pMemInputPin;
 399             IMemInputPin_AddRef(pMemConnected);
 400         }
 401     }
 402     LeaveCriticalSection(This->pin.pCritSec);
 403
 404     if (SUCCEEDED(hr))
 405     {
 406         /* NOTE: if we are in a critical section when Receive is called
 407          * then it causes some problems (most notably with the native Video
 408          * Renderer) if we are re-entered for whatever reason */
 409         hr = IMemInputPin_Receive(pMemConnected, pSample);
 410         IMemInputPin_Release(pMemConnected);
 411     }
 412
 413     return hr;
 414 }