riched20: Add newlines to ERR macro output.
[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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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 HRESULT WINAPI IPinImpl_QueryInternalConnections(IPin * iface, IPin ** apPin, ULONG * cPin)
155 {
156     IPinImpl *This = (IPinImpl *)iface;
157
158     TRACE("(%p/%p)->(%p, %p)\n", This, iface, apPin, cPin);
159
160     return E_NOTIMPL; /* to tell caller that all input pins connected to all output pins */
161 }
162
163 /* Function called as a helper to IPin_Connect */
164 /* specific AM_MEDIA_TYPE - it cannot be NULL */
165 /* NOTE: not part of standard interface */
166 static HRESULT OutputPin_ConnectSpecific(IPin * iface, IPin * pReceivePin, const AM_MEDIA_TYPE * pmt)
167 {
168     OutputPin *This = (OutputPin *)iface;
169     HRESULT hr;
170     IMemAllocator * pMemAlloc = NULL;
171     ALLOCATOR_PROPERTIES actual; /* FIXME: should we put the actual props back in to This? */
172
173     TRACE("(%p, %p)\n", pReceivePin, pmt);
174     dump_AM_MEDIA_TYPE(pmt);
175
176     /* FIXME: call queryacceptproc */
177     
178     This->pin.pConnectedTo = pReceivePin;
179     IPin_AddRef(pReceivePin);
180     CopyMediaType(&This->pin.mtCurrent, pmt);
181
182     hr = IPin_ReceiveConnection(pReceivePin, iface, pmt);
183
184     /* get the IMemInputPin interface we will use to deliver samples to the
185      * connected pin */
186     if (SUCCEEDED(hr))
187     {
188         hr = IPin_QueryInterface(pReceivePin, &IID_IMemInputPin, (LPVOID)&This->pMemInputPin);
189
190         if (SUCCEEDED(hr))
191             hr = IMemInputPin_GetAllocator(This->pMemInputPin, &pMemAlloc);
192
193         if (hr == VFW_E_NO_ALLOCATOR)
194         {
195             /* Input pin provides no allocator, use standard memory allocator */
196             hr = CoCreateInstance(&CLSID_MemoryAllocator, NULL, CLSCTX_INPROC_SERVER, &IID_IMemAllocator, (LPVOID*)&pMemAlloc);
197
198             if (SUCCEEDED(hr))
199             {
200                 hr = IMemInputPin_NotifyAllocator(This->pMemInputPin, pMemAlloc, FALSE);
201             }
202         }
203
204         if (SUCCEEDED(hr))
205             hr = IMemAllocator_SetProperties(pMemAlloc, &This->allocProps, &actual);
206
207         if (pMemAlloc)
208             IMemAllocator_Release(pMemAlloc);
209
210         /* break connection if we couldn't get the allocator */
211         if (FAILED(hr))
212             IPin_Disconnect(pReceivePin);
213     }
214
215     if (FAILED(hr))
216     {
217         IPin_Release(This->pin.pConnectedTo);
218         This->pin.pConnectedTo = NULL;
219         DeleteMediaType(&This->pin.mtCurrent);
220     }
221
222     TRACE(" -- %lx\n", hr);
223     return hr;
224 }
225
226 HRESULT OutputPin_Init(const PIN_INFO * pPinInfo, ALLOCATOR_PROPERTIES * props, LPVOID pUserData, QUERYACCEPTPROC pQueryAccept, LPCRITICAL_SECTION pCritSec, OutputPin * pPinImpl)
227 {
228     TRACE("\n");
229
230     /* Common attributes */
231     pPinImpl->pin.refCount = 1;
232     pPinImpl->pin.pConnectedTo = NULL;
233     pPinImpl->pin.fnQueryAccept = pQueryAccept;
234     pPinImpl->pin.pUserData = pUserData;
235     pPinImpl->pin.pCritSec = pCritSec;
236     Copy_PinInfo(&pPinImpl->pin.pinInfo, pPinInfo);
237
238     /* Output pin attributes */
239     pPinImpl->pMemInputPin = NULL;
240     pPinImpl->pConnectSpecific = OutputPin_ConnectSpecific;
241     if (props)
242     {
243         memcpy(&pPinImpl->allocProps, props, sizeof(pPinImpl->allocProps));
244         if (pPinImpl->allocProps.cbAlign == 0)
245             pPinImpl->allocProps.cbAlign = 1;
246     }
247     else
248         ZeroMemory(&pPinImpl->allocProps, sizeof(pPinImpl->allocProps));
249
250     return S_OK;
251 }
252
253 HRESULT WINAPI OutputPin_Connect(IPin * iface, IPin * pReceivePin, const AM_MEDIA_TYPE * pmt)
254 {
255     HRESULT hr;
256     OutputPin *This = (OutputPin *)iface;
257
258     TRACE("(%p/%p)->(%p, %p)\n", This, iface, pReceivePin, pmt);
259     dump_AM_MEDIA_TYPE(pmt);
260
261     /* If we try to connect to ourself, we will definitely deadlock.
262      * There are other cases where we could deadlock too, but this
263      * catches the obvious case */
264     assert(pReceivePin != iface);
265
266     EnterCriticalSection(This->pin.pCritSec);
267     {
268         /* if we have been a specific type to connect with, then we can either connect
269          * with that or fail. We cannot choose different AM_MEDIA_TYPE */
270         if (pmt && !IsEqualGUID(&pmt->majortype, &GUID_NULL) && !IsEqualGUID(&pmt->subtype, &GUID_NULL))
271             hr = This->pConnectSpecific(iface, pReceivePin, pmt);
272         else
273         {
274             /* negotiate media type */
275
276             IEnumMediaTypes * pEnumCandidates;
277             AM_MEDIA_TYPE * pmtCandidate; /* Candidate media type */
278
279             if (SUCCEEDED(hr = IPin_EnumMediaTypes(iface, &pEnumCandidates)))
280             {
281                 hr = VFW_E_NO_ACCEPTABLE_TYPES; /* Assume the worst, but set to S_OK if connected successfully */
282
283                 /* try this filter's media types first */
284                 while (S_OK == IEnumMediaTypes_Next(pEnumCandidates, 1, &pmtCandidate, NULL))
285                 {
286                     if (( !pmt || CompareMediaTypes(pmt, pmtCandidate, TRUE) ) &&
287                         (This->pConnectSpecific(iface, pReceivePin, pmtCandidate) == S_OK))
288                     {
289                         hr = S_OK;
290                         TRACE("o_o\n");
291                         DeleteMediaType(pmtCandidate);
292                         break;
293                     }
294                     DeleteMediaType(pmtCandidate);
295                 }
296                 IEnumMediaTypes_Release(pEnumCandidates);
297             }
298
299             /* then try receiver filter's media types */
300             if (hr != S_OK && SUCCEEDED(hr = IPin_EnumMediaTypes(pReceivePin, &pEnumCandidates))) /* if we haven't already connected successfully */
301             {
302                 hr = VFW_E_NO_ACCEPTABLE_TYPES; /* Assume the worst, but set to S_OK if connected successfully */
303
304                 while (S_OK == IEnumMediaTypes_Next(pEnumCandidates, 1, &pmtCandidate, NULL))
305                 {
306                     if (( !pmt || CompareMediaTypes(pmt, pmtCandidate, TRUE) ) &&
307                         (This->pConnectSpecific(iface, pReceivePin, pmtCandidate) == S_OK))
308                     {
309                         hr = S_OK;
310                         DeleteMediaType(pmtCandidate);
311                         break;
312                     }
313                     DeleteMediaType(pmtCandidate);
314                 } /* while */
315                 IEnumMediaTypes_Release(pEnumCandidates);
316             } /* if not found */
317         } /* if negotiate media type */
318     } /* if succeeded */
319     LeaveCriticalSection(This->pin.pCritSec);
320
321     TRACE(" -- %lx\n", hr);
322     return hr;
323 }
324
325 HRESULT WINAPI OutputPin_ReceiveConnection(IPin * iface, IPin * pReceivePin, const AM_MEDIA_TYPE * pmt)
326 {
327     ERR("Incoming connection on an output pin! (%p, %p)\n", pReceivePin, pmt);
328
329     return E_UNEXPECTED;
330 }
331
332 HRESULT WINAPI OutputPin_Disconnect(IPin * iface)
333 {
334     HRESULT hr;
335     OutputPin *This = (OutputPin *)iface;
336
337     TRACE("()\n");
338
339     EnterCriticalSection(This->pin.pCritSec);
340     {
341         if (This->pMemInputPin)
342         {
343             IMemInputPin_Release(This->pMemInputPin);
344             This->pMemInputPin = NULL;
345         }
346         if (This->pin.pConnectedTo)
347         {
348             IPin_Release(This->pin.pConnectedTo);
349             This->pin.pConnectedTo = NULL;
350             hr = S_OK;
351         }
352         else
353             hr = S_FALSE;
354     }
355     LeaveCriticalSection(This->pin.pCritSec);
356
357     return hr;
358 }
359
360 HRESULT OutputPin_GetDeliveryBuffer(OutputPin * This, IMediaSample ** ppSample, const REFERENCE_TIME * tStart, const REFERENCE_TIME * tStop, DWORD dwFlags)
361 {
362     HRESULT hr;
363
364     TRACE("(%p, %p, %p, %lx)\n", ppSample, tStart, tStop, dwFlags);
365
366     EnterCriticalSection(This->pin.pCritSec);
367     {
368         if (!This->pin.pConnectedTo)
369             hr = VFW_E_NOT_CONNECTED;
370         else
371         {
372             IMemAllocator * pAlloc = NULL;
373
374             hr = IMemInputPin_GetAllocator(This->pMemInputPin, &pAlloc);
375
376             if (SUCCEEDED(hr))
377                 hr = IMemAllocator_GetBuffer(pAlloc, ppSample, (REFERENCE_TIME *)tStart, (REFERENCE_TIME *)tStop, dwFlags);
378
379             if (SUCCEEDED(hr))
380                 hr = IMediaSample_SetTime(*ppSample, (REFERENCE_TIME *)tStart, (REFERENCE_TIME *)tStop);
381
382             if (pAlloc)
383                 IMemAllocator_Release(pAlloc);
384         }
385     }
386     LeaveCriticalSection(This->pin.pCritSec);
387
388     return hr;
389 }
390
391 HRESULT OutputPin_SendSample(OutputPin * This, IMediaSample * pSample)
392 {
393     HRESULT hr = S_OK;
394     IMemInputPin * pMemConnected = NULL;
395
396     EnterCriticalSection(This->pin.pCritSec);
397     {
398         if (!This->pin.pConnectedTo || !This->pMemInputPin)
399             hr = VFW_E_NOT_CONNECTED;
400         else
401         {
402             /* we don't have the lock held when using This->pMemInputPin,
403              * so we need to AddRef it to stop it being deleted while we are
404              * using it. */
405             pMemConnected = This->pMemInputPin;
406             IMemInputPin_AddRef(pMemConnected);
407         }
408     }
409     LeaveCriticalSection(This->pin.pCritSec);
410
411     if (SUCCEEDED(hr))
412     {
413         /* NOTE: if we are in a critical section when Receive is called
414          * then it causes some problems (most notably with the native Video
415          * Renderer) if we are re-entered for whatever reason */
416         hr = IMemInputPin_Receive(pMemConnected, pSample);
417         IMemInputPin_Release(pMemConnected);
418     }
419
420     return hr;
421 }