wined3d: Explicitly pass the draw rect to device_clear_render_targets().
[wine] / 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 }