I thought I'd move it around a little and put it in qcap, where I *think* it should reside, I know CaptureGraphBuilder has to, so I moved it to I had to copy some files from quartz for it though media.c is enummedia.c in quartz pin.c is a diet version of quartz' pin.c regsvr.c is meant to register the vfwcapture and the capturegraphbuilder class, also copied from quartz qcap_main.c is basically a modified version of quartz' main.c
vfwcapture related files: vfwcapture.c - front-end com interface v4l.c - Does the magic between /dev/video and vfwcapture null.c - NULL renderer, in case v4l isn't available the functions get enabled capture.h - headers that are used for null.c/v4l.c/vfwcapture.c
Current todo list: - Implement YUV formats (If anyone has some documentation on it I would be grateful, if you want to write the renderers yourself (Should be easy) I would be eternal grateful) - Add resizing (Help me!!! Fix my Resize function (24 bits to 24 bits) and send the results to me), currently resizing (Clipping and flipping image horizontal) should crash when format < 320x240 - Find a way for devenum to keep /dev/video* apart (I have a vague idea on how to do it) - Fix Capture_SetMediaType function to try to adjust size
I'll do the last thing of my TODO list myself, but if you're interested in helping you're free to do so :)
If your webcam isn't detected in msn messenger there could be several reasons: 1. Make sure you use the BUILTIN devenum,quartz and qcap 2. Make sure you regsvr32'd the *BUILTIN* qcap and quartz (regsvr32 qcap) 3. Delete HKEY_CURRENT_USER/Software/Microsoft/ActiveMovie 4. Check permissions for /dev/video* 5. Adjust #define VIDEODEVICE (in dlls/qcap/vfwcapture.c) to get the right video device.. 6. Try starting up msn with WINEDEBUG=-all,+qcap_v4l and check for output, especially the ERR lines You could get something like: err:qcap_v4l:Capture_Initialise /dev/video1: (Some explanation why the initialisation failed here) in that case it should be obvious why it wouldn't work and how you can fix it :)
If it can't render your webcam, write a renderer for it and give me a copy of it. If it your image gets clipped, dig into msdn and write a proper resize function and pass me a copy. If you're too lazy to apply my quartz fixes patch, native quartz will work too.. (I tested it).. but I offer no guarantees on it.. If something else happens, tell me the results, and I'll look at it.. (If not covered by the above ;))
At this point, it is not recommended to use this in msn but you're free to try, you will need a native msvfw32.dll, because a function msn uses is not implemented in the builtin This patch will only work for wine-cvs, since it uses some patches that are for now only in the wine cvs tree
Devices I tested this on: A creative usb webcam (zc030x driver), images looked distorted because of driver issues, not because of bugs on my side bttv, worked perfect, because for some reason it initialised with a resolution of 320x240, so I didn't need to touch it
Index: dlls/quartz/enummedia.c =================================================================== RCS file: /home/wine/wine/dlls/quartz/enummedia.c,v retrieving revision 1.5 diff -u -p -r1.5 enummedia.c --- dlls/quartz/enummedia.c 6 Jan 2005 19:36:47 -0000 1.5 +++ dlls/quartz/enummedia.c 1 May 2005 00:10:56 -0000 @@ -27,6 +27,7 @@ WINE_DEFAULT_DEBUG_CHANNEL(quartz); HRESULT CopyMediaType(AM_MEDIA_TYPE * pDest, const AM_MEDIA_TYPE *pSrc) { memcpy(pDest, pSrc, sizeof(AM_MEDIA_TYPE)); + if (!pSrc->pbFormat) return S_OK; if (!(pDest->pbFormat = CoTaskMemAlloc(pSrc->cbFormat))) return E_OUTOFMEMORY; memcpy(pDest->pbFormat, pSrc->pbFormat, pSrc->cbFormat); @@ -45,6 +46,7 @@ void DeleteMediaType(AM_MEDIA_TYPE * pMe IUnknown_Release(pMediaType->pUnk); pMediaType->pUnk = NULL; } + CoTaskMemFree(pMediaType); }
BOOL CompareMediaTypes(const AM_MEDIA_TYPE * pmt1, const AM_MEDIA_TYPE * pmt2, BOOL bWildcards) @@ -90,7 +92,11 @@ HRESULT IEnumMediaTypesImpl_Construct(co pEnumMediaTypes->enumMediaDetails.cMediaTypes = pDetails->cMediaTypes; pEnumMediaTypes->enumMediaDetails.pMediaTypes = CoTaskMemAlloc(sizeof(AM_MEDIA_TYPE) * pDetails->cMediaTypes); for (i = 0; i < pDetails->cMediaTypes; i++) - pEnumMediaTypes->enumMediaDetails.pMediaTypes[i] = pDetails->pMediaTypes[i]; + if (FAILED(CopyMediaType(&pEnumMediaTypes->enumMediaDetails.pMediaTypes[i], &pDetails->pMediaTypes[i]))) { + while (--i > 0) CoTaskMemFree(pEnumMediaTypes->enumMediaDetails.pMediaTypes[i].pbFormat); + CoTaskMemFree(pEnumMediaTypes->enumMediaDetails.pMediaTypes); + return E_OUTOFMEMORY; + } *ppEnum = (IEnumMediaTypes *)(&pEnumMediaTypes->lpVtbl); return S_OK; } @@ -136,12 +142,14 @@ static ULONG WINAPI IEnumMediaTypesImpl_
if (!refCount) { + int i; + for (i = 0; i < This->enumMediaDetails.cMediaTypes; i++) + if (This->enumMediaDetails.pMediaTypes[i].pbFormat) + CoTaskMemFree(This->enumMediaDetails.pMediaTypes[i].pbFormat); CoTaskMemFree(This->enumMediaDetails.pMediaTypes); CoTaskMemFree(This); - return 0; } - else - return refCount; + return refCount; }
static HRESULT WINAPI IEnumMediaTypesImpl_Next(IEnumMediaTypes * iface, ULONG cMediaTypes, AM_MEDIA_TYPE ** ppMediaTypes, ULONG * pcFetched) @@ -159,7 +167,13 @@ static HRESULT WINAPI IEnumMediaTypesImp ULONG i; *ppMediaTypes = CoTaskMemAlloc(sizeof(AM_MEDIA_TYPE) * cFetched); for (i = 0; i < cFetched; i++) - (*ppMediaTypes)[i] = This->enumMediaDetails.pMediaTypes[This->uIndex + i]; + if (FAILED(CopyMediaType(&(*ppMediaTypes)[i], &This->enumMediaDetails.pMediaTypes[This->uIndex + i]))) { + while (--i) + CoTaskMemFree((*ppMediaTypes)[i].pbFormat); + CoTaskMemFree(*ppMediaTypes); + *ppMediaTypes = NULL; + return E_OUTOFMEMORY; + } }
if ((cMediaTypes != 1) || pcFetched) Index: dlls/quartz/filtergraph.c =================================================================== RCS file: /home/wine/wine/dlls/quartz/filtergraph.c,v retrieving revision 1.27 diff -u -p -r1.27 filtergraph.c --- dlls/quartz/filtergraph.c 24 Mar 2005 21:01:37 -0000 1.27 +++ dlls/quartz/filtergraph.c 1 May 2005 00:10:58 -0000 @@ -245,6 +245,9 @@ static ULONG Filtergraph_Release(IFilter TRACE("(%p)->(): new ref = %ld\n", This, ref);
if (ref == 0) { + int i; + for (i = 0; i < This->nFilters; i++) + IBaseFilter_Release(This->ppFiltersInGraph[i]); IFilterMapper2_Release(This->pFilterMapper2); CloseHandle(This->hEventCompletion); EventsQueue_Destroy(&This->evqueue); @@ -556,8 +559,7 @@ static HRESULT GetInternalConnections(IB IPin_QueryDirection(ppin, &pindir); if (pindir == PINDIR_OUTPUT) i++; - else - IPin_Release(ppin); + IPin_Release(ppin); } *pppins = CoTaskMemAlloc(sizeof(IPin*)*i); /* Retrieve output pins */ @@ -605,10 +607,8 @@ static HRESULT WINAPI Graphbuilder_Conne TRACE("(%p/%p)->(%p, %p)\n", This, iface, ppinOut, ppinIn);
/* Try direct connection first */ - TRACE("Try direct connection first\n"); hr = IPin_Connect(ppinOut, ppinIn, NULL); if (SUCCEEDED(hr)) { - TRACE("Direct connection successful\n"); return S_OK; } TRACE("Direct connection failed, trying to insert other filters\n"); @@ -648,7 +648,7 @@ static HRESULT WINAPI Graphbuilder_Conne VARIANT var; GUID clsid; IPin** ppins; - IPin* ppinfilter; + IPin* ppinfilter = NULL; IBaseFilter* pfilter = NULL;
hr = GetFilterInfo(pMoniker, &clsid, &var); @@ -677,6 +677,7 @@ static HRESULT WINAPI Graphbuilder_Conne ERR("Enumpins (%lx)\n", hr); goto error; } + hr = IEnumPins_Next(penumpins, 1, &ppinfilter, &pin); if (FAILED(hr)) { ERR("Next (%lx)\n", hr); @@ -703,17 +704,22 @@ static HRESULT WINAPI Graphbuilder_Conne TRACE("pins to consider: %ld\n", nb); for(i = 0; i < nb; i++) { TRACE("Processing pin %d\n", i); - hr = IGraphBuilder_Connect(iface, ppins[0], ppinIn); + hr = IGraphBuilder_Connect(iface, ppins[i], ppinIn); if (FAILED(hr)) { - TRACE("Cannot render pin %p (%lx)\n", ppinfilter, hr); - return hr; + TRACE("Cannot render pin %p (%lx)\n", ppinfilter, hr); } + IPin_Release(ppins[i]); + if (SUCCEEDED(hr)) break; } + while (++i < nb) IPin_Release(ppins[i]); CoTaskMemFree(ppins); + IBaseFilter_Release(pfilter); + IPin_Release(ppinfilter); + break; } - break;
error: + if (ppinfilter) IPin_Release(ppinfilter); if (pfilter) { IGraphBuilder_RemoveFilter(iface, pfilter); IBaseFilter_Release(pfilter); @@ -1167,7 +1173,9 @@ static HRESULT WINAPI Mediacontrol_Invok return S_OK; }
-static HRESULT ExploreGraph(IFilterGraphImpl* pGraph, IPin* pOutputPin, REFERENCE_TIME tStart) +typedef HRESULT(WINAPI *fnFoundFilter)(IBaseFilter *); + +static HRESULT ExploreGraph(IFilterGraphImpl* pGraph, IPin* pOutputPin, fnFoundFilter FoundFilter) { HRESULT hr; IPin* pInputPin; @@ -1176,7 +1184,8 @@ static HRESULT ExploreGraph(IFilterGraph ULONG i; PIN_INFO PinInfo;
- TRACE("%p %p %lld\n", pGraph, pOutputPin, tStart); + TRACE("%p %p\n", pGraph, pOutputPin); + PinInfo.pFilter = NULL;
hr = IPin_ConnectedTo(pOutputPin, &pInputPin);
@@ -1201,20 +1210,33 @@ static HRESULT ExploreGraph(IFilterGraph /* Explore the graph downstream from this pin * FIXME: We should prevent exploring from a pin more than once. This can happens when * several input pins are connected to the same output (a MUX for instance). */ - ExploreGraph(pGraph, ppPins[i], tStart); + ExploreGraph(pGraph, ppPins[i], FoundFilter); + IPin_Release(ppPins[i]); }
CoTaskMemFree(ppPins); } - TRACE("Run filter %p\n", PinInfo.pFilter); - IBaseFilter_Run(PinInfo.pFilter, tStart); + TRACE("Doing stuff with filter %p\n", PinInfo.pFilter); + FoundFilter(PinInfo.pFilter); }
+ if (PinInfo.pFilter) IBaseFilter_Release(PinInfo.pFilter); return hr; }
-/*** IMediaControl methods ***/ -static HRESULT WINAPI Mediacontrol_Run(IMediaControl *iface) { +static HRESULT WINAPI SendRun(IBaseFilter *pFilter) { + return IBaseFilter_Run(pFilter, 0); +} + +static HRESULT WINAPI SendPause(IBaseFilter *pFilter) { + return IBaseFilter_Pause(pFilter); +} + +static HRESULT WINAPI SendStop(IBaseFilter *pFilter) { + return IBaseFilter_Stop(pFilter); +} + +static HRESULT WINAPI SendTheFilterAMessage(IMediaControl *iface, fnFoundFilter FoundFilter) { ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface); int i; IBaseFilter* pfilter; @@ -1223,19 +1245,10 @@ static HRESULT WINAPI Mediacontrol_Run(I IPin* pPin; LONG dummy; PIN_DIRECTION dir; - TRACE("(%p/%p)->()\n", This, iface);
- EnterCriticalSection(&This->cs); - - if (This->state == State_Running) - { - LeaveCriticalSection(&This->cs); - return S_OK; - } - - /* Explorer the graph from source filters to renderers, determine renderers number and - * run filters from renderers to source filters */ + /* Explorer the graph from source filters to renderers, determine renderers + * number and run filters from renderers to source filters */ This->nRenderers = 0; ResetEvent(This->hEventCompletion);
@@ -1253,6 +1266,7 @@ static HRESULT WINAPI Mediacontrol_Run(I while(IEnumPins_Next(pEnum, 1, &pPin, &dummy) == S_OK) { IPin_QueryDirection(pPin, &dir); + IPin_Release(pPin); if (dir == PINDIR_INPUT) { source = FALSE; @@ -1266,34 +1280,56 @@ static HRESULT WINAPI Mediacontrol_Run(I while(IEnumPins_Next(pEnum, 1, &pPin, &dummy) == S_OK) { /* Explore the graph downstream from this pin */ - ExploreGraph(This, pPin, 0); + ExploreGraph(This, pPin, FoundFilter); + IPin_Release(pPin); } - IBaseFilter_Run(pfilter, 0); + FoundFilter(pfilter); } IEnumPins_Release(pEnum); }
- This->state = State_Running; + return S_FALSE; +} + +/*** IMediaControl methods ***/ +static HRESULT WINAPI Mediacontrol_Run(IMediaControl *iface) { + ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface); + TRACE("(%p/%p)->()\n", This, iface); + + if (This->state == State_Running) return S_OK;
+ EnterCriticalSection(&This->cs); + SendTheFilterAMessage(iface, SendRun); + This->state = State_Running; LeaveCriticalSection(&This->cs); - return S_FALSE; }
static HRESULT WINAPI Mediacontrol_Pause(IMediaControl *iface) { ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface); + TRACE("(%p/%p)->()\n", This, iface);
- TRACE("(%p/%p)->(): stub !!!\n", This, iface); + if (This->state == State_Paused) return S_OK;
- return S_OK; + EnterCriticalSection(&This->cs); + SendTheFilterAMessage(iface, SendPause); + This->state = State_Paused; + LeaveCriticalSection(&This->cs); + return S_FALSE; }
static HRESULT WINAPI Mediacontrol_Stop(IMediaControl *iface) { ICOM_THIS_MULTI(IFilterGraphImpl, IMediaControl_vtbl, iface); + TRACE("(%p/%p)->()\n", This, iface);
- TRACE("(%p/%p)->(): stub !!!\n", This, iface); + if (This->state == State_Stopped) return S_OK;
- return S_OK; + EnterCriticalSection(&This->cs); + if (This->state == State_Running) SendTheFilterAMessage(iface, SendPause); + SendTheFilterAMessage(iface, SendStop); + This->state = State_Stopped; + LeaveCriticalSection(&This->cs); + return S_FALSE; }
static HRESULT WINAPI Mediacontrol_GetState(IMediaControl *iface, Index: dlls/quartz/pin.c =================================================================== RCS file: /home/wine/wine/dlls/quartz/pin.c,v retrieving revision 1.13 diff -u -p -r1.13 pin.c --- dlls/quartz/pin.c 2 Mar 2005 10:12:12 -0000 1.13 +++ dlls/quartz/pin.c 1 May 2005 00:10:59 -0000 @@ -49,7 +49,6 @@ static void Copy_PinInfo(PIN_INFO * pDes strcpyW(pDest->achName, pSrc->achName); pDest->dir = pSrc->dir; pDest->pFilter = pSrc->pFilter; - IBaseFilter_AddRef(pDest->pFilter); }
/* Function called as a helper to IPin_Connect */ @@ -311,6 +310,7 @@ HRESULT WINAPI IPinImpl_QueryPinInfo(IPi TRACE("(%p/%p)->(%p)\n", This, iface, pInfo);
Copy_PinInfo(pInfo, &This->pinInfo); + IBaseFilter_AddRef(pInfo->pFilter);
return S_OK; }
diff -Nru wine-old/dlls/qcap/capturegraph.c wine-new/dlls/qcap/capturegraph.c --- wine-old/dlls/qcap/capturegraph.c 1970-01-01 01:00:00.000000000 +0100 +++ wine-new/dlls/qcap/capturegraph.c 2005-04-29 00:31:34.000000000 +0200 @@ -0,0 +1,196 @@ +/* Capture Graph Builder, Minimal edition.. + * Copyright 2005 Maarten Lankhorst + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * TODO: Implement CaptureGraphBuilder2, and make all calls from + * CaptureGraphBuilder forward to it.. + */ + +#include "config.h" + +#define NONAMELESSSTRUCT +#define NONAMELESSUNION +#include "qcap_private.h" + +#include "uuids.h" +#include "mmreg.h" +#include "vfwmsgs.h" +#include "amvideo.h" +#include "windef.h" +#include "winbase.h" +#include "dshow.h" +#include "evcode.h" +#include "strmif.h" +#include "ddraw.h" + +#include "wine/unicode.h" +#include "wine/debug.h" + +WINE_DEFAULT_DEBUG_CHANNEL(qcap); + +static const ICaptureGraphBuilderVtbl Builder_Vtbl; + +typedef struct CaptureGraphImpl +{ + const ICaptureGraphBuilderVtbl * lpVtbl; + IGraphBuilder *mygraph; + + ULONG refCount; + CRITICAL_SECTION csFilter; +} CaptureGraphImpl; + +HRESULT CaptureGraphBuilder_create(IUnknown * pUnkOuter, LPVOID * ppv) +{ + CaptureGraphImpl * pCapture; + TRACE("(%p, %p)\n", pUnkOuter, ppv); + *ppv = NULL; + if (pUnkOuter) return CLASS_E_NOAGGREGATION; + pCapture = CoTaskMemAlloc(sizeof(CaptureGraphImpl)); + pCapture->lpVtbl = &Builder_Vtbl; + pCapture->refCount = 1; + pCapture->mygraph = NULL; + InitializeCriticalSection(&pCapture->csFilter); + *ppv = (LPVOID)pCapture; + return S_OK; +} + +static HRESULT WINAPI CaptureGraphBuilder_QueryInterface(ICaptureGraphBuilder * iface, REFIID riid, LPVOID * ppv) +{ + struct CaptureGraphImpl *This = (CaptureGraphImpl *)iface; + TRACE("(%p/%p)->(%s, %p)\n", This, iface, qcdebugstr_guid(riid), ppv); + *ppv = NULL; + if (IsEqualIID(riid, &IID_IUnknown)) + *ppv = (LPVOID)This; + else if (IsEqualIID(riid, &IID_ICaptureGraphBuilder)) + *ppv = (LPVOID)This; + + if (*ppv) + { + IUnknown_AddRef((IUnknown *)(*ppv)); + return S_OK; + } + + FIXME("No interface for %s!\n", qcdebugstr_guid(riid)); + return E_NOINTERFACE; +} + +static ULONG WINAPI CaptureGraphBuilder_AddRef(ICaptureGraphBuilder * iface) +{ + CaptureGraphImpl *This = (CaptureGraphImpl *)iface; + ULONG refCount = InterlockedIncrement(&This->refCount); + + TRACE("(%p/%p)->() AddRef from %ld\n", This, iface, refCount - 1); + return refCount; +} + +static ULONG WINAPI CaptureGraphBuilder_Release(ICaptureGraphBuilder * iface) +{ + CaptureGraphImpl *This = (CaptureGraphImpl *)iface; + ULONG refCount = InterlockedDecrement(&This->refCount); + + TRACE("(%p/%p)->() Release from %ld\n", This, iface, refCount + 1); + + if (!refCount) { + TRACE("Destroying everything..\n"); + DeleteCriticalSection(&This->csFilter); + if (This->mygraph != NULL) + IGraphBuilder_Release((IGraphBuilder *)This->mygraph); + CoTaskMemFree(This); + return 0; + } + else return refCount; +} + +static HRESULT WINAPI CaptureGraphBuilder_SetFilterGraph(ICaptureGraphBuilder * iface, IGraphBuilder *pfg) +{ +/* The graph builder will automatically create a filter graph if you don't call this method. If you call this method after the graph builder has created its own filter graph, the call will fail. */ + struct CaptureGraphImpl *This = (CaptureGraphImpl *)iface; + if (This->mygraph != NULL) return E_NOTIMPL; + This->mygraph = pfg; + IGraphBuilder_AddRef((IGraphBuilder *)This->mygraph); + TRACE("%p: %p\n", iface, pfg); + return S_OK; +} + +static HRESULT WINAPI CaptureGraphBuilder_GetFilterGraph(ICaptureGraphBuilder * iface, IGraphBuilder **pfg) +{ + struct CaptureGraphImpl *This = (CaptureGraphImpl *)iface; + FIXME("%p: Make our own filtergraph if we haven't got one already - stub\n", iface); + if (This->mygraph == NULL) return E_NOTIMPL; + + *pfg = This->mygraph; + IGraphBuilder_AddRef((IGraphBuilder *)This->mygraph); + + TRACE("%p: %p\n", iface, *pfg); + return S_OK; +} + +static HRESULT WINAPI CaptureGraphBuilder_SetOutputFileName(ICaptureGraphBuilder * iface, const GUID *pType, LPCOLESTR lpstrFile,IBaseFilter **ppf, IFileSinkFilter **ppSink) +{ + FIXME("%p: %p, %p, %p, %p - stub\n", iface, pType, lpstrFile, *ppf, *ppSink); + return E_NOTIMPL; +} + +static HRESULT WINAPI CaptureGraphBuilder_FindInterface(ICaptureGraphBuilder * iface, const GUID *pCategory, IBaseFilter *pf, REFIID riid, void **ppint) +{ + struct CaptureGraphImpl *This = (CaptureGraphImpl *)iface; + FIXME("%p: %s %p %s %p - unwanted partial stub!\n", This, qcdebugstr_guid(pCategory), pf, qcdebugstr_guid(riid), *ppint); + return IBaseFilter_QueryInterface(pf, riid, ppint); + /* Looks for the specified interface on the filter, upstream and + * downstream from the filter, and, optionally, only on the output + * pin of the given category. + */ +} + +static HRESULT WINAPI CaptureGraphBuilder_RenderStream(ICaptureGraphBuilder * iface, const GUID *pCategory, IUnknown *pSource, IBaseFilter *pfCompressor, IBaseFilter *pfRenderer) +{ + FIXME("%p: stub\n", iface); + return E_NOTIMPL; +} + +static HRESULT WINAPI CaptureGraphBuilder_ControlStream(ICaptureGraphBuilder * iface, const GUID *pCategory, IBaseFilter *pFilter, REFERENCE_TIME *pstart, REFERENCE_TIME *pstop, WORD wStartCookie, WORD wStopCookie) +{ + FIXME("%p: stub\n", iface); + return E_NOTIMPL; +} + +static HRESULT WINAPI CaptureGraphBuilder_AllocCapFile(ICaptureGraphBuilder * iface, LPCOLESTR lpstr, DWORDLONG dwlSize) +{ + FIXME("%p: stub\n", iface); + return E_NOTIMPL; +} + +static HRESULT WINAPI CaptureGraphBuilder_CopyCaptureFile(ICaptureGraphBuilder * iface, LPOLESTR lpwstrOld, LPOLESTR lpwstrNew, int fAllowEscAbort, IAMCopyCaptureFileProgress *pCallback) +{ + FIXME("%p: stub\n", iface); + return E_NOTIMPL; +} + +static const ICaptureGraphBuilderVtbl Builder_Vtbl = +{ + CaptureGraphBuilder_QueryInterface, + CaptureGraphBuilder_AddRef, + CaptureGraphBuilder_Release, + CaptureGraphBuilder_SetFilterGraph, + CaptureGraphBuilder_GetFilterGraph, + CaptureGraphBuilder_SetOutputFileName, + CaptureGraphBuilder_FindInterface, + CaptureGraphBuilder_RenderStream, + CaptureGraphBuilder_ControlStream, + CaptureGraphBuilder_AllocCapFile, + CaptureGraphBuilder_CopyCaptureFile +}; + diff -Nru wine-old/dlls/qcap/capture.h wine-new/dlls/qcap/capture.h --- wine-old/dlls/qcap/capture.h 1970-01-01 01:00:00.000000000 +0100 +++ wine-new/dlls/qcap/capture.h 2005-05-01 01:51:50.000000000 +0200 @@ -0,0 +1,35 @@ +/* DirectShow private capture header (QCAP.DLL) + * + * Copyright 2005 Maarten Lankhorst + * + * This file contains the (internal) driver registration functions, + * driver enumeration APIs and DirectDraw creation functions. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef __CAPTURE_H__ +#define __CAPTURE_H__ + +HRESULT Capture_Initialise(void ** pointer, IPin *pOut, USHORT card); +HRESULT Capture_GetMediaType(void * pBox, AM_MEDIA_TYPE ** mT); +HRESULT Capture_SetMediaType(void * pBox, AM_MEDIA_TYPE * mT); +HRESULT Capture_Run(void * pBox, FILTER_STATE *state); +HRESULT Capture_Stop(void * pBox, FILTER_STATE *state); +HRESULT Capture_Pause(void * pBox, FILTER_STATE *state); +HRESULT Capture_Destroy(void * pBox); + +#endif /* __CAPTURE_H__ */ + diff -Nru wine-old/dlls/qcap/enumpins.c wine-new/dlls/qcap/enumpins.c --- wine-old/dlls/qcap/enumpins.c 1970-01-01 01:00:00.000000000 +0100 +++ wine-new/dlls/qcap/enumpins.c 2005-04-29 13:40:15.000000000 +0200 @@ -0,0 +1,183 @@ +/* + * Generic Implementation of IPin Interface + * + * Copyright 2003 Robert Shearman + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include "qcap_private.h" +#include "pin.h" + +#include "wine/debug.h" +#include "wine/unicode.h" +#include "uuids.h" +#include "vfwmsgs.h" +#include <assert.h> + +WINE_DEFAULT_DEBUG_CHANNEL(qcap); + +typedef struct IEnumPinsImpl +{ + const IEnumPinsVtbl * lpVtbl; + ULONG refCount; + ENUMPINDETAILS enumPinDetails; + ULONG uIndex; +} IEnumPinsImpl; + +static const struct IEnumPinsVtbl IEnumPinsImpl_Vtbl; + +HRESULT IEnumPinsImpl_Construct(const ENUMPINDETAILS * pDetails, IEnumPins ** ppEnum) +{ + IEnumPinsImpl * pEnumPins = CoTaskMemAlloc(sizeof(IEnumPinsImpl)); + TRACE("()\n"); + if (!pEnumPins) + { + *ppEnum = NULL; + return E_OUTOFMEMORY; + } + pEnumPins->lpVtbl = &IEnumPinsImpl_Vtbl; + pEnumPins->refCount = 1; + pEnumPins->uIndex = 0; + CopyMemory(&pEnumPins->enumPinDetails, pDetails, sizeof(ENUMPINDETAILS)); + *ppEnum = (IEnumPins *)(&pEnumPins->lpVtbl); + return S_OK; +} + +static HRESULT WINAPI IEnumPinsImpl_QueryInterface(IEnumPins * iface, REFIID riid, LPVOID * ppv) +{ + TRACE("(%s, %p)\n", qcdebugstr_guid(riid), ppv); + + *ppv = NULL; + + if (IsEqualIID(riid, &IID_IUnknown)) + *ppv = (LPVOID)iface; + else if (IsEqualIID(riid, &IID_IEnumPins)) + *ppv = (LPVOID)iface; + + if (*ppv) + { + IUnknown_AddRef((IUnknown *)(*ppv)); + return S_OK; + } + + FIXME("No interface for %s!\n", qcdebugstr_guid(riid)); + + return E_NOINTERFACE; +} +static ULONG WINAPI IEnumPinsImpl_AddRef(IEnumPins * iface) +{ + IEnumPinsImpl *This = (IEnumPinsImpl *)iface; + ULONG refCount = InterlockedIncrement(&This->refCount); + + TRACE("() -> %lu\n", refCount); + + return refCount; +} + +static ULONG WINAPI IEnumPinsImpl_Release(IEnumPins * iface) +{ + IEnumPinsImpl *This = (IEnumPinsImpl *)iface; + ULONG refCount = InterlockedDecrement(&This->refCount); + + TRACE("() -> %lu\n", refCount); + + if (!refCount) + { + CoTaskMemFree(This); + return 0; + } + else + return refCount; +} + +static HRESULT WINAPI IEnumPinsImpl_Next(IEnumPins * iface, ULONG cPins, IPin ** ppPins, ULONG * pcFetched) +{ + ULONG cFetched; + IEnumPinsImpl *This = (IEnumPinsImpl *)iface; + + TRACE("()\n"); + + cFetched = min(This->enumPinDetails.cPins, This->uIndex + cPins) - This->uIndex; + + TRACE("(%lu, %p, %p)\n", cPins, ppPins, pcFetched); + + if (cFetched > 0) + { + ULONG i; + for (i = 0; i < cFetched; i++) { + IPin_AddRef(This->enumPinDetails.ppPins[This->uIndex + i]); + ppPins[i] = This->enumPinDetails.ppPins[This->uIndex + i]; + } + } + + if ((cPins != 1) || pcFetched) + *pcFetched = cFetched; + + This->uIndex += cFetched; + + if (cFetched != cPins) + return S_FALSE; + return S_OK; +} + +static HRESULT WINAPI IEnumPinsImpl_Skip(IEnumPins * iface, ULONG cPins) +{ + IEnumPinsImpl *This = (IEnumPinsImpl *)iface; + + TRACE("(%lu)\n", cPins); + + if (This->uIndex + cPins < This->enumPinDetails.cPins) + { + This->uIndex += cPins; + return S_OK; + } + return S_FALSE; +} + +static HRESULT WINAPI IEnumPinsImpl_Reset(IEnumPins * iface) +{ + IEnumPinsImpl *This = (IEnumPinsImpl *)iface; + + TRACE("IEnumPinsImpl::Reset()\n"); + + This->uIndex = 0; + return S_OK; +} + +static HRESULT WINAPI IEnumPinsImpl_Clone(IEnumPins * iface, IEnumPins ** ppEnum) +{ + HRESULT hr; + IEnumPinsImpl *This = (IEnumPinsImpl *)iface; + + TRACE("(%p)\n", ppEnum); + + hr = IEnumPinsImpl_Construct(&This->enumPinDetails, ppEnum); + if (FAILED(hr)) + return hr; + return IEnumPins_Skip(*ppEnum, This->uIndex); +} + +static const IEnumPinsVtbl IEnumPinsImpl_Vtbl = +{ + IEnumPinsImpl_QueryInterface, + IEnumPinsImpl_AddRef, + IEnumPinsImpl_Release, + IEnumPinsImpl_Next, + IEnumPinsImpl_Skip, + IEnumPinsImpl_Reset, + IEnumPinsImpl_Clone +}; + diff -Nru wine-old/dlls/qcap/Makefile.in wine-new/dlls/qcap/Makefile.in --- wine-old/dlls/qcap/Makefile.in 2004-05-14 23:37:32.000000000 +0200 +++ wine-new/dlls/qcap/Makefile.in 2005-05-01 01:56:42.000000000 +0200 @@ -3,8 +3,19 @@ SRCDIR = @srcdir@ VPATH = @srcdir@ MODULE = qcap.dll +IMPORTS = ole32 kernel32 advapi32 user32 +EXTRALIBS = -lstrmiids -luuid $(LIBUNICODE)
-C_SRCS = qcap_main.c +C_SRCS = \ + capturegraph.c \ + enumpins.c \ + media.c \ + null.c \ + pin.c \ + qcap_main.c \ + regsvr.c \ + v4l.c \ + vfwcapture.c
RC_SRCS = version.rc
diff -Nru wine-old/dlls/qcap/media.c wine-new/dlls/qcap/media.c --- wine-old/dlls/qcap/media.c 1970-01-01 01:00:00.000000000 +0100 +++ wine-new/dlls/qcap/media.c 2005-05-01 01:48:09.000000000 +0200 @@ -0,0 +1,229 @@ +/* + * Implementation of IEnumMediaTypes Interface + * + * Copyright 2003 Robert Shearman + * Copyright 2005 Maarten Lankhorst + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include "qcap_private.h" + +#include "wine/debug.h" + +WINE_DEFAULT_DEBUG_CHANNEL(qcap); + +HRESULT CopyMediaType(AM_MEDIA_TYPE * pDest, const AM_MEDIA_TYPE *pSrc) +{ + memcpy(pDest, pSrc, sizeof(AM_MEDIA_TYPE)); + if (!pDest->pbFormat) return S_OK; + if (!(pDest->pbFormat = CoTaskMemAlloc(pSrc->cbFormat))) + return E_OUTOFMEMORY; + memcpy(pDest->pbFormat, pSrc->pbFormat, pSrc->cbFormat); + return S_OK; +} + +void DeleteMediaType(AM_MEDIA_TYPE * pMediaType) +{ + if (pMediaType->pbFormat) + { + CoTaskMemFree(pMediaType->pbFormat); + pMediaType->pbFormat = NULL; + } + if (pMediaType->pUnk) + { + IUnknown_Release(pMediaType->pUnk); + pMediaType->pUnk = NULL; + } + CoTaskMemFree(pMediaType); +} + +BOOL CompareMediaTypes(const AM_MEDIA_TYPE * pmt1, const AM_MEDIA_TYPE * pmt2, BOOL bWildcards) +{ + TRACE("pmt1: "); + dump_AM_MEDIA_TYPE(pmt1); + TRACE("pmt2: "); + dump_AM_MEDIA_TYPE(pmt2); + return (((bWildcards && (IsEqualGUID(&pmt1->majortype, &GUID_NULL) || IsEqualGUID(&pmt2->majortype, &GUID_NULL))) || IsEqualGUID(&pmt1->majortype, &pmt2->majortype)) && + ((bWildcards && (IsEqualGUID(&pmt1->subtype, &GUID_NULL) || IsEqualGUID(&pmt2->subtype, &GUID_NULL))) || IsEqualGUID(&pmt1->subtype, &pmt2->subtype))); +} + +void dump_AM_MEDIA_TYPE(const AM_MEDIA_TYPE * pmt) +{ + if (!pmt) + return; + TRACE("\t%s\n\t%s\n\t...\n\t%s\n", qcdebugstr_guid(&pmt->majortype), qcdebugstr_guid(&pmt->subtype), qcdebugstr_guid(&pmt->formattype)); +} + +typedef struct IEnumMediaTypesImpl +{ + const IEnumMediaTypesVtbl * lpVtbl; + ULONG refCount; + ENUMMEDIADETAILS enumMediaDetails; + ULONG uIndex; +} IEnumMediaTypesImpl; + +static const struct IEnumMediaTypesVtbl IEnumMediaTypesImpl_Vtbl; + +HRESULT IEnumMediaTypesImpl_Construct(const ENUMMEDIADETAILS * pDetails, IEnumMediaTypes ** ppEnum) +{ + ULONG i; + IEnumMediaTypesImpl * pEnumMediaTypes = CoTaskMemAlloc(sizeof(IEnumMediaTypesImpl)); + + if (!pEnumMediaTypes) + { + *ppEnum = NULL; + return E_OUTOFMEMORY; + } + pEnumMediaTypes->lpVtbl = &IEnumMediaTypesImpl_Vtbl; + pEnumMediaTypes->refCount = 1; + pEnumMediaTypes->uIndex = 0; + pEnumMediaTypes->enumMediaDetails.cMediaTypes = pDetails->cMediaTypes; + pEnumMediaTypes->enumMediaDetails.pMediaTypes = CoTaskMemAlloc(sizeof(AM_MEDIA_TYPE) * pDetails->cMediaTypes); + for (i = 0; i < pDetails->cMediaTypes; i++) + CopyMediaType(&pEnumMediaTypes->enumMediaDetails.pMediaTypes[i], &pDetails->pMediaTypes[i]); + *ppEnum = (IEnumMediaTypes *)(&pEnumMediaTypes->lpVtbl); + return S_OK; +} + +static HRESULT WINAPI IEnumMediaTypesImpl_QueryInterface(IEnumMediaTypes * iface, REFIID riid, LPVOID * ppv) +{ + TRACE("(%s, %p)\n", qcdebugstr_guid(riid), ppv); + + *ppv = NULL; + + if (IsEqualIID(riid, &IID_IUnknown)) + *ppv = (LPVOID)iface; + else if (IsEqualIID(riid, &IID_IEnumMediaTypes)) + *ppv = (LPVOID)iface; + + if (*ppv) + { + IUnknown_AddRef((IUnknown *)(*ppv)); + return S_OK; + } + + FIXME("No interface for %s!\n", qcdebugstr_guid(riid)); + + return E_NOINTERFACE; +} + +static ULONG WINAPI IEnumMediaTypesImpl_AddRef(IEnumMediaTypes * iface) +{ + IEnumMediaTypesImpl *This = (IEnumMediaTypesImpl *)iface; + ULONG refCount = InterlockedIncrement(&This->refCount); + + TRACE("()\n"); + + return refCount; +} + +static ULONG WINAPI IEnumMediaTypesImpl_Release(IEnumMediaTypes * iface) +{ + IEnumMediaTypesImpl *This = (IEnumMediaTypesImpl *)iface; + ULONG refCount = InterlockedDecrement(&This->refCount); + + TRACE("()\n"); + + if (!refCount) + { + int i; + for (i = 0; i < This->enumMediaDetails.cMediaTypes; i++) + if (This->enumMediaDetails.pMediaTypes[i].pbFormat) + CoTaskMemFree(This->enumMediaDetails.pMediaTypes[i].pbFormat); + CoTaskMemFree(This->enumMediaDetails.pMediaTypes); + CoTaskMemFree(This); + return 0; + } + else + return refCount; +} + +static HRESULT WINAPI IEnumMediaTypesImpl_Next(IEnumMediaTypes * iface, ULONG cMediaTypes, AM_MEDIA_TYPE ** ppMediaTypes, ULONG * pcFetched) +{ + ULONG cFetched; + IEnumMediaTypesImpl *This = (IEnumMediaTypesImpl *)iface; + + cFetched = min(This->enumMediaDetails.cMediaTypes, This->uIndex + cMediaTypes) - This->uIndex; + + TRACE("(%lu, %p, %p)\n", cMediaTypes, ppMediaTypes, pcFetched); + TRACE("Next uIndex: %lu, cFetched: %lu\n", This->uIndex, cFetched); + + if (cFetched > 0) + { + ULONG i; + *ppMediaTypes = CoTaskMemAlloc(sizeof(AM_MEDIA_TYPE) * cFetched); + for (i = 0; i < cFetched; i++) + CopyMediaType(&(*ppMediaTypes)[i], &This->enumMediaDetails.pMediaTypes[This->uIndex + i]); + } + + if ((cMediaTypes != 1) || pcFetched) + *pcFetched = cFetched; + + This->uIndex += cFetched; + + if (cFetched != cMediaTypes) + return S_FALSE; + return S_OK; +} + +static HRESULT WINAPI IEnumMediaTypesImpl_Skip(IEnumMediaTypes * iface, ULONG cMediaTypes) +{ + IEnumMediaTypesImpl *This = (IEnumMediaTypesImpl *)iface; + + TRACE("(%lu)\n", cMediaTypes); + + if (This->uIndex + cMediaTypes < This->enumMediaDetails.cMediaTypes) + { + This->uIndex += cMediaTypes; + return S_OK; + } + return S_FALSE; +} + +static HRESULT WINAPI IEnumMediaTypesImpl_Reset(IEnumMediaTypes * iface) +{ + IEnumMediaTypesImpl *This = (IEnumMediaTypesImpl *)iface; + + TRACE("()\n"); + + This->uIndex = 0; + return S_OK; +} + +static HRESULT WINAPI IEnumMediaTypesImpl_Clone(IEnumMediaTypes * iface, IEnumMediaTypes ** ppEnum) +{ + HRESULT hr; + IEnumMediaTypesImpl *This = (IEnumMediaTypesImpl *)iface; + + TRACE("(%p)\n", ppEnum); + hr = IEnumMediaTypesImpl_Construct(&This->enumMediaDetails, ppEnum); + + if (FAILED(hr)) + return hr; + return IEnumMediaTypes_Skip(*ppEnum, This->uIndex); +} + +static const IEnumMediaTypesVtbl IEnumMediaTypesImpl_Vtbl = +{ + IEnumMediaTypesImpl_QueryInterface, + IEnumMediaTypesImpl_AddRef, + IEnumMediaTypesImpl_Release, + IEnumMediaTypesImpl_Next, + IEnumMediaTypesImpl_Skip, + IEnumMediaTypesImpl_Reset, + IEnumMediaTypesImpl_Clone +}; + diff -Nru wine-old/dlls/qcap/null.c wine-new/dlls/qcap/null.c --- wine-old/dlls/qcap/null.c 1970-01-01 01:00:00.000000000 +0100 +++ wine-new/dlls/qcap/null.c 2005-05-01 01:49:06.000000000 +0200 @@ -0,0 +1,84 @@ +/* DirectShow capture services (QCAP.DLL) + * + * Copyright 2005 Maarten Lankhorst + * + * This file contains the part of the vfw capture interface that + * does the actual capturing stuff required for capturing + * and setting/getting media format.. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * Why on earth am I writing a copyright notice for a NULL renderer??? + */ + +#include "config.h" +#ifndef HAVE_LINUX_VIDEODEV_H + +#define NONAMELESSSTRUCT +#define NONAMELESSUNION +#include "qcap_private.h" +#include "pin.h" + +#include "uuids.h" +#include "mmreg.h" +#include "vfwmsgs.h" +#include "amvideo.h" +#include "windef.h" +#include "winbase.h" +#include "dshow.h" +#include "strmif.h" +#include "ddraw.h" + +#include "wine/unicode.h" +#include "wine/debug.h" + +HRESULT Capture_Initialise(void ** pointer, IPin *pOut, USHORT card) +{ + ERR("No DirectShow Video for Wine Capture support compiled\n"); + return E_FAIL; +} + +HRESULT Capture_GetMediaType(void * pBox, AM_MEDIA_TYPE ** mT) +{ + return E_FAIL; +} + +HRESULT Capture_SetMediaType(void * pBox, AM_MEDIA_TYPE * mT) +{ + return E_FAIL; +} + +HRESULT Capture_Run(void * pBox, FILTER_STATE *state) +{ + return E_FAIL; +} + +HRESULT Capture_Stop(void * pBox, FILTER_STATE *state) +{ + return E_FAIL; +} + +HRESULT Capture_Pause(void * pBox, FILTER_STATE *state) +{ + return E_FAIL; +} + +HRESULT Capture_Destroy(void * pBox) +{ + return E_FAIL; +} + +#endif + diff -Nru wine-old/dlls/qcap/pin.c wine-new/dlls/qcap/pin.c --- wine-old/dlls/qcap/pin.c 1970-01-01 01:00:00.000000000 +0100 +++ wine-new/dlls/qcap/pin.c 2005-04-30 18:44:10.000000000 +0200 @@ -0,0 +1,411 @@ +/* + * Generic Implementation of IPin Interface + * + * Copyright 2003 Robert Shearman + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include "qcap_private.h" +#include "pin.h" + +#include "wine/debug.h" +#include "wine/unicode.h" +#include "uuids.h" +#include "vfwmsgs.h" +#include <assert.h> + +WINE_DEFAULT_DEBUG_CHANNEL(qcap); + +#define ALIGNDOWN(value,boundary) ((value) & ~(boundary-1)) +#define ALIGNUP(value,boundary) (ALIGNDOWN(value - 1, boundary) + boundary) + +static void Copy_PinInfo(PIN_INFO * pDest, const PIN_INFO * pSrc) +{ + /* Tempting to just do a memcpy, but the name field is + 128 characters long! We will probably never exceed 10 + most of the time, so we are better off copying + each field manually */ + strcpyW(pDest->achName, pSrc->achName); + pDest->dir = pSrc->dir; + pDest->pFilter = pSrc->pFilter; +} + +HRESULT WINAPI IPinImpl_ConnectedTo(IPin * iface, IPin ** ppPin) +{ + HRESULT hr; + IPinImpl *This = (IPinImpl *)iface; + +/* TRACE("(%p)\n", ppPin);*/ + + EnterCriticalSection(This->pCritSec); + { + if (This->pConnectedTo) + { + *ppPin = This->pConnectedTo; + IPin_AddRef(*ppPin); + hr = S_OK; + } + else + hr = VFW_E_NOT_CONNECTED; + } + LeaveCriticalSection(This->pCritSec); + + return hr; +} + +HRESULT WINAPI IPinImpl_ConnectionMediaType(IPin * iface, AM_MEDIA_TYPE * pmt) +{ + HRESULT hr; + IPinImpl *This = (IPinImpl *)iface; + + TRACE("(%p/%p)->(%p)\n", This, iface, pmt); + + EnterCriticalSection(This->pCritSec); + { + if (This->pConnectedTo) + { + CopyMediaType(pmt, &This->mtCurrent); + hr = S_OK; + } + else + { + ZeroMemory(pmt, sizeof(*pmt)); + hr = VFW_E_NOT_CONNECTED; + } + } + LeaveCriticalSection(This->pCritSec); + + return hr; +} + +HRESULT WINAPI IPinImpl_QueryPinInfo(IPin * iface, PIN_INFO * pInfo) +{ + IPinImpl *This = (IPinImpl *)iface; + + TRACE("(%p/%p)->(%p)\n", This, iface, pInfo); + + Copy_PinInfo(pInfo, &This->pinInfo); + IBaseFilter_AddRef(pInfo->pFilter); + + return S_OK; +} + +HRESULT WINAPI IPinImpl_QueryDirection(IPin * iface, PIN_DIRECTION * pPinDir) +{ + IPinImpl *This = (IPinImpl *)iface; + + TRACE("(%p/%p)->(%p)\n", This, iface, pPinDir); + + *pPinDir = This->pinInfo.dir; + + return S_OK; +} + +HRESULT WINAPI IPinImpl_QueryId(IPin * iface, LPWSTR * Id) +{ + IPinImpl *This = (IPinImpl *)iface; + + TRACE("(%p/%p)->(%p)\n", This, iface, Id); + + *Id = CoTaskMemAlloc((strlenW(This->pinInfo.achName) + 1) * sizeof(WCHAR)); + if (!Id) + return E_OUTOFMEMORY; + + strcpyW(*Id, This->pinInfo.achName); + + return S_OK; +} + +HRESULT WINAPI IPinImpl_QueryAccept(IPin * iface, const AM_MEDIA_TYPE * pmt) +{ + IPinImpl *This = (IPinImpl *)iface; + + TRACE("(%p/%p)->(%p)\n", This, iface, pmt); + + if (!This->fnQueryAccept) return S_OK; + + return (This->fnQueryAccept(This->pUserData, pmt) == S_OK ? S_OK : S_FALSE); +} + +HRESULT WINAPI IPinImpl_QueryInternalConnections(IPin * iface, IPin ** apPin, ULONG * cPin) +{ + IPinImpl *This = (IPinImpl *)iface; + + TRACE("(%p/%p)->(%p, %p)\n", This, iface, apPin, cPin); + + return E_NOTIMPL; /* to tell caller that all input pins connected to all output pins */ +} + +/* Function called as a helper to IPin_Connect */ +/* specific AM_MEDIA_TYPE - it cannot be NULL */ +/* NOTE: not part of standard interface */ +static HRESULT OutputPin_ConnectSpecific(IPin * iface, IPin * pReceivePin, const AM_MEDIA_TYPE * pmt) +{ + OutputPin *This = (OutputPin *)iface; + HRESULT hr; + IMemAllocator * pMemAlloc = NULL; + ALLOCATOR_PROPERTIES actual; /* FIXME: should we put the actual props back in to This? */ + + TRACE("(%p, %p)\n", pReceivePin, pmt); + dump_AM_MEDIA_TYPE(pmt); + + /* FIXME: call queryacceptproc */ + + This->pin.pConnectedTo = pReceivePin; + IPin_AddRef(pReceivePin); + CopyMediaType(&This->pin.mtCurrent, pmt); + + hr = IPin_ReceiveConnection(pReceivePin, iface, pmt); + + /* get the IMemInputPin interface we will use to deliver samples to the + * connected pin */ + if (SUCCEEDED(hr)) + { + hr = IPin_QueryInterface(pReceivePin, &IID_IMemInputPin, (LPVOID)&This->pMemInputPin); + + if (SUCCEEDED(hr)) + hr = IMemInputPin_GetAllocator(This->pMemInputPin, &pMemAlloc); + + if (hr == VFW_E_NO_ALLOCATOR) + { + /* Input pin provides no allocator, use standard memory allocator */ + hr = CoCreateInstance(&CLSID_MemoryAllocator, NULL, CLSCTX_INPROC_SERVER, &IID_IMemAllocator, (LPVOID*)&pMemAlloc); + + if (SUCCEEDED(hr)) + { + hr = IMemInputPin_NotifyAllocator(This->pMemInputPin, pMemAlloc, FALSE); + } + } + + if (SUCCEEDED(hr)) + hr = IMemAllocator_SetProperties(pMemAlloc, &This->allocProps, &actual); + + if (pMemAlloc) + IMemAllocator_Release(pMemAlloc); + + /* break connection if we couldn't get the allocator */ + if (FAILED(hr)) + IPin_Disconnect(pReceivePin); + } + + if (FAILED(hr)) + { + IPin_Release(This->pin.pConnectedTo); + This->pin.pConnectedTo = NULL; + DeleteMediaType(&This->pin.mtCurrent); + } + + TRACE(" -- %lx\n", hr); + return hr; +} + +HRESULT OutputPin_Init(const PIN_INFO * pPinInfo, ALLOCATOR_PROPERTIES * props, LPVOID pUserData, QUERYACCEPTPROC pQueryAccept, LPCRITICAL_SECTION pCritSec, OutputPin * pPinImpl) +{ + TRACE("\n"); + + /* Common attributes */ + pPinImpl->pin.refCount = 1; + pPinImpl->pin.pConnectedTo = NULL; + pPinImpl->pin.fnQueryAccept = pQueryAccept; + pPinImpl->pin.pUserData = pUserData; + pPinImpl->pin.pCritSec = pCritSec; + Copy_PinInfo(&pPinImpl->pin.pinInfo, pPinInfo); + + /* Output pin attributes */ + pPinImpl->pMemInputPin = NULL; + pPinImpl->pConnectSpecific = OutputPin_ConnectSpecific; + if (props) + { + memcpy(&pPinImpl->allocProps, props, sizeof(pPinImpl->allocProps)); + if (pPinImpl->allocProps.cbAlign == 0) + pPinImpl->allocProps.cbAlign = 1; + } + else + ZeroMemory(&pPinImpl->allocProps, sizeof(pPinImpl->allocProps)); + + return S_OK; +} + +HRESULT WINAPI OutputPin_Connect(IPin * iface, IPin * pReceivePin, const AM_MEDIA_TYPE * pmt) +{ + HRESULT hr; + OutputPin *This = (OutputPin *)iface; + + TRACE("(%p/%p)->(%p, %p)\n", This, iface, pReceivePin, pmt); + dump_AM_MEDIA_TYPE(pmt); + + /* If we try to connect to ourself, we will definitely deadlock. + * There are other cases where we could deadlock too, but this + * catches the obvious case */ + assert(pReceivePin != iface); + + EnterCriticalSection(This->pin.pCritSec); + { + /* if we have been a specific type to connect with, then we can either connect + * with that or fail. We cannot choose different AM_MEDIA_TYPE */ + if (pmt && !IsEqualGUID(&pmt->majortype, &GUID_NULL) && !IsEqualGUID(&pmt->subtype, &GUID_NULL)) + hr = This->pConnectSpecific(iface, pReceivePin, pmt); + else + { + /* negotiate media type */ + + IEnumMediaTypes * pEnumCandidates; + AM_MEDIA_TYPE * pmtCandidate; /* Candidate media type */ + + if (SUCCEEDED(hr = IPin_EnumMediaTypes(iface, &pEnumCandidates))) + { + hr = VFW_E_NO_ACCEPTABLE_TYPES; /* Assume the worst, but set to S_OK if connected successfully */ + + /* try this filter's media types first */ + while (S_OK == IEnumMediaTypes_Next(pEnumCandidates, 1, &pmtCandidate, NULL)) + { + if (( !pmt || CompareMediaTypes(pmt, pmtCandidate, TRUE) ) && + (This->pConnectSpecific(iface, pReceivePin, pmtCandidate) == S_OK)) + { + hr = S_OK; + TRACE("o_o\n"); + DeleteMediaType(pmtCandidate); + break; + } + DeleteMediaType(pmtCandidate); + } + IEnumMediaTypes_Release(pEnumCandidates); + } + + /* then try receiver filter's media types */ + if (hr != S_OK && SUCCEEDED(hr = IPin_EnumMediaTypes(pReceivePin, &pEnumCandidates))) /* if we haven't already connected successfully */ + { + hr = VFW_E_NO_ACCEPTABLE_TYPES; /* Assume the worst, but set to S_OK if connected successfully */ + + while (S_OK == IEnumMediaTypes_Next(pEnumCandidates, 1, &pmtCandidate, NULL)) + { + if (( !pmt || CompareMediaTypes(pmt, pmtCandidate, TRUE) ) && + (This->pConnectSpecific(iface, pReceivePin, pmtCandidate) == S_OK)) + { + hr = S_OK; + DeleteMediaType(pmtCandidate); + break; + } + DeleteMediaType(pmtCandidate); + } /* while */ + IEnumMediaTypes_Release(pEnumCandidates); + } /* if not found */ + } /* if negotiate media type */ + } /* if succeeded */ + LeaveCriticalSection(This->pin.pCritSec); + + TRACE(" -- %lx\n", hr); + return hr; +} + +HRESULT WINAPI OutputPin_ReceiveConnection(IPin * iface, IPin * pReceivePin, const AM_MEDIA_TYPE * pmt) +{ + ERR("Incoming connection on an output pin! (%p, %p)\n", pReceivePin, pmt); + + return E_UNEXPECTED; +} + +HRESULT WINAPI OutputPin_Disconnect(IPin * iface) +{ + HRESULT hr; + OutputPin *This = (OutputPin *)iface; + + TRACE("()\n"); + + EnterCriticalSection(This->pin.pCritSec); + { + if (This->pMemInputPin) + { + IMemInputPin_Release(This->pMemInputPin); + This->pMemInputPin = NULL; + } + if (This->pin.pConnectedTo) + { + IPin_Release(This->pin.pConnectedTo); + This->pin.pConnectedTo = NULL; + hr = S_OK; + } + else + hr = S_FALSE; + } + LeaveCriticalSection(This->pin.pCritSec); + + return hr; +} + +HRESULT OutputPin_GetDeliveryBuffer(OutputPin * This, IMediaSample ** ppSample, const REFERENCE_TIME * tStart, const REFERENCE_TIME * tStop, DWORD dwFlags) +{ + HRESULT hr; + + TRACE("(%p, %p, %p, %lx)\n", ppSample, tStart, tStop, dwFlags); + + EnterCriticalSection(This->pin.pCritSec); + { + if (!This->pin.pConnectedTo) + hr = VFW_E_NOT_CONNECTED; + else + { + IMemAllocator * pAlloc = NULL; + + hr = IMemInputPin_GetAllocator(This->pMemInputPin, &pAlloc); + + if (SUCCEEDED(hr)) + hr = IMemAllocator_GetBuffer(pAlloc, ppSample, (REFERENCE_TIME *)tStart, (REFERENCE_TIME *)tStop, dwFlags); + + if (SUCCEEDED(hr)) + hr = IMediaSample_SetTime(*ppSample, (REFERENCE_TIME *)tStart, (REFERENCE_TIME *)tStop); + + if (pAlloc) + IMemAllocator_Release(pAlloc); + } + } + LeaveCriticalSection(This->pin.pCritSec); + + return hr; +} + +HRESULT OutputPin_SendSample(OutputPin * This, IMediaSample * pSample) +{ + HRESULT hr = S_OK; + IMemInputPin * pMemConnected = NULL; + + EnterCriticalSection(This->pin.pCritSec); + { + if (!This->pin.pConnectedTo || !This->pMemInputPin) + hr = VFW_E_NOT_CONNECTED; + else + { + /* we don't have the lock held when using This->pMemInputPin, + * so we need to AddRef it to stop it being deleted while we are + * using it. */ + pMemConnected = This->pMemInputPin; + IMemInputPin_AddRef(pMemConnected); + } + } + LeaveCriticalSection(This->pin.pCritSec); + + if (SUCCEEDED(hr)) + { + /* NOTE: if we are in a critical section when Receive is called + * then it causes some problems (most notably with the native Video + * Renderer) if we are re-entered for whatever reason */ + hr = IMemInputPin_Receive(pMemConnected, pSample); + IMemInputPin_Release(pMemConnected); + } + + return hr; +} + diff -Nru wine-old/dlls/qcap/pin.h wine-new/dlls/qcap/pin.h --- wine-old/dlls/qcap/pin.h 1970-01-01 01:00:00.000000000 +0100 +++ wine-new/dlls/qcap/pin.h 2005-04-29 14:01:43.000000000 +0200 @@ -0,0 +1,81 @@ +/* + * IPin function declarations to allow inheritance + * + * Copyright 2003 Robert Shearman + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +/* This function will process incoming samples to the pin. + * Any return value valid in IMemInputPin::Receive is allowed here + */ +typedef HRESULT (* SAMPLEPROC)(LPVOID userdata, IMediaSample * pSample); + +/* This function will determine whether a type is supported or not. + * It is allowed to return any error value (within reason), as opposed + * to IPin::QueryAccept which is only allowed to return S_OK or S_FALSE. + */ +typedef HRESULT (* QUERYACCEPTPROC)(LPVOID userdata, const AM_MEDIA_TYPE * pmt); + +/* This function is called prior to finalizing a connection with + * another pin and can be used to get things from the other pin + * like IMemInput interfaces. + */ +typedef HRESULT (* PRECONNECTPROC)(IPin * iface, IPin * pConnectPin); + +typedef struct IPinImpl +{ + const struct IPinVtbl * lpVtbl; + ULONG refCount; + LPCRITICAL_SECTION pCritSec; + PIN_INFO pinInfo; + IPin * pConnectedTo; + AM_MEDIA_TYPE mtCurrent; + ENUMMEDIADETAILS enumMediaDetails; + QUERYACCEPTPROC fnQueryAccept; + LPVOID pUserData; +} IPinImpl; + +typedef struct OutputPin +{ + /* inheritance C style! */ + IPinImpl pin; + + IMemInputPin * pMemInputPin; + HRESULT (* pConnectSpecific)(IPin * iface, IPin * pReceiver, const AM_MEDIA_TYPE * pmt); + ALLOCATOR_PROPERTIES allocProps; +} OutputPin; + +/*** Initializers ***/ +HRESULT OutputPin_Init(const PIN_INFO * pPinInfo, ALLOCATOR_PROPERTIES *props, LPVOID pUserData, QUERYACCEPTPROC pQueryAccept, LPCRITICAL_SECTION pCritSec, OutputPin * pPinImpl); + +/* Common */ +HRESULT WINAPI IPinImpl_ConnectedTo(IPin * iface, IPin ** ppPin); +HRESULT WINAPI IPinImpl_ConnectionMediaType(IPin * iface, AM_MEDIA_TYPE * pmt); +HRESULT WINAPI IPinImpl_QueryPinInfo(IPin * iface, PIN_INFO * pInfo); +HRESULT WINAPI IPinImpl_QueryDirection(IPin * iface, PIN_DIRECTION * pPinDir); +HRESULT WINAPI IPinImpl_QueryId(IPin * iface, LPWSTR * Id); +HRESULT WINAPI IPinImpl_QueryAccept(IPin * iface, const AM_MEDIA_TYPE * pmt); +HRESULT WINAPI IPinImpl_EnumMediaTypes(IPin * iface, IEnumMediaTypes ** ppEnum); +HRESULT WINAPI IPinImpl_QueryInternalConnections(IPin * iface, IPin ** apPin, ULONG * cPin); + +/* Output Pin */ +HRESULT WINAPI OutputPin_Connect(IPin * iface, IPin * pReceivePin, const AM_MEDIA_TYPE * pmt); +HRESULT WINAPI OutputPin_Disconnect(IPin * iface); +HRESULT WINAPI OutputPin_ReceiveConnection(IPin * iface, IPin * pReceivePin, const AM_MEDIA_TYPE * pmt); + +HRESULT OutputPin_GetDeliveryBuffer(OutputPin * This, IMediaSample ** ppSample, const REFERENCE_TIME * tStart, const REFERENCE_TIME * tStop, DWORD dwFlags); +HRESULT OutputPin_SendSample(OutputPin * This, IMediaSample * pSample); + diff -Nru wine-old/dlls/qcap/qcap_main.c wine-new/dlls/qcap/qcap_main.c --- wine-old/dlls/qcap/qcap_main.c 2004-05-21 22:54:48.000000000 +0200 +++ wine-new/dlls/qcap/qcap_main.c 2005-05-01 01:53:20.000000000 +0200 @@ -1,7 +1,10 @@ -/* - * Qcap implementation +/* DirectShow Capture Base Functions (QCAP.DLL) * - * Copyright (C) 2003 Dominik Strasser + * Copyright 2002 Lionel Ulmer + * Copyright 2005 Maarten Lankhorst + * + * This file contains the (internal) driver registration functions, + * driver enumeration APIs and DirectDraw creation functions. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -18,26 +21,206 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
+#include "config.h" #include "wine/debug.h" -#include "winerror.h"
+#include "qcap_private.h"
WINE_DEFAULT_DEBUG_CHANNEL(qcap);
+static DWORD dll_ref = 0; + +/* For the moment, do nothing here. */ +BOOL WINAPI DllMain(HINSTANCE hInstDLL, DWORD fdwReason, LPVOID lpv) +{ + switch(fdwReason) { + case DLL_PROCESS_ATTACH: + DisableThreadLibraryCalls(hInstDLL); + break; + case DLL_PROCESS_DETACH: + break; + } + return TRUE; +} + +/****************************************************************************** + * DirectShow ClassFactory + */ +typedef struct { + IClassFactory ITF_IClassFactory; + + DWORD ref; + HRESULT (*pfnCreateInstance)(IUnknown *pUnkOuter, LPVOID *ppObj); +} IClassFactoryImpl; + +struct object_creation_info +{ + const CLSID *clsid; + HRESULT (*pfnCreateInstance)(IUnknown *pUnkOuter, LPVOID *ppObj); +}; + +static const struct object_creation_info object_creation[] = +{ + { &CLSID_VfwCapture, &VfwCapture_create }, + { &CLSID_CaptureGraphBuilder, &CaptureGraphBuilder_create } +}; + +static HRESULT WINAPI +DSCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj) +{ + IClassFactoryImpl *This = (IClassFactoryImpl *)iface; + + if (IsEqualGUID(riid, &IID_IUnknown) + || IsEqualGUID(riid, &IID_IClassFactory)) + { + IClassFactory_AddRef(iface); + *ppobj = This; + return S_OK; + } + + WARN("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppobj); + return E_NOINTERFACE; +} + +static ULONG WINAPI DSCF_AddRef(LPCLASSFACTORY iface) +{ + IClassFactoryImpl *This = (IClassFactoryImpl *)iface; + return InterlockedIncrement(&This->ref); +} + +static ULONG WINAPI DSCF_Release(LPCLASSFACTORY iface) +{ + IClassFactoryImpl *This = (IClassFactoryImpl *)iface; + + ULONG ref = InterlockedDecrement(&This->ref); + + if (ref == 0) + HeapFree(GetProcessHeap(), 0, This); + + return ref; +} + + +static HRESULT WINAPI DSCF_CreateInstance(LPCLASSFACTORY iface, LPUNKNOWN pOuter, + REFIID riid, LPVOID *ppobj) +{ + IClassFactoryImpl *This = (IClassFactoryImpl *)iface; + HRESULT hres; + LPUNKNOWN punk; + + TRACE("(%p)->(%p,%s,%p)\n",This,pOuter,debugstr_guid(riid),ppobj); + + *ppobj = NULL; + hres = This->pfnCreateInstance(pOuter, (LPVOID *) &punk); + if (SUCCEEDED(hres)) { + hres = IUnknown_QueryInterface(punk, riid, ppobj); + IUnknown_Release(punk); + } + return hres; +} + +static HRESULT WINAPI DSCF_LockServer(LPCLASSFACTORY iface,BOOL dolock) +{ + IClassFactoryImpl *This = (IClassFactoryImpl *)iface; + FIXME("(%p)->(%d),stub!\n",This,dolock); + return S_OK; +} + +static IClassFactoryVtbl DSCF_Vtbl = +{ + DSCF_QueryInterface, + DSCF_AddRef, + DSCF_Release, + DSCF_CreateInstance, + DSCF_LockServer +}; + +/******************************************************************************* + * DllGetClassObject [QCAP.@] + * Retrieves class object from a DLL object + * + * NOTES + * Docs say returns STDAPI + * + * PARAMS + * rclsid [I] CLSID for the class object + * riid [I] Reference to identifier of interface for class object + * ppv [O] Address of variable to receive interface pointer for riid + * + * RETURNS + * Success: S_OK + * Failure: CLASS_E_CLASSNOTAVAILABLE, E_OUTOFMEMORY, E_INVALIDARG, + * E_UNEXPECTED + */ +DWORD WINAPI QCAP_DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv) +{ + unsigned int i; + IClassFactoryImpl *factory; + + TRACE("(%s,%s,%p)\n", debugstr_guid(rclsid), debugstr_guid(riid), ppv); + + if ( !IsEqualGUID( &IID_IClassFactory, riid ) + && ! IsEqualGUID( &IID_IUnknown, riid) ) + return E_NOINTERFACE; + + for (i=0; i < sizeof(object_creation)/sizeof(object_creation[0]); i++) + { + if (IsEqualGUID(object_creation[i].clsid, rclsid)) + break; + } + + if (i == sizeof(object_creation)/sizeof(object_creation[0])) + { + FIXME("%s: no class found.\n", debugstr_guid(rclsid)); + return CLASS_E_CLASSNOTAVAILABLE; + } + + factory = HeapAlloc(GetProcessHeap(), 0, sizeof(*factory)); + if (factory == NULL) return E_OUTOFMEMORY; + + factory->ITF_IClassFactory.lpVtbl = &DSCF_Vtbl; + factory->ref = 1; + + factory->pfnCreateInstance = object_creation[i].pfnCreateInstance; + + *ppv = &(factory->ITF_IClassFactory); + return S_OK; +} + /*********************************************************************** - * DllRegisterServer (QCAP.@) + * DllCanUnloadNow (QCAP.@) */ -HRESULT WINAPI QCAP_DllRegisterServer() +HRESULT WINAPI QCAP_DllCanUnloadNow() { - FIXME("(): stub\n"); - return 0; + return dll_ref != 0 ? S_FALSE : S_OK; }
+ +#define OUR_GUID_ENTRY(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \ + { { l, w1, w2, { b1, b2, b3, b4, b5, b6, b7, b8 } } , #name }, + +static struct { + const GUID riid; + const char *name; +} InterfaceDesc[] = +{ +#include "uuids.h" + { { 0, 0, 0, {0, 0, 0, 0, 0, 0, 0, 0} }, NULL } +}; + /*********************************************************************** - * DllGetClassObject (QCAP.@) + * qcdebugstr_guid (internal) + * + * Gives a text version of QCap Guids */ -HRESULT WINAPI QCAP_DllGetClassObject(REFCLSID rclsid, REFIID iid, LPVOID *ppv) +const char * qcdebugstr_guid( const GUID * id ) { - FIXME("\n\tCLSID:\t%s,\n\tIID:\t%s\n",debugstr_guid(rclsid),debugstr_guid(iid)); - return CLASS_E_CLASSNOTAVAILABLE; + int i; + char * name = NULL; + + for (i=0;InterfaceDesc[i].name && !name;i++) { + if (IsEqualGUID(&InterfaceDesc[i].riid, id)) return InterfaceDesc[i].name; + } + return debugstr_guid(id); } + diff -Nru wine-old/dlls/qcap/qcap_private.h wine-new/dlls/qcap/qcap_private.h --- wine-old/dlls/qcap/qcap_private.h 1970-01-01 01:00:00.000000000 +0100 +++ wine-new/dlls/qcap/qcap_private.h 2005-04-29 00:27:34.000000000 +0200 @@ -0,0 +1,64 @@ +/* Quartz Capture private interfaces (QCAP.DLL) + * + * Copyright 2005 Maarten Lankhorst + * + * This file contains the (internal) driver registration functions, + * driver enumeration APIs and DirectDraw creation functions. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#ifndef __QCAP_PRIVATE_INCLUDED__ +#define __QCAP_PRIVATE_INCLUDED__ + +#include <stdarg.h> + +#define COBJMACROS + +#include "windef.h" +#include "winbase.h" +#include "wtypes.h" +#include "wingdi.h" +#include "winuser.h" +#include "dshow.h" + +#define ICOM_THIS_MULTI(impl,field,iface) impl* const This=(impl*)((char*)(iface) - offsetof(impl,field)) + +HRESULT VfwCapture_create(IUnknown * pUnkOuter, LPVOID * ppv); +HRESULT CaptureGraphBuilder_create(IUnknown * pUnkOuter, LPVOID * ppv); + +typedef struct tagENUMPINDETAILS +{ + ULONG cPins; + IPin ** ppPins; +} ENUMPINDETAILS; + +typedef struct tagENUMEDIADETAILS +{ + ULONG cMediaTypes; + AM_MEDIA_TYPE * pMediaTypes; +} ENUMMEDIADETAILS; + +HRESULT IEnumPinsImpl_Construct(const ENUMPINDETAILS * pDetails, IEnumPins ** ppEnum); +HRESULT IEnumMediaTypesImpl_Construct(const ENUMMEDIADETAILS * pDetails, IEnumMediaTypes ** ppEnum); + +extern const char * qcdebugstr_guid(const GUID * id); + +HRESULT CopyMediaType(AM_MEDIA_TYPE * pDest, const AM_MEDIA_TYPE *pSrc); +void DeleteMediaType(AM_MEDIA_TYPE * pmt); +BOOL CompareMediaTypes(const AM_MEDIA_TYPE * pmt1, const AM_MEDIA_TYPE * pmt2, BOOL bWildcards); +void dump_AM_MEDIA_TYPE(const AM_MEDIA_TYPE * pmt); + +#endif /* __QCAP_PRIVATE_INCLUDED__ */ diff -Nru wine-old/dlls/qcap/qcap.spec wine-new/dlls/qcap/qcap.spec --- wine-old/dlls/qcap/qcap.spec 2003-07-30 05:48:55.000000000 +0200 +++ wine-new/dlls/qcap/qcap.spec 2005-04-28 23:07:08.000000000 +0200 @@ -1,4 +1,4 @@ -@ stub DllCanUnloadNow +@ stdcall -private DllCanUnloadNow() QCAP_DllCanUnloadNow @ stdcall -private DllGetClassObject(ptr ptr ptr) QCAP_DllGetClassObject @ stdcall -private DllRegisterServer() QCAP_DllRegisterServer -@ stub DllUnregisterServer +@ stdcall -private DllUnregisterServer() QCAP_DllUnregisterServer diff -Nru wine-old/dlls/qcap/regsvr.c wine-new/dlls/qcap/regsvr.c --- wine-old/dlls/qcap/regsvr.c 1970-01-01 01:00:00.000000000 +0100 +++ wine-new/dlls/qcap/regsvr.c 2005-04-29 00:28:39.000000000 +0200 @@ -0,0 +1,940 @@ +/* + * self-registerable dll functions for qcap.dll + * + * Copyright (C) 2003 John K. Hohm + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#define NONAMELESSUNION +#define NONAMELESSSTRUCT +#define COBJMACROS +#define COM_NO_WINDOWS_H +#include <stdarg.h> +#include <string.h> + +#include "windef.h" +#include "winbase.h" +#include "winuser.h" +#include "winreg.h" +#include "winerror.h" + +#include "ole2.h" +#include "uuids.h" +#include "strmif.h" + +#include "wine/debug.h" + +WINE_DEFAULT_DEBUG_CHANNEL(qcap); + +/* + * Near the bottom of this file are the exported DllRegisterServer and + * DllUnregisterServer, which make all this worthwhile. + */ + +/*********************************************************************** + * interface for self-registering + */ +struct regsvr_interface +{ + IID const *iid; /* NULL for end of list */ + LPCSTR name; /* can be NULL to omit */ + IID const *base_iid; /* can be NULL to omit */ + int num_methods; /* can be <0 to omit */ + CLSID const *ps_clsid; /* can be NULL to omit */ + CLSID const *ps_clsid32; /* can be NULL to omit */ +}; + +static HRESULT register_interfaces(struct regsvr_interface const *list); +static HRESULT unregister_interfaces(struct regsvr_interface const *list); + +struct regsvr_coclass +{ + CLSID const *clsid; /* NULL for end of list */ + LPCSTR name; /* can be NULL to omit */ + LPCSTR ips; /* can be NULL to omit */ + LPCSTR ips32; /* can be NULL to omit */ + LPCSTR ips32_tmodel; /* can be NULL to omit */ + LPCSTR progid; /* can be NULL to omit */ + LPCSTR viprogid; /* can be NULL to omit */ + LPCSTR progid_extra; /* can be NULL to omit */ +}; + +static HRESULT register_coclasses(struct regsvr_coclass const *list); +static HRESULT unregister_coclasses(struct regsvr_coclass const *list); + +struct regsvr_mediatype_parsing +{ + CLSID const *majortype; /* NULL for end of list */ + CLSID const *subtype; + LPCSTR line[11]; /* NULL for end of list */ +}; + +static HRESULT register_mediatypes_parsing(struct regsvr_mediatype_parsing const *list); +static HRESULT unregister_mediatypes_parsing(struct regsvr_mediatype_parsing const *list); + +struct regsvr_mediatype_extension +{ + CLSID const *majortype; /* NULL for end of list */ + CLSID const *subtype; + LPCSTR extension; +}; + +struct mediatype +{ + CLSID const *majortype; /* NULL for end of list */ + CLSID const *subtype; + DWORD fourcc; +}; + +struct pin +{ + DWORD flags; /* 0xFFFFFFFF for end of list */ + struct mediatype mediatypes[11]; +}; + +struct regsvr_filter +{ + CLSID const *clsid; /* NULL for end of list */ + CLSID const *category; + WCHAR name[50]; + DWORD merit; + struct pin pins[11]; +}; + +static HRESULT register_mediatypes_extension(struct regsvr_mediatype_extension const *list); +static HRESULT unregister_mediatypes_extension(struct regsvr_mediatype_extension const *list); + +static HRESULT register_filters(struct regsvr_filter const *list); +static HRESULT unregister_filters(struct regsvr_filter const *list); + +/*********************************************************************** + * static string constants + */ +static WCHAR const interface_keyname[10] = { + 'I', 'n', 't', 'e', 'r', 'f', 'a', 'c', 'e', 0 }; +static WCHAR const base_ifa_keyname[14] = { + 'B', 'a', 's', 'e', 'I', 'n', 't', 'e', 'r', 'f', 'a', 'c', + 'e', 0 }; +static WCHAR const num_methods_keyname[11] = { + 'N', 'u', 'm', 'M', 'e', 't', 'h', 'o', 'd', 's', 0 }; +static WCHAR const ps_clsid_keyname[15] = { + 'P', 'r', 'o', 'x', 'y', 'S', 't', 'u', 'b', 'C', 'l', 's', + 'i', 'd', 0 }; +static WCHAR const ps_clsid32_keyname[17] = { + 'P', 'r', 'o', 'x', 'y', 'S', 't', 'u', 'b', 'C', 'l', 's', + 'i', 'd', '3', '2', 0 }; +static WCHAR const clsid_keyname[6] = { + 'C', 'L', 'S', 'I', 'D', 0 }; +static WCHAR const curver_keyname[7] = { + 'C', 'u', 'r', 'V', 'e', 'r', 0 }; +static WCHAR const ips_keyname[13] = { + 'I', 'n', 'P', 'r', 'o', 'c', 'S', 'e', 'r', 'v', 'e', 'r', + 0 }; +static WCHAR const ips32_keyname[15] = { + 'I', 'n', 'P', 'r', 'o', 'c', 'S', 'e', 'r', 'v', 'e', 'r', + '3', '2', 0 }; +static WCHAR const progid_keyname[7] = { + 'P', 'r', 'o', 'g', 'I', 'D', 0 }; +static WCHAR const viprogid_keyname[25] = { + 'V', 'e', 'r', 's', 'i', 'o', 'n', 'I', 'n', 'd', 'e', 'p', + 'e', 'n', 'd', 'e', 'n', 't', 'P', 'r', 'o', 'g', 'I', 'D', + 0 }; +static char const tmodel_valuename[] = "ThreadingModel"; +static WCHAR const mediatype_name[11] = { + 'M', 'e', 'd', 'i', 'a', ' ', 'T', 'y', 'p', 'e', 0 }; +static WCHAR const subtype_valuename[8] = { + 'S', 'u', 'b', 't', 'y', 'p', 'e', 0 }; +static WCHAR const sourcefilter_valuename[14] = { + 'S', 'o', 'u', 'r', 'c', 'e', ' ', 'F', 'i', 'l', 't', 'e', 'r', 0 }; +static WCHAR const extensions_keyname[11] = { + 'E', 'x', 't', 'e', 'n', 's', 'i', 'o', 'n', 's', 0 }; + +/*********************************************************************** + * static helper functions + */ +static LONG register_key_guid(HKEY base, WCHAR const *name, GUID const *guid); +static LONG register_key_defvalueW(HKEY base, WCHAR const *name, + WCHAR const *value); +static LONG register_key_defvalueA(HKEY base, WCHAR const *name, + char const *value); +static LONG register_progid(WCHAR const *clsid, + char const *progid, char const *curver_progid, + char const *name, char const *extra); +static LONG recursive_delete_key(HKEY key); +static LONG recursive_delete_keyA(HKEY base, char const *name); +static LONG recursive_delete_keyW(HKEY base, WCHAR const *name); + +/*********************************************************************** + * register_interfaces + */ +static HRESULT register_interfaces(struct regsvr_interface const *list) +{ + LONG res = ERROR_SUCCESS; + HKEY interface_key; + + res = RegCreateKeyExW(HKEY_CLASSES_ROOT, interface_keyname, 0, NULL, 0, + KEY_READ | KEY_WRITE, NULL, &interface_key, NULL); + if (res != ERROR_SUCCESS) goto error_return; + + for (; res == ERROR_SUCCESS && list->iid; ++list) { + WCHAR buf[39]; + HKEY iid_key; + + StringFromGUID2(list->iid, buf, 39); + res = RegCreateKeyExW(interface_key, buf, 0, NULL, 0, + KEY_READ | KEY_WRITE, NULL, &iid_key, NULL); + if (res != ERROR_SUCCESS) goto error_close_interface_key; + + if (list->name) { + res = RegSetValueExA(iid_key, NULL, 0, REG_SZ, + (CONST BYTE*)(list->name), + strlen(list->name) + 1); + if (res != ERROR_SUCCESS) goto error_close_iid_key; + } + + if (list->base_iid) { + register_key_guid(iid_key, base_ifa_keyname, list->base_iid); + if (res != ERROR_SUCCESS) goto error_close_iid_key; + } + + if (0 <= list->num_methods) { + static WCHAR const fmt[3] = { '%', 'd', 0 }; + HKEY key; + + res = RegCreateKeyExW(iid_key, num_methods_keyname, 0, NULL, 0, + KEY_READ | KEY_WRITE, NULL, &key, NULL); + if (res != ERROR_SUCCESS) goto error_close_iid_key; + + wsprintfW(buf, fmt, list->num_methods); + res = RegSetValueExW(key, NULL, 0, REG_SZ, + (CONST BYTE*)buf, + (lstrlenW(buf) + 1) * sizeof(WCHAR)); + RegCloseKey(key); + + if (res != ERROR_SUCCESS) goto error_close_iid_key; + } + + if (list->ps_clsid) { + register_key_guid(iid_key, ps_clsid_keyname, list->ps_clsid); + if (res != ERROR_SUCCESS) goto error_close_iid_key; + } + + if (list->ps_clsid32) { + register_key_guid(iid_key, ps_clsid32_keyname, list->ps_clsid32); + if (res != ERROR_SUCCESS) goto error_close_iid_key; + } + + error_close_iid_key: + RegCloseKey(iid_key); + } + +error_close_interface_key: + RegCloseKey(interface_key); +error_return: + return res != ERROR_SUCCESS ? HRESULT_FROM_WIN32(res) : S_OK; +} + +/*********************************************************************** + * unregister_interfaces + */ +static HRESULT unregister_interfaces(struct regsvr_interface const *list) +{ + LONG res = ERROR_SUCCESS; + HKEY interface_key; + + res = RegOpenKeyExW(HKEY_CLASSES_ROOT, interface_keyname, 0, + KEY_READ | KEY_WRITE, &interface_key); + if (res == ERROR_FILE_NOT_FOUND) return S_OK; + if (res != ERROR_SUCCESS) goto error_return; + + for (; res == ERROR_SUCCESS && list->iid; ++list) { + WCHAR buf[39]; + + StringFromGUID2(list->iid, buf, 39); + res = recursive_delete_keyW(interface_key, buf); + } + + RegCloseKey(interface_key); +error_return: + return res != ERROR_SUCCESS ? HRESULT_FROM_WIN32(res) : S_OK; +} + +/*********************************************************************** + * register_coclasses + */ +static HRESULT register_coclasses(struct regsvr_coclass const *list) +{ + LONG res = ERROR_SUCCESS; + HKEY coclass_key; + + res = RegCreateKeyExW(HKEY_CLASSES_ROOT, clsid_keyname, 0, NULL, 0, + KEY_READ | KEY_WRITE, NULL, &coclass_key, NULL); + if (res != ERROR_SUCCESS) goto error_return; + + for (; res == ERROR_SUCCESS && list->clsid; ++list) { + WCHAR buf[39]; + HKEY clsid_key; + + StringFromGUID2(list->clsid, buf, 39); + res = RegCreateKeyExW(coclass_key, buf, 0, NULL, 0, + KEY_READ | KEY_WRITE, NULL, &clsid_key, NULL); + if (res != ERROR_SUCCESS) goto error_close_coclass_key; + + if (list->name) { + res = RegSetValueExA(clsid_key, NULL, 0, REG_SZ, + (CONST BYTE*)(list->name), + strlen(list->name) + 1); + if (res != ERROR_SUCCESS) goto error_close_clsid_key; + } + + if (list->ips) { + res = register_key_defvalueA(clsid_key, ips_keyname, list->ips); + if (res != ERROR_SUCCESS) goto error_close_clsid_key; + } + + if (list->ips32) { + HKEY ips32_key; + + res = RegCreateKeyExW(clsid_key, ips32_keyname, 0, NULL, 0, + KEY_READ | KEY_WRITE, NULL, + &ips32_key, NULL); + if (res != ERROR_SUCCESS) goto error_close_clsid_key; + + res = RegSetValueExA(ips32_key, NULL, 0, REG_SZ, + (CONST BYTE*)list->ips32, + lstrlenA(list->ips32) + 1); + if (res == ERROR_SUCCESS && list->ips32_tmodel) + res = RegSetValueExA(ips32_key, tmodel_valuename, 0, REG_SZ, + (CONST BYTE*)list->ips32_tmodel, + strlen(list->ips32_tmodel) + 1); + RegCloseKey(ips32_key); + if (res != ERROR_SUCCESS) goto error_close_clsid_key; + } + + if (list->progid) { + res = register_key_defvalueA(clsid_key, progid_keyname, + list->progid); + if (res != ERROR_SUCCESS) goto error_close_clsid_key; + + res = register_progid(buf, list->progid, NULL, + list->name, list->progid_extra); + if (res != ERROR_SUCCESS) goto error_close_clsid_key; + } + + if (list->viprogid) { + res = register_key_defvalueA(clsid_key, viprogid_keyname, + list->viprogid); + if (res != ERROR_SUCCESS) goto error_close_clsid_key; + + res = register_progid(buf, list->viprogid, list->progid, + list->name, list->progid_extra); + if (res != ERROR_SUCCESS) goto error_close_clsid_key; + } + + error_close_clsid_key: + RegCloseKey(clsid_key); + } + +error_close_coclass_key: + RegCloseKey(coclass_key); +error_return: + return res != ERROR_SUCCESS ? HRESULT_FROM_WIN32(res) : S_OK; +} + +/*********************************************************************** + * unregister_coclasses + */ +static HRESULT unregister_coclasses(struct regsvr_coclass const *list) +{ + LONG res = ERROR_SUCCESS; + HKEY coclass_key; + + res = RegOpenKeyExW(HKEY_CLASSES_ROOT, clsid_keyname, 0, + KEY_READ | KEY_WRITE, &coclass_key); + if (res == ERROR_FILE_NOT_FOUND) return S_OK; + if (res != ERROR_SUCCESS) goto error_return; + + for (; res == ERROR_SUCCESS && list->clsid; ++list) { + WCHAR buf[39]; + + StringFromGUID2(list->clsid, buf, 39); + res = recursive_delete_keyW(coclass_key, buf); + if (res != ERROR_SUCCESS) goto error_close_coclass_key; + + if (list->progid) { + res = recursive_delete_keyA(HKEY_CLASSES_ROOT, list->progid); + if (res != ERROR_SUCCESS) goto error_close_coclass_key; + } + + if (list->viprogid) { + res = recursive_delete_keyA(HKEY_CLASSES_ROOT, list->viprogid); + if (res != ERROR_SUCCESS) goto error_close_coclass_key; + } + } + +error_close_coclass_key: + RegCloseKey(coclass_key); +error_return: + return res != ERROR_SUCCESS ? HRESULT_FROM_WIN32(res) : S_OK; +} + +/*********************************************************************** + * register_mediatypes_parsing + */ +static HRESULT register_mediatypes_parsing(struct regsvr_mediatype_parsing const *list) +{ + LONG res = ERROR_SUCCESS; + HKEY mediatype_key; + WCHAR buf[39]; + int i; + + res = RegCreateKeyExW(HKEY_CLASSES_ROOT, mediatype_name, 0, NULL, 0, + KEY_READ | KEY_WRITE, NULL, &mediatype_key, NULL); + if (res != ERROR_SUCCESS) return HRESULT_FROM_WIN32(res); + + for (; res == ERROR_SUCCESS && list->majortype; ++list) { + HKEY majortype_key = NULL; + HKEY subtype_key = NULL; + + StringFromGUID2(list->majortype, buf, 39); + res = RegCreateKeyExW(mediatype_key, buf, 0, NULL, 0, + KEY_READ | KEY_WRITE, NULL, &majortype_key, NULL); + if (res != ERROR_SUCCESS) goto error_close_keys; + + StringFromGUID2(list->subtype, buf, 39); + res = RegCreateKeyExW(majortype_key, buf, 0, NULL, 0, + KEY_READ | KEY_WRITE, NULL, &subtype_key, NULL); + if (res != ERROR_SUCCESS) goto error_close_keys; + + StringFromGUID2(&CLSID_AsyncReader, buf, 39); + res = RegSetValueExW(subtype_key, sourcefilter_valuename, 0, REG_SZ, (CONST BYTE*)buf, + (lstrlenW(buf) + 1) * sizeof(WCHAR)); + if (res != ERROR_SUCCESS) goto error_close_keys; + + for(i = 0; list->line[i]; i++) { + char buffer[3]; + wsprintfA(buffer, "%d", i); + res = RegSetValueExA(subtype_key, buffer, 0, REG_SZ, (CONST BYTE*)list->line[i], + lstrlenA(list->line[i])); + if (res != ERROR_SUCCESS) goto error_close_keys; + } + +error_close_keys: + if (majortype_key) + RegCloseKey(majortype_key); + if (subtype_key) + RegCloseKey(subtype_key); + } + + RegCloseKey(mediatype_key); + + return res != ERROR_SUCCESS ? HRESULT_FROM_WIN32(res) : S_OK; +} + +/*********************************************************************** + * register_mediatypes_extension + */ +static HRESULT register_mediatypes_extension(struct regsvr_mediatype_extension const *list) +{ + LONG res = ERROR_SUCCESS; + HKEY mediatype_key; + HKEY extensions_root_key = NULL; + WCHAR buf[39]; + + res = RegCreateKeyExW(HKEY_CLASSES_ROOT, mediatype_name, 0, NULL, 0, + KEY_READ | KEY_WRITE, NULL, &mediatype_key, NULL); + if (res != ERROR_SUCCESS) return HRESULT_FROM_WIN32(res); + + res = RegCreateKeyExW(mediatype_key, extensions_keyname, 0, NULL, 0, + KEY_READ | KEY_WRITE, NULL, &extensions_root_key, NULL); + if (res != ERROR_SUCCESS) goto error_return; + + for (; res == ERROR_SUCCESS && list->majortype; ++list) { + HKEY extension_key; + + res = RegCreateKeyExA(extensions_root_key, list->extension, 0, NULL, 0, + KEY_READ | KEY_WRITE, NULL, &extension_key, NULL); + if (res != ERROR_SUCCESS) break; + + StringFromGUID2(list->majortype, buf, 39); + res = RegSetValueExW(extension_key, mediatype_name, 0, REG_SZ, (CONST BYTE*)buf, + (lstrlenW(buf) + 1) * sizeof(WCHAR)); + if (res != ERROR_SUCCESS) goto error_close_key; + + StringFromGUID2(list->subtype, buf, 39); + res = RegSetValueExW(extension_key, subtype_valuename, 0, REG_SZ, (CONST BYTE*)buf, + (lstrlenW(buf) + 1) * sizeof(WCHAR)); + if (res != ERROR_SUCCESS) goto error_close_key; + + StringFromGUID2(&CLSID_AsyncReader, buf, 39); + res = RegSetValueExW(extension_key, sourcefilter_valuename, 0, REG_SZ, (CONST BYTE*)buf, + (lstrlenW(buf) + 1) * sizeof(WCHAR)); + if (res != ERROR_SUCCESS) goto error_close_key; + +error_close_key: + RegCloseKey(extension_key); + } + +error_return: + RegCloseKey(mediatype_key); + if (extensions_root_key) + RegCloseKey(extensions_root_key); + + return res != ERROR_SUCCESS ? HRESULT_FROM_WIN32(res) : S_OK; +} + +/*********************************************************************** + * unregister_mediatypes_parsing + */ +static HRESULT unregister_mediatypes_parsing(struct regsvr_mediatype_parsing const *list) +{ + LONG res; + HKEY mediatype_key; + HKEY majortype_key; + WCHAR buf[39]; + + res = RegOpenKeyExW(HKEY_CLASSES_ROOT, mediatype_name, 0, + KEY_READ | KEY_WRITE, &mediatype_key); + if (res == ERROR_FILE_NOT_FOUND) return S_OK; + if (res != ERROR_SUCCESS) return HRESULT_FROM_WIN32(res); + + for (; res == ERROR_SUCCESS && list->majortype; ++list) { + StringFromGUID2(list->majortype, buf, 39); + res = RegOpenKeyExW(mediatype_key, buf, 0, + KEY_READ | KEY_WRITE, &majortype_key); + if (res == ERROR_FILE_NOT_FOUND) { + res = ERROR_SUCCESS; + continue; + } + if (res != ERROR_SUCCESS) break; + + StringFromGUID2(list->subtype, buf, 39); + res = recursive_delete_keyW(majortype_key, buf); + if (res == ERROR_FILE_NOT_FOUND) res = ERROR_SUCCESS; + + /* Removed majortype key if there is no more subtype key */ + res = RegDeleteKeyW(majortype_key, 0); + if (res == ERROR_ACCESS_DENIED) res = ERROR_SUCCESS; + + RegCloseKey(majortype_key); + } + + RegCloseKey(mediatype_key); + + return res != ERROR_SUCCESS ? HRESULT_FROM_WIN32(res) : S_OK; +} + +/*********************************************************************** + * unregister_mediatypes_extension + */ +static HRESULT unregister_mediatypes_extension(struct regsvr_mediatype_extension const *list) +{ + LONG res; + HKEY mediatype_key; + HKEY extensions_root_key = NULL; + + res = RegOpenKeyExW(HKEY_CLASSES_ROOT, mediatype_name, 0, + KEY_READ | KEY_WRITE, &mediatype_key); + if (res == ERROR_FILE_NOT_FOUND) return S_OK; + if (res != ERROR_SUCCESS) return HRESULT_FROM_WIN32(res); + + res = RegOpenKeyExW(mediatype_key, extensions_keyname, 0, + KEY_READ | KEY_WRITE, &extensions_root_key); + if (res == ERROR_FILE_NOT_FOUND) + res = ERROR_SUCCESS; + else if (res == ERROR_SUCCESS) + for (; res == ERROR_SUCCESS && list->majortype; ++list) { + res = recursive_delete_keyA(extensions_root_key, list->extension); + if (res == ERROR_FILE_NOT_FOUND) res = ERROR_SUCCESS; + } + + RegCloseKey(mediatype_key); + if (extensions_root_key) + RegCloseKey(extensions_root_key); + + return res != ERROR_SUCCESS ? HRESULT_FROM_WIN32(res) : S_OK; +} + +/*********************************************************************** + * register_filters + */ +static HRESULT register_filters(struct regsvr_filter const *list) +{ + HRESULT hr; + IFilterMapper2* pFM2 = NULL; + + CoInitialize(NULL); + hr = CoCreateInstance(&CLSID_FilterMapper2, NULL, CLSCTX_INPROC_SERVER, &IID_IFilterMapper2, (LPVOID*)&pFM2); + + if (SUCCEEDED(hr)) { + for (; SUCCEEDED(hr) && list->clsid; ++list) { + REGFILTER2 rf2; + REGFILTERPINS2* prfp2; + int i; + + for (i = 0; list->pins[i].flags != 0xFFFFFFFF; i++) ; + rf2.dwVersion = 2; + rf2.dwMerit = list->merit; + rf2.u.s1.cPins2 = i; + rf2.u.s1.rgPins2 = prfp2 = (REGFILTERPINS2*) CoTaskMemAlloc(i*sizeof(REGFILTERPINS2)); + if (!prfp2) { + hr = E_OUTOFMEMORY; + break; + } + for (i = 0; list->pins[i].flags != 0xFFFFFFFF; i++) { + REGPINTYPES* lpMediatype; + CLSID* lpClsid; + int j, nbmt; + + for (nbmt = 0; list->pins[i].mediatypes[nbmt].majortype; nbmt++) ; + /* Allocate a single buffer for regpintypes struct and clsids */ + lpMediatype = (REGPINTYPES*) CoTaskMemAlloc(nbmt*(sizeof(REGPINTYPES) + 2*sizeof(CLSID))); + if (!lpMediatype) { + hr = E_OUTOFMEMORY; + break; + } + lpClsid = (CLSID*) (lpMediatype + nbmt); + for (j = 0; j < nbmt; j++) { + (lpMediatype + j)->clsMajorType = lpClsid + j*2; + memcpy(lpClsid + j*2, list->pins[i].mediatypes[j].majortype, sizeof(CLSID)); + (lpMediatype + j)->clsMinorType = lpClsid + j*2 + 1; + if (list->pins[i].mediatypes[j].subtype) + memcpy(lpClsid + j*2 + 1, list->pins[i].mediatypes[j].subtype, sizeof(CLSID)); + else { + /* Subtype are often a combination of major type + fourcc/tag */ + memcpy(lpClsid + j*2 + 1, list->pins[i].mediatypes[j].majortype, sizeof(CLSID)); + *(DWORD*)(lpClsid + j*2 + 1) = list->pins[i].mediatypes[j].fourcc; + } + } + prfp2[i].dwFlags = list->pins[i].flags; + prfp2[i].cInstances = 0; + prfp2[i].nMediaTypes = j; + prfp2[i].lpMediaType = lpMediatype; + prfp2[i].nMediums = 0; + prfp2[i].lpMedium = NULL; + prfp2[i].clsPinCategory = NULL; + } + + if (FAILED(hr)) { + ERR("failed to register with hresult 0x%lx\n", hr); + CoTaskMemFree(prfp2); + break; + } + + hr = IFilterMapper2_RegisterFilter(pFM2, list->clsid, list->name, NULL, list->category, NULL, &rf2); + + while (i) { + CoTaskMemFree((REGPINTYPES*)prfp2[i-1].lpMediaType); + i--; + } + CoTaskMemFree(prfp2); + } + } + + if (pFM2) + IFilterMapper2_Release(pFM2); + + CoUninitialize(); + + return hr; +} + +/*********************************************************************** + * unregister_filters + */ +static HRESULT unregister_filters(struct regsvr_filter const *list) +{ + HRESULT hr; + IFilterMapper2* pFM2; + + CoInitialize(NULL); + + hr = CoCreateInstance(&CLSID_FilterMapper2, NULL, CLSCTX_INPROC_SERVER, &IID_IFilterMapper2, (LPVOID*)&pFM2); + + if (SUCCEEDED(hr)) { + for (; SUCCEEDED(hr) && list->clsid; ++list) + hr = IFilterMapper2_UnregisterFilter(pFM2, list->category, NULL, list->clsid); + IFilterMapper2_Release(pFM2); + } + + CoUninitialize(); + + return hr; +} + +/*********************************************************************** + * regsvr_key_guid + */ +static LONG register_key_guid(HKEY base, WCHAR const *name, GUID const *guid) +{ + WCHAR buf[39]; + + StringFromGUID2(guid, buf, 39); + return register_key_defvalueW(base, name, buf); +} + +/*********************************************************************** + * regsvr_key_defvalueW + */ +static LONG register_key_defvalueW( + HKEY base, + WCHAR const *name, + WCHAR const *value) +{ + LONG res; + HKEY key; + + res = RegCreateKeyExW(base, name, 0, NULL, 0, + KEY_READ | KEY_WRITE, NULL, &key, NULL); + if (res != ERROR_SUCCESS) return res; + res = RegSetValueExW(key, NULL, 0, REG_SZ, (CONST BYTE*)value, + (lstrlenW(value) + 1) * sizeof(WCHAR)); + RegCloseKey(key); + return res; +} + +/*********************************************************************** + * regsvr_key_defvalueA + */ +static LONG register_key_defvalueA( + HKEY base, + WCHAR const *name, + char const *value) +{ + LONG res; + HKEY key; + + res = RegCreateKeyExW(base, name, 0, NULL, 0, + KEY_READ | KEY_WRITE, NULL, &key, NULL); + if (res != ERROR_SUCCESS) return res; + res = RegSetValueExA(key, NULL, 0, REG_SZ, (CONST BYTE*)value, + lstrlenA(value) + 1); + RegCloseKey(key); + return res; +} + +/*********************************************************************** + * regsvr_progid + */ +static LONG register_progid( + WCHAR const *clsid, + char const *progid, + char const *curver_progid, + char const *name, + char const *extra) +{ + LONG res; + HKEY progid_key; + + res = RegCreateKeyExA(HKEY_CLASSES_ROOT, progid, 0, + NULL, 0, KEY_READ | KEY_WRITE, NULL, + &progid_key, NULL); + if (res != ERROR_SUCCESS) return res; + + if (name) { + res = RegSetValueExA(progid_key, NULL, 0, REG_SZ, + (CONST BYTE*)name, strlen(name) + 1); + if (res != ERROR_SUCCESS) goto error_close_progid_key; + } + + if (clsid) { + res = register_key_defvalueW(progid_key, clsid_keyname, clsid); + if (res != ERROR_SUCCESS) goto error_close_progid_key; + } + + if (curver_progid) { + res = register_key_defvalueA(progid_key, curver_keyname, + curver_progid); + if (res != ERROR_SUCCESS) goto error_close_progid_key; + } + + if (extra) { + HKEY extra_key; + + res = RegCreateKeyExA(progid_key, extra, 0, + NULL, 0, KEY_READ | KEY_WRITE, NULL, + &extra_key, NULL); + if (res == ERROR_SUCCESS) + RegCloseKey(extra_key); + } + +error_close_progid_key: + RegCloseKey(progid_key); + return res; +} + +/*********************************************************************** + * recursive_delete_key + */ +static LONG recursive_delete_key(HKEY key) +{ + LONG res; + WCHAR subkey_name[MAX_PATH]; + DWORD cName; + HKEY subkey; + + for (;;) { + cName = sizeof(subkey_name) / sizeof(WCHAR); + res = RegEnumKeyExW(key, 0, subkey_name, &cName, + NULL, NULL, NULL, NULL); + if (res != ERROR_SUCCESS && res != ERROR_MORE_DATA) { + res = ERROR_SUCCESS; /* presumably we're done enumerating */ + break; + } + res = RegOpenKeyExW(key, subkey_name, 0, + KEY_READ | KEY_WRITE, &subkey); + if (res == ERROR_FILE_NOT_FOUND) continue; + if (res != ERROR_SUCCESS) break; + + res = recursive_delete_key(subkey); + RegCloseKey(subkey); + if (res != ERROR_SUCCESS) break; + } + + if (res == ERROR_SUCCESS) res = RegDeleteKeyW(key, 0); + return res; +} + +/*********************************************************************** + * recursive_delete_keyA + */ +static LONG recursive_delete_keyA(HKEY base, char const *name) +{ + LONG res; + HKEY key; + + res = RegOpenKeyExA(base, name, 0, KEY_READ | KEY_WRITE, &key); + if (res == ERROR_FILE_NOT_FOUND) return ERROR_SUCCESS; + if (res != ERROR_SUCCESS) return res; + res = recursive_delete_key(key); + RegCloseKey(key); + return res; +} + +/*********************************************************************** + * recursive_delete_keyW + */ +static LONG recursive_delete_keyW(HKEY base, WCHAR const *name) +{ + LONG res; + HKEY key; + + res = RegOpenKeyExW(base, name, 0, KEY_READ | KEY_WRITE, &key); + if (res == ERROR_FILE_NOT_FOUND) return ERROR_SUCCESS; + if (res != ERROR_SUCCESS) return res; + res = recursive_delete_key(key); + RegCloseKey(key); + return res; +} + +/*********************************************************************** + * coclass list + */ +static struct regsvr_coclass const coclass_list[] = { + { &CLSID_VfwCapture, + "Video input for wine", + NULL, + "qcap.dll", + "Both" + }, + { &CLSID_CaptureGraphBuilder, + "Capture Graph Builder", + NULL, + "qcap.dll", + "Both" + }, + { NULL } /* list terminator */ +}; + +/*********************************************************************** + * interface list + */ + +static struct regsvr_interface const interface_list[] = { + { NULL } /* list terminator */ +}; + +/*********************************************************************** + * mediatype list + */ + +static struct regsvr_mediatype_parsing const mediatype_parsing_list[] = { + { NULL } /* list terminator */ +}; + +/*********************************************************************** + * mediatype list + */ + +static struct regsvr_mediatype_extension const mediatype_extension_list[] = { + { NULL } /* list terminator */ +}; + +/*********************************************************************** + * filter list + */ + +static struct regsvr_filter const filter_list[] = { + { &CLSID_VfwCapture, + &CLSID_VideoInputDeviceCategory, + { 'V','i','d','e','o',' ','4',' ','w','i','n','e',0 }, + 0x400000, + { { 0xFFFFFFFF } } + }, + { NULL } /* list terminator */ +}; + +/*********************************************************************** + * DllRegisterServer (QCAP.@) + */ +HRESULT WINAPI QCAP_DllRegisterServer(void) +{ + HRESULT hr; + + TRACE("\n"); + + hr = register_coclasses(coclass_list); + if (SUCCEEDED(hr)) + hr = register_interfaces(interface_list); + if (SUCCEEDED(hr)) + hr = register_mediatypes_parsing(mediatype_parsing_list); + if (SUCCEEDED(hr)) + hr = register_mediatypes_extension(mediatype_extension_list); + if (SUCCEEDED(hr)) + hr = register_filters(filter_list); + return hr; +} + +/*********************************************************************** + * DllUnregisterServer (QCAP.@) + */ +HRESULT WINAPI QCAP_DllUnregisterServer(void) +{ + HRESULT hr; + + TRACE("\n"); + + hr = unregister_filters(filter_list); + if (SUCCEEDED(hr)) + hr = unregister_coclasses(coclass_list); + if (SUCCEEDED(hr)) + hr = unregister_interfaces(interface_list); + if (SUCCEEDED(hr)) + hr = unregister_mediatypes_parsing(mediatype_parsing_list); + if (SUCCEEDED(hr)) + hr = unregister_mediatypes_extension(mediatype_extension_list); + return hr; +} diff -Nru wine-old/dlls/qcap/v4l.c wine-new/dlls/qcap/v4l.c --- wine-old/dlls/qcap/v4l.c 1970-01-01 01:00:00.000000000 +0100 +++ wine-new/dlls/qcap/v4l.c 2005-05-01 02:08:03.000000000 +0200 @@ -0,0 +1,667 @@ +/* DirectShow capture services (QCAP.DLL) + * + * Copyright 2005 Maarten Lankhorst + * + * This file contains the part of the vfw capture interface that + * does the actual Video4Linux(1/2) stuff required for capturing + * and setting/getting media format.. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include "config.h" +#ifdef HAVE_LINUX_VIDEODEV_H + +#define NONAMELESSSTRUCT +#define NONAMELESSUNION +#include "qcap_private.h" +#include "pin.h" + +#include "uuids.h" +#include "mmreg.h" +#include "vfwmsgs.h" +#include "amvideo.h" +#include "windef.h" +#include "winbase.h" +#include "dshow.h" +#include "strmif.h" +#include "ddraw.h" + +#include "wine/unicode.h" +#include "wine/debug.h" + +#include <stdio.h> +#include <sys/ioctl.h> +#include <sys/stat.h> +#include <sys/mman.h> +#include <sys/errno.h> +#include <sys/time.h> +#include <asm/types.h> +#include <linux/videodev.h> +#include <fcntl.h> +#include <unistd.h> +#include "winnls.h" +#include "capture.h" + +WINE_DEFAULT_DEBUG_CHANNEL(qcap_v4l); + +/* NOTE: Currently the V4L2 is unsupported and I'm not working on it, + * I have undefined HAVE_V4L2 so that I could leave the code in place + * without having to update it.. + */ +#undef HAVE_V4L2 + +struct CaptureBox; + +typedef void (* Renderer)(struct CaptureBox *, LPBYTE bufferin, LPBYTE stream); + +typedef struct CaptureBox { +/* Dunno what to put in here? */ + UINT width, height, bitDepth, fps; + UINT outputwidth, outputheight; + + CRITICAL_SECTION CritSect; + + IPin *pOut; + int fd, isV4l2, mmap; + int iscommitted, stopped; + +/* mmap (V4l1) */ + struct video_mmap *grab_buf; + struct video_mbuf gb_buffers; + void *pmap; + int buffers, palette; + +/* read (V4l1) */ + int imagesize; + char * grab_data; + + int curframe; + + HANDLE thread; + Renderer renderer; +} CaptureBox; + +struct renderlist { + int depth; + char* name; + Renderer renderer; +}; + +static void renderer_RGB24(CaptureBox *capBox, LPBYTE bufferin, LPBYTE stream); +static void renderer_RGB32(CaptureBox *capBox, LPBYTE bufferin, LPBYTE stream); + +static const struct renderlist renderlist_V4l[] = { + { 0, "NULL renderer", NULL }, + { 8, "Gray scales", NULL }, /* 1, Intentional not suported */ + { 0, "High 240 cube (BT848)", NULL }, /* 2, Intentional not supported */ + { 16, "16 bit RGB (565)", NULL }, /* 3, Intentional not supported */ + { 24, "24 bit RGB values", renderer_RGB24 }, /* 4, Supported, and tested */ + { 32, "32 bit RGB values", renderer_RGB32 }, /* 5, Supported, and tested */ + { 16, "15 bit RGB (555)", NULL }, /* 6, Intentional not supported */ + { 16, "YUV 422 (Not P)", NULL }, /* 7, Should be supported */ + { 16, "YUYV (Not P)", NULL }, /* 8, Should be supported */ + { 16, "UYVY (Not P)", NULL }, /* 9, Should be supported */ + { 12, "YUV 420 (Not P)", NULL }, /* 10, Should be supported */ + { 0, "Raw capturing (BT848)", NULL }, /* 11, Intentional not supported */ + { 16, "YUV 422 (Planar)", NULL }, /* 12, Should be supported */ + { 12, "YUV 411 (Planar)", NULL }, /* 13, Should be supported */ + { 12, "YUV 420 (Planar)", NULL }, /* 14, Should be supported */ + { 10, "YUV 410 (Planar)", NULL }, /* 15, Should be supported */ + { 0, NULL, NULL }, +}; + +const int fallback_V4l[] = { 4, 5, 7, 8, 9, 12, 13, 14, 15, 10 }; +/* Fallback: First try raw formats, then yuv, then yuv with a color channel missing */ + +static int xioctl(int fd, int request, void * arg) +{ + int r; + + do r = ioctl (fd, request, arg); + while (-1 == r && EINTR == errno); + + return r; +} + +HRESULT Capture_Initialise(void ** pointer, IPin * pOut, USHORT card) +{ + CaptureBox * capBox = CoTaskMemAlloc(sizeof(CaptureBox)); + char device[128]; + struct stat st; +#ifdef HAVE_V4L2 + struct v4l2_capability caps; +#endif + struct video_capability capa; + struct video_picture pict; + struct video_window window; + + /* Because I don't want to change every return failure, + I'll let VfwCapture clean up if *pointer != NULL + and the call failed.. + */ + + *pointer = NULL; /* Until we're succesful */ + + if (!capBox) { + ERR("Out of memory\n"); + return E_OUTOFMEMORY; + } + + sprintf(device, "/dev/video%i", card); + + FIXME("(): Allow use of more then 1 video adapter, like I did in avicap\n"); + + if (stat (device, &st) == -1) { + ERR("%s: %s\n", device, strerror(errno)); + CoTaskMemFree(capBox); + return E_FAIL; + } + + if (!S_ISCHR (st.st_mode)) { + ERR("%s: Not a device\n", device); + CoTaskMemFree(capBox); + return E_FAIL; + } + + capBox->fd = open(device, O_RDWR | O_NONBLOCK); + if (capBox->fd == -1) { + ERR("%s: Failed to open: %s\n", device, strerror(errno)); + CoTaskMemFree(capBox); + return E_FAIL; + } + +#ifdef HAVE_V4L2 + if (xioctl(capBox->fd, VIDIOC_QUERYCAP, &caps) >= 0) { + capBox->isV4l2 = 1; +/* There are 5 reasons I don't add V4l2 support + * 1. Webcams don't use it + * 2. It is more complicated then V4l and more complicated then it needs to be + * 3. V4l2 devices can fall back to V4l + * 4. No one really misses it if I leave it out.. + * 5. (MAIN REASON) *I* don't miss it, if you do, write V4l2 support yourself! + */ + ERR("Tinkerer detected? Thou shalt not define HAVE_V4L2\n"); + CoTaskMemFree(capBox); + close(capBox->fd); + return E_FAIL; + } else +#endif /* HAVE_V4L2 */ + { + capBox->isV4l2 = 0; + memset(&capa, 0, sizeof(capa)); + + if (xioctl(capBox->fd, VIDIOCGCAP, &capa) == -1) { + if (errno != EINVAL && errno != 515) ERR("%s: Querying failed: %s\n", device, strerror(errno)); + else ERR("%s: Querying failed: Not a V4L compatible device", device); + close(capBox->fd); + CoTaskMemFree(capBox); + return E_FAIL; + } + + if (!(capa.type & VID_TYPE_CAPTURE)) { + ERR("%s: This is not a video capture device\n", device); + close(capBox->fd); + CoTaskMemFree(capBox); + return E_FAIL; + } + TRACE("Amount of inputs on %s: %d\n", capa.name, capa.channels); + + if (xioctl(capBox->fd, VIDIOCGPICT, &pict) == -1) { + ERR("%s: Acquiring picture properties failed, this shouldn't happen..\n", device); + close(capBox->fd); + CoTaskMemFree(capBox); + return E_FAIL; + } + + TRACE("%s: Suggested picture depth: %d, suggested picture palette: %d\n", device, pict.depth, pict.palette); + TRACE("%s: Hue %d, Color %d, Contrast %d\n", device, pict.hue,pict.colour,pict.contrast); +/* This will most likely fail, and if it does we will fall back to 32 bits, + of which each first bit will be nothing but rubble, waste of bandwidth */ + TRACE("%s: Suggested format: "%s"\n", device, renderlist_V4l[pict.palette].name); + if (!renderlist_V4l[pict.palette].renderer) + { + int palet = pict.palette, formatenum; + WARN("No renderer available for "%s", trying to fall back to defaults\n", renderlist_V4l[pict.palette].name); + capBox->renderer = NULL; + for (formatenum = 0; formatenum < (sizeof(fallback_V4l) / sizeof(int)); formatenum++) { + int currentrender = fallback_V4l[formatenum]; + if (renderlist_V4l[currentrender].renderer == NULL) continue; + pict.depth = renderlist_V4l[currentrender].depth; + pict.palette = currentrender; + if (xioctl(capBox->fd, VIDIOCSPICT, &pict) == -1) { + TRACE("%s: Could not render with "%s"\n (%d)", device, renderlist_V4l[currentrender].name, currentrender); + continue; + } + TRACE("%s: Found a suitable renderer: "%s" (%d)\n", device, renderlist_V4l[currentrender].name, currentrender); + capBox->renderer = renderlist_V4l[currentrender].renderer; + break; + } + if (!capBox->renderer) { + close(capBox->fd); + CoTaskMemFree(capBox); + ERR("%s: This device wants to use "%s", but this format isn't available, and it didn't accept one of our other formats, GIVING UP!\n\n", device, renderlist_V4l[palet].name); + return E_FAIL; + } + } else { + TRACE("Using the suggested format\n"); + capBox->renderer = renderlist_V4l[pict.palette].renderer; + } + + memset(&window, 0, sizeof(window)); + if (xioctl(capBox->fd, VIDIOCGWIN, &window) == -1) { + ERR("%s: Getting resolution failed.. (%s), giving up\n", device, strerror(errno)); + close(capBox->fd); + CoTaskMemFree(capBox); + return E_FAIL; + } + + capBox->height = window.height; + capBox->width = window.width; + capBox->bitDepth = 24; +/* Try mmap */ + + if (xioctl(capBox->fd, VIDIOCGMBUF, &capBox->gb_buffers) != -1 && capBox->gb_buffers.frames) { + capBox->mmap = 1; + capBox->buffers = capBox->gb_buffers.frames; + if (capBox->gb_buffers.frames > 2) { + TRACE("%s: %d buffers granted, but only using 2 anyway\n", device, capBox->gb_buffers.frames); + capBox->buffers = 2; + } else if (capBox->gb_buffers.frames == 1) { + TRACE("%s: Only 1 buffer granted, which is below the tested 2\n", device); + } else { + TRACE("%s: Using %d buffers\n", device, capBox->gb_buffers.frames); + } + capBox->pmap = mmap(0, capBox->gb_buffers.size, PROT_READ|PROT_WRITE, MAP_SHARED, capBox->fd, 0); + if (capBox->pmap != MAP_FAILED) { + int i; + capBox->grab_buf = CoTaskMemAlloc(sizeof(struct video_mmap) * capBox->buffers); + if(!capBox->grab_buf) { + ERR("Out of memory?\n"); + munmap(capBox->pmap, capBox->gb_buffers.size); + close(capBox->fd); + CoTaskMemFree(capBox); + return E_OUTOFMEMORY; + } + + /* Setup mmap capture buffers. */ + for (i = 0; i < capBox->buffers; i++) { + capBox->grab_buf[i].format = pict.palette; + capBox->grab_buf[i].frame = i; + capBox->grab_buf[i].width = capBox->width; + capBox->grab_buf[i].height = capBox->height; + if (xioctl(capBox->fd, VIDIOCMCAPTURE, &capBox->grab_buf[i]) == -1) + { + ERR("%s: Error setting up capture IOCTL: %s\n", device, strerror(errno)); + Capture_Destroy(capBox); + return E_FAIL; + } + } + } else capBox->mmap = 0; + } + if (!capBox->mmap) { + capBox->buffers = 1; + capBox->imagesize = renderlist_V4l[pict.palette].depth * capBox->height * capBox->width / 8; + capBox->grab_data = CoTaskMemAlloc(capBox->imagesize); + if (!capBox->grab_data) + { + ERR("%s: Out of memory?\n", device); + close(capBox->fd); + CoTaskMemFree(capBox); + return E_OUTOFMEMORY; + } + } + } + + capBox->pOut = pOut; + capBox->fps = 3; + capBox->stopped = 0; + capBox->curframe = 0; + InitializeCriticalSection(&capBox->CritSect); + *pointer = capBox; + +/* I had to set output to 320x240 for pin connection, the builtin filtergraph reconnect doesn't work + * we will try to change to this format later anyway, in Capture_SetFormat */ + capBox->outputwidth = 320; + capBox->outputheight = 240; + capBox->iscommitted = 0; + TRACE("Using format: %d bits - %d x %d\n", capBox->bitDepth, capBox->width, capBox->height); + return S_OK; +} + +HRESULT Capture_Destroy(void * pBox) +{ + CaptureBox *capBox = (CaptureBox *)pBox; +/* Destroy file handlers etc? This function can't fail.. */ +#ifdef HAVE_V4L2 + if (capBox->isV4l2) { +/* We should destroy V4l2 stuff here but we don't use it */ + } else +#endif + if (capBox->mmap) { + munmap(capBox->pmap, capBox->gb_buffers.size); + CoTaskMemFree(capBox->grab_buf); + } else CoTaskMemFree(capBox->grab_data); + close(capBox->fd); + DeleteCriticalSection(&capBox->CritSect); + return S_OK; +} + +HRESULT Capture_SetMediaType(void * pBox, AM_MEDIA_TYPE * mT) +{ + CaptureBox *capBox = (CaptureBox *)pBox; + TRACE("%p\n", capBox); + if (((VIDEOINFOHEADER *)mT->pbFormat)->bmiHeader.biBitCount != 24 || + ((VIDEOINFOHEADER *)mT->pbFormat)->bmiHeader.biCompression != BI_RGB) + { + ERR("Invalid media type suggested\n"); + return VFW_E_INVALIDMEDIATYPE; + } +#ifdef HAVE_V4L2 + if (capBox->isV4l2) { +/* We should do V4l2 resizing here but V4l2 is not really supported.. */ + } else +#endif + { + struct video_window window; + + } + + capBox->outputwidth = ((VIDEOINFOHEADER *)mT->pbFormat)->bmiHeader.biWidth; + capBox->outputheight = ((VIDEOINFOHEADER *)mT->pbFormat)->bmiHeader.biHeight; + + FIXME("%p -> (%p) - %d %d\n", capBox, mT, capBox->outputwidth, capBox->outputheight); + return S_OK; +} + +HRESULT Capture_GetMediaType(void * pBox, AM_MEDIA_TYPE ** mT) +{ + CaptureBox *capBox = (CaptureBox *)pBox; + TRACE("%p\n", capBox); + VIDEOINFOHEADER *vi; + mT[0] = CoTaskMemAlloc(sizeof(AM_MEDIA_TYPE)); + if (!mT[0]) return E_OUTOFMEMORY; + vi = CoTaskMemAlloc(sizeof(VIDEOINFOHEADER)); + mT[0]->cbFormat = sizeof(VIDEOINFOHEADER); + if (!vi) + { + CoTaskMemFree(mT[0]); + return E_OUTOFMEMORY; + } + memcpy(&mT[0]->majortype, &MEDIATYPE_Video, sizeof(GUID)); + memcpy(&mT[0]->subtype, &MEDIASUBTYPE_RGB24, sizeof(GUID)); + memcpy(&mT[0]->formattype, &FORMAT_VideoInfo, sizeof(GUID)); + mT[0]->bFixedSizeSamples = TRUE; + mT[0]->bTemporalCompression = FALSE; + mT[0]->pUnk = NULL; + mT[0]->lSampleSize = capBox->outputwidth * capBox->outputheight * capBox->bitDepth / 8; + TRACE("Output format: %d x %d - %d bits = %lu KB\n", capBox->outputwidth, capBox->outputheight, capBox->bitDepth, mT[0]->lSampleSize/1024); + vi->rcSource.left = 0; vi->rcSource.top = 0; + vi->rcTarget.left = 0; vi->rcTarget.top = 0; + vi->rcSource.right = capBox->width; vi->rcSource.bottom = capBox->height; + vi->rcTarget.right = capBox->outputwidth; vi->rcTarget.bottom = capBox->outputheight; + vi->dwBitRate = capBox->fps * mT[0]->lSampleSize; + vi->dwBitErrorRate = 0; + vi->AvgTimePerFrame = (LONGLONG)10000000.0 / (LONGLONG)capBox->fps; + vi->bmiHeader.biSize = 40; + vi->bmiHeader.biWidth = capBox->outputwidth; + vi->bmiHeader.biHeight = capBox->outputheight; + vi->bmiHeader.biPlanes = 1; + vi->bmiHeader.biBitCount = 24; + vi->bmiHeader.biCompression = BI_RGB; + vi->bmiHeader.biSizeImage = mT[0]->lSampleSize; + vi->bmiHeader.biClrUsed = vi->bmiHeader.biClrImportant = 0; + vi->bmiHeader.biXPelsPerMeter = 100; + vi->bmiHeader.biYPelsPerMeter = 100; + mT[0]->pbFormat = (void *)vi; + dump_AM_MEDIA_TYPE(mT[0]); + return S_OK; +} + +static void renderer_RGB24(CaptureBox *capBox, LPBYTE bufferin, LPBYTE stream) +{ + int size = capBox->height * capBox->width * 3; + TRACE("%p\n", capBox); + memcpy(bufferin, stream, size); +} + +static void renderer_RGB32(CaptureBox *capBox, LPBYTE bufferin, LPBYTE stream) +{ + int size = capBox->height * capBox->width * 4; + int pointer = 0, offset = 1; + TRACE("()\n"); + + /* I guess it's easier - but slower to do this per byte.. */ + + while (pointer + offset <= size) { + bufferin[pointer] = stream[pointer + offset]; + pointer++; + bufferin[pointer] = stream[pointer + offset]; + pointer++; + bufferin[pointer] = stream[pointer + offset]; + pointer++; + offset++; + } +} + +#define CHECKRANGE(a) (a > 255 ? 255 : (a < 0 ? 0 : a)) + +static void Resize(CaptureBox * capBox, LPBYTE output, LPBYTE input) +{ +/* outputheight < height */ +/* outputwidth < width */ + int depth = capBox->bitDepth / 8; + int inoffset = 0, outoffset = (capBox->outputheight-1) * capBox->outputwidth * depth; + int ow = capBox->outputwidth * depth; + while (outoffset) { + outoffset -= ow; + int x; + for (x = 0; x < ow; x++) + output[outoffset + x] = input[inoffset + x]; + inoffset += capBox->width * depth; + } +} + +static void Capture_GetFrame(CaptureBox * capBox, LPBYTE * pInput) +{ +#ifdef HAVE_V4L2 + if (capBox->isV4l2) { + } else +#endif + if (capBox->mmap) { + if (xioctl(capBox->fd, VIDIOCSYNC, &capBox->grab_buf[capBox->curframe]) == -1) + TRACE("Syncing ioctl failed: %s\n", strerror(errno)); + *pInput = ((char *)capBox->pmap) + capBox->gb_buffers.offsets[capBox->curframe]; + } else { + int retval; + while ((retval = read(capBox->fd, capBox->grab_data, capBox->imagesize)) == -1) + if (errno != EAGAIN) break; + if (retval == -1) + ERR("Error occured while reading from device: %s\n", strerror(errno)); + *pInput = capBox->grab_data; + } +} + +static void Capture_FreeFrame(CaptureBox * capBox) +{ +#ifdef HAVE_V4L2 + if (capBox->isV4l2) { + } else +#endif + if (capBox->mmap) { + if (xioctl(capBox->fd, VIDIOCMCAPTURE, &capBox->grab_buf[capBox->curframe]) == -1) + TRACE("Freeing frame for capture failed: %s\n", strerror(errno)); + } + if (++capBox->curframe == capBox->buffers) capBox->curframe = 0; +} + +static DWORD WINAPI ReadThread(LPVOID lParam) { + CaptureBox * capBox = lParam; + HRESULT hr; + IMediaSample *pSample = NULL; + unsigned long framecount = 0; + LPBYTE pTarget, pInput, pOutput; + pOutput = CoTaskMemAlloc(capBox->width * capBox->height * 3); + + while (1) { + EnterCriticalSection(&capBox->CritSect); + if (capBox->stopped) break; + hr = OutputPin_GetDeliveryBuffer((OutputPin *)capBox->pOut, &pSample, NULL, NULL, 0); + if (SUCCEEDED(hr)) { + IMediaSample_SetActualDataLength(pSample, capBox->outputheight * capBox->outputwidth * capBox->bitDepth / 8); + IMediaSample_GetPointer(pSample, &pTarget); + /* TODO: Check return values.. */ + Capture_GetFrame(capBox, &pInput); + capBox->renderer(capBox, pOutput, pInput); + Resize(capBox, pTarget, pOutput); + hr = OutputPin_SendSample((OutputPin *)capBox->pOut, pSample); + FIXME("%p -> Frame %lu: %lx\n", capBox, ++framecount, hr); + IMediaSample_Release(pSample); + Capture_FreeFrame(capBox); + } + LeaveCriticalSection(&capBox->CritSect); + if (FAILED(hr) && hr != VFW_E_NOT_CONNECTED) { + ERR("Received error: %lx\n", hr); + } + } + LeaveCriticalSection(&capBox->CritSect); + CoTaskMemFree(pOutput); + + return 0x0; +} + +HRESULT Capture_Run(void * pBox, FILTER_STATE *state) +{ + CaptureBox *capBox = (CaptureBox *)pBox; + HANDLE thread; + HRESULT hr; + + TRACE("%p -> (%p)\n", capBox, state); + + if (*state == State_Running) return S_OK; + + EnterCriticalSection(&capBox->CritSect); + + capBox->stopped = 0; + + if (*state == State_Stopped) + { + *state = State_Running; + if (!capBox->iscommitted++) { + IMemAllocator * pAlloc = NULL; + ALLOCATOR_PROPERTIES ap, actual; + ap.cBuffers = 3; + ap.cbBuffer = capBox->outputwidth * capBox->outputheight * capBox->bitDepth / 8; + ap.cbAlign = 1; + ap.cbPrefix = 0; + + hr = IMemInputPin_GetAllocator(((OutputPin *)capBox->pOut)->pMemInputPin, &pAlloc); + + if (SUCCEEDED(hr)) + hr = IMemAllocator_SetProperties(pAlloc, &ap, &actual); + + if (SUCCEEDED(hr)) + hr = IMemAllocator_Commit(pAlloc); + + if (pAlloc) + IMemAllocator_Release(pAlloc); + + TRACE("Committing allocator: %lx\n", hr); + } + + thread = CreateThread(NULL, 0, ReadThread, capBox, 0, NULL); + if (thread) { + capBox->thread = thread; + SetThreadPriority(thread, THREAD_PRIORITY_IDLE); + LeaveCriticalSection(&capBox->CritSect); + return S_OK; + } + ERR("Creating thread failed.. %lx\n", GetLastError()); + LeaveCriticalSection(&capBox->CritSect); + return E_FAIL; + } + + ResumeThread(capBox->thread); + *state = State_Running; + LeaveCriticalSection(&capBox->CritSect); + return S_OK; +} + +HRESULT Capture_Pause(void * pBox, FILTER_STATE *state) +{ + CaptureBox *capBox = (CaptureBox *)pBox; + TRACE("%p -> (%p)\n", capBox, state); + if (*state == State_Paused) return S_OK; + if (*state == State_Stopped) Capture_Run(pBox, state); + EnterCriticalSection(&capBox->CritSect); + *state = State_Paused; + SuspendThread(capBox->thread); + LeaveCriticalSection(&capBox->CritSect); + return S_OK; +} + +HRESULT Capture_Stop(void * pBox, FILTER_STATE *state) +{ + CaptureBox *capBox = (CaptureBox *)pBox; + TRACE("%p -> (%p)\n", capBox, state); + if (*state == State_Stopped) return S_OK; + + EnterCriticalSection(&capBox->CritSect); + + if (capBox->thread) { + if (*state == State_Paused) + ResumeThread(capBox->thread); + *state = State_Stopped; + capBox->stopped = 1; + capBox->thread = 0; + if (capBox->iscommitted) { + HRESULT hr; + IMemInputPin *pMem = NULL; + IMemAllocator * pAlloc = NULL; + IPin *pConnect = NULL; + + capBox->iscommitted = 0; + + hr = IPin_ConnectedTo(capBox->pOut, &pConnect); + + if (SUCCEEDED(hr)) + hr = IPin_QueryInterface(pConnect, &IID_IMemInputPin, (void **) &pMem); + + if (SUCCEEDED(hr)) + hr = IMemInputPin_GetAllocator(pMem, &pAlloc); + + if (SUCCEEDED(hr)) + hr = IMemAllocator_Decommit(pAlloc); + + if (pAlloc) + IMemAllocator_Release(pAlloc); + + if (pMem) + IMemInputPin_Release(pMem); + + if (pConnect) + IPin_Release(pConnect); + + if (hr != S_OK && hr != VFW_E_NOT_COMMITTED) + ERR("Decommitting allocator: %lx\n", hr); + } + } + + LeaveCriticalSection(&capBox->CritSect); + return S_OK; +} + +#endif /* HAVE_LINUX_VIDEODEV_H */ + diff -Nru wine-old/dlls/qcap/vfwcapture.c wine-new/dlls/qcap/vfwcapture.c --- wine-old/dlls/qcap/vfwcapture.c 1970-01-01 01:00:00.000000000 +0100 +++ wine-new/dlls/qcap/vfwcapture.c 2005-05-01 01:59:57.000000000 +0200 @@ -0,0 +1,614 @@ +/* Video For Windows Steering structure + * + * Copyright 2005 Maarten Lankhorst + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * Ugh, Now I can't tell what's worser, COM or the bugs in filtergraph, pins, enummedia and devenum.. + * This file is only compiled if we found a working videodev.h + * If it doesn't exist, null.c will be compiled instead + */ + +/* /dev/videoX where X = videodevice, will look at a more legal way later.. + * So here we use /dev/video0 */ +#define VIDEODEVICE 0 + +#define NONAMELESSSTRUCT +#define NONAMELESSUNION +#include "config.h" +#include "qcap_private.h" +#include "wine/unicode.h" +#include "wine/debug.h" + +WINE_DEFAULT_DEBUG_CHANNEL(qcap); + +#include "pin.h" +#include "capture.h" +#include "uuids.h" +#include "mmreg.h" +#include "vfwmsgs.h" +#include "amvideo.h" +#include "windef.h" +#include "winbase.h" +#include "dshow.h" +#include "strmif.h" +#include "ddraw.h" + +static const IBaseFilterVtbl VfwCapture_Vtbl; +static const IAMStreamConfigVtbl IAMStreamConfig_VTable; +static const IPinVtbl VfwPin_Vtbl; + +static HRESULT VfwPin_Construct(IBaseFilter * pBaseFilter, LPCRITICAL_SECTION pCritSec, IPin ** ppPin); +static const WCHAR wszOutputPinName[] = { 'O','u','t','p','u','t',0 }; + +typedef struct VfwCapture +{ + const struct IBaseFilterVtbl * lpVtbl; + const struct IAMStreamConfigVtbl * IAMStreamConfig_vtbl; + + LPVOID myCap; + ULONG refCount; + FILTER_INFO filterInfo; + FILTER_STATE state; + CRITICAL_SECTION csFilter; + + IPin * pOutputPin; +} VfwCapture; + +/* VfwPin implementation */ +typedef struct VfwPinImpl +{ + OutputPin pin; + + LPVOID myCap; + IKsPropertySetVtbl * KSP_VT; +} VfwPinImpl; + +HRESULT VfwCapture_create(IUnknown * pUnkOuter, LPVOID * ppv) +{ + VfwCapture *pVfwCapture; + HRESULT hr; + + if (pUnkOuter) + return CLASS_E_NOAGGREGATION; + + pVfwCapture = CoTaskMemAlloc(sizeof(VfwCapture)); + + if (!pVfwCapture) + return E_OUTOFMEMORY; + + pVfwCapture->lpVtbl = &VfwCapture_Vtbl; + pVfwCapture->IAMStreamConfig_vtbl = &IAMStreamConfig_VTable; + pVfwCapture->refCount = 1; + pVfwCapture->filterInfo.achName[0] = '\0'; + pVfwCapture->filterInfo.pGraph = NULL; + pVfwCapture->state = State_Stopped; + InitializeCriticalSection(&pVfwCapture->csFilter); + hr = VfwPin_Construct((IBaseFilter *)&pVfwCapture->lpVtbl, &pVfwCapture->csFilter, &pVfwCapture->pOutputPin); + if (!SUCCEEDED(hr)) + { + CoTaskMemFree(pVfwCapture); + return E_OUTOFMEMORY; + } else { + hr = Capture_Initialise(&pVfwCapture->myCap, pVfwCapture->pOutputPin, VIDEODEVICE); + ((VfwPinImpl *)pVfwCapture->pOutputPin)->myCap = pVfwCapture->myCap; + if (FAILED(hr)) { + if (pVfwCapture->myCap) + CoTaskMemFree(pVfwCapture->myCap); + IPin_Release((IPin *)pVfwCapture->pOutputPin); + CoTaskMemFree(pVfwCapture); + return hr; + } + } + *ppv = (LPVOID)pVfwCapture; + TRACE("-- created at %p\n", pVfwCapture); + + return S_OK; +} + +static HRESULT WINAPI VfwCapture_QueryInterface(IBaseFilter * iface, REFIID riid, LPVOID * ppv) +{ + VfwCapture *This = (VfwCapture *)iface; + TRACE("(%s, %p)\n", qcdebugstr_guid(riid), ppv); + *ppv = NULL; + + if (IsEqualIID(riid, &IID_IUnknown)) + *ppv = (LPVOID)This; + else if (IsEqualIID(riid, &IID_IPersist)) + *ppv = (LPVOID)This; + else if (IsEqualIID(riid, &IID_IMediaFilter)) + *ppv = (LPVOID)This; + else if (IsEqualIID(riid, &IID_IBaseFilter)) + *ppv = (LPVOID)This; + else if (IsEqualIID(riid, &IID_IAMStreamConfig)) + *ppv = (LPVOID)&(This->IAMStreamConfig_vtbl); + + if (*ppv) + { + TRACE("Returning %s interface\n", qcdebugstr_guid(riid)); + IUnknown_AddRef((IUnknown *)(*ppv)); + return S_OK; + } + + FIXME("No interface for %s!\n", qcdebugstr_guid(riid)); + return E_NOINTERFACE; +} + +static ULONG WINAPI VfwCapture_AddRef(IBaseFilter * iface) +{ + VfwCapture *This = (VfwCapture *)iface; + ULONG refCount = InterlockedIncrement(&This->refCount); + + TRACE("(%p/%p)->() New refcount: %ld\n", This, iface, refCount); + + return refCount; +} + +static ULONG WINAPI VfwCapture_Release(IBaseFilter * iface) +{ + VfwCapture *This = (VfwCapture *)iface; + ULONG refCount = InterlockedDecrement(&This->refCount); + TRACE("(%p/%p)->() New refcount: %ld\n", This, iface, refCount); + + if (!refCount) + { + TRACE("(): Destroying everything!\n"); + if (This->state != State_Stopped) + Capture_Stop(This->myCap, &This->state); + Capture_Destroy(This->myCap); + CoTaskMemFree(This->myCap); + if (((IPinImpl *)This->pOutputPin)->pConnectedTo != NULL) + { + IPin_Disconnect(((IPinImpl *)This->pOutputPin)->pConnectedTo); + IPin_Disconnect(This->pOutputPin); + } + IPin_Release(This->pOutputPin); + DeleteCriticalSection(&This->csFilter); + This->lpVtbl = NULL; + CoTaskMemFree(This); + } + return refCount; +} + +/** IPersist methods **/ + +static HRESULT WINAPI VfwCapture_GetClassID(IBaseFilter * iface, CLSID * pClsid) +{ + TRACE("(%p)\n", pClsid); + *pClsid = CLSID_VfwCapture; + return S_OK; +} + +/** IMediaFilter methods **/ + +static HRESULT WINAPI VfwCapture_Stop(IBaseFilter * iface) +{ + VfwCapture *This = (VfwCapture *)iface; + TRACE("()\n"); + return Capture_Stop(This->myCap, &This->state); +} + +static HRESULT WINAPI VfwCapture_Pause(IBaseFilter * iface) +{ + VfwCapture *This = (VfwCapture *)iface; + TRACE("()\n"); + return Capture_Pause(This->myCap, &This->state); +} + +static HRESULT WINAPI VfwCapture_Run(IBaseFilter * iface, REFERENCE_TIME tStart) +{ + VfwCapture *This = (VfwCapture *)iface; + TRACE("(%lx%08lx)\n", (ULONG)(tStart >> 32), (ULONG)tStart); + return Capture_Run(This->myCap, &This->state); +} + +static HRESULT WINAPI VfwCapture_GetState(IBaseFilter * iface, DWORD dwMilliSecsTimeout, FILTER_STATE *pState) +{ + VfwCapture *This = (VfwCapture *)iface; + TRACE("(%lu, %p)\n", dwMilliSecsTimeout, pState); + *pState = This->state; + return S_OK; +} + +static HRESULT WINAPI VfwCapture_SetSyncSource(IBaseFilter * iface, IReferenceClock *pClock) +{ + TRACE("(%p)\n", pClock); + return S_OK; +} + +static HRESULT WINAPI VfwCapture_GetSyncSource(IBaseFilter * iface, IReferenceClock **ppClock) +{ + TRACE("(%p)\n", ppClock); + return S_OK; +} + +/** IBaseFilter methods **/ + +static HRESULT WINAPI VfwCapture_EnumPins(IBaseFilter * iface, IEnumPins **ppEnum) +{ + ENUMPINDETAILS epd; + VfwCapture *This = (VfwCapture *)iface; + + TRACE("(%p)\n", ppEnum); + + epd.cPins = 1; + epd.ppPins = &This->pOutputPin; + return IEnumPinsImpl_Construct(&epd, ppEnum); +} + +static HRESULT WINAPI VfwCapture_FindPin(IBaseFilter * iface, LPCWSTR Id, IPin **ppPin) +{ + FIXME("(%s, %p) - stub\n", debugstr_w(Id), ppPin); + return E_NOTIMPL; +} + +static HRESULT WINAPI VfwCapture_QueryFilterInfo(IBaseFilter * iface, FILTER_INFO *pInfo) +{ + VfwCapture *This = (VfwCapture *)iface; + + TRACE("(%p)\n", pInfo); + + strcpyW(pInfo->achName, This->filterInfo.achName); + pInfo->pGraph = This->filterInfo.pGraph; + + if (pInfo->pGraph) + IFilterGraph_AddRef(pInfo->pGraph); + return S_OK; +} + +static HRESULT WINAPI VfwCapture_JoinFilterGraph(IBaseFilter * iface, IFilterGraph *pGraph, LPCWSTR pName) +{ + VfwCapture *This = (VfwCapture *)iface; + + TRACE("(%p, %s)\n", pGraph, debugstr_w(pName)); + + if (pName) + strcpyW(This->filterInfo.achName, pName); + else + *This->filterInfo.achName = 0; + This->filterInfo.pGraph = pGraph; /* NOTE: do NOT increase ref. count */ + + return S_OK; +} + +static HRESULT WINAPI VfwCapture_QueryVendorInfo(IBaseFilter * iface, LPWSTR *pVendorInfo) +{ + FIXME("(%p) - stub\n", pVendorInfo); + return E_NOTIMPL; +} + +static const IBaseFilterVtbl VfwCapture_Vtbl = +{ + VfwCapture_QueryInterface, + VfwCapture_AddRef, + VfwCapture_Release, + VfwCapture_GetClassID, + VfwCapture_Stop, + VfwCapture_Pause, + VfwCapture_Run, + VfwCapture_GetState, + VfwCapture_SetSyncSource, + VfwCapture_GetSyncSource, + VfwCapture_EnumPins, + VfwCapture_FindPin, + VfwCapture_QueryFilterInfo, + VfwCapture_JoinFilterGraph, + VfwCapture_QueryVendorInfo +}; + +/* AMStreamConfig interface, we only need to implement {G,S}etFormat */ +static HRESULT WINAPI AMStreamConfig_QueryInterface(IAMStreamConfig * iface, REFIID riid, LPVOID * ppv) +{ + if (IsEqualIID(riid, &IID_IUnknown) || + IsEqualIID(riid, &IID_IAMStreamConfig)) + { + *ppv = (LPVOID)iface; + return S_OK; + } + + FIXME("No interface for iid %s\n", qcdebugstr_guid(riid)); + return E_NOINTERFACE; +} + +static ULONG WINAPI AMStreamConfig_AddRef(IAMStreamConfig * iface) +{ + ICOM_THIS_MULTI(VfwCapture, IAMStreamConfig_vtbl, iface); + TRACE("%p --> Forwarding to VfwCapture (%p)\n", iface, This); + return IUnknown_AddRef((IUnknown *)This); +} + +static ULONG WINAPI AMStreamConfig_Release(IAMStreamConfig * iface) +{ + ICOM_THIS_MULTI(VfwCapture, IAMStreamConfig_vtbl, iface); + TRACE("%p --> Forwarding to VfwCapture (%p)\n", iface, This); + return IUnknown_Release((IUnknown *)This); +} + +static HRESULT WINAPI AMStreamConfig_SetFormat(IAMStreamConfig *iface, + AM_MEDIA_TYPE *pmt) { + HRESULT hr; + ICOM_THIS_MULTI(VfwCapture, IAMStreamConfig_vtbl, iface); + + TRACE("(%p): %p->%p\n", iface, pmt, pmt->pbFormat); + + if (This->state != State_Stopped) + { + TRACE("Returning not stopped error\n"); + return VFW_E_NOT_STOPPED; + } + + dump_AM_MEDIA_TYPE(pmt); + + if (((IPinImpl *)This->pOutputPin)->pConnectedTo != NULL) { + hr = IPin_QueryAccept(((IPinImpl *)This->pOutputPin)->pConnectedTo, pmt); + TRACE("Would accept: %ld\n", hr); + if (hr == S_FALSE) + return VFW_E_INVALIDMEDIATYPE; + } + + hr = Capture_SetMediaType(This->myCap, pmt); + if (SUCCEEDED(hr) && This->filterInfo.pGraph != NULL && + ((IPinImpl *)This->pOutputPin)->pConnectedTo != NULL) { + hr = IFilterGraph_Reconnect(This->filterInfo.pGraph, This->pOutputPin); + if (SUCCEEDED(hr)) + TRACE("Reconnection completed, with new media format..\n"); + } + TRACE("Returning: %ld\n", hr); + return hr; +} + +static HRESULT WINAPI AMStreamConfig_GetFormat(IAMStreamConfig *iface, + AM_MEDIA_TYPE **pmt) { + ICOM_THIS_MULTI(VfwCapture, IAMStreamConfig_vtbl, iface); + + TRACE("%p -> (%p)\n", iface, pmt); + return Capture_GetMediaType(This->myCap, pmt); +} + +static HRESULT WINAPI AMStreamConfig_GetNumberOfCapabilities(IAMStreamConfig *iface, int *piCount, int *piSize) +{ + FIXME("%p: %p %p - stub, intentional\n", iface, piCount, piSize); + return E_NOTIMPL; /* Not implemented for this interface */ +} + +static HRESULT WINAPI AMStreamConfig_GetStreamCaps(IAMStreamConfig *iface, +int iIndex, AM_MEDIA_TYPE **pmt, BYTE *pSCC) +{ + FIXME("%p: %d %p %p - stub, intentional\n", iface, iIndex, pmt, pSCC); + return E_NOTIMPL; /* Not implemented for this interface */ +} + +static const IAMStreamConfigVtbl IAMStreamConfig_VTable = +{ + AMStreamConfig_QueryInterface, + AMStreamConfig_AddRef, + AMStreamConfig_Release, + AMStreamConfig_SetFormat, + AMStreamConfig_GetFormat, + AMStreamConfig_GetNumberOfCapabilities, + AMStreamConfig_GetStreamCaps +}; + +/* IKsPropertySet interface */ +static HRESULT WINAPI KSP_QueryInterface(IKsPropertySet * iface, REFIID riid, LPVOID * ppv) +{ + if (IsEqualIID(riid, &IID_IUnknown) || + IsEqualIID(riid, &IID_IKsPropertySet)) + { + *ppv = (LPVOID)iface; + return S_OK; + } + + FIXME("No interface for iid %s\n", qcdebugstr_guid(riid)); + return E_NOINTERFACE; +} + +static ULONG WINAPI KSP_AddRef(IKsPropertySet * iface) +{ + ICOM_THIS_MULTI(VfwPinImpl, KSP_VT, iface); + TRACE("%p --> Forwarding to VfwPin (%p)\n", iface, This); + return IUnknown_AddRef((IUnknown *)This); +} + +static ULONG WINAPI KSP_Release(IKsPropertySet * iface) +{ + ICOM_THIS_MULTI(VfwPinImpl, KSP_VT, iface); + TRACE("%p --> Forwarding to VfwPin (%p)\n", iface, This); + return IUnknown_Release((IUnknown *)This); +} + +static HRESULT WINAPI KSP_Set(IKsPropertySet * iface, REFGUID guidPropSet, DWORD dwPropID, LPVOID pInstanceData, DWORD cbInstanceData, LPVOID pPropData, DWORD cbPropData) +{ + FIXME("%p: stub\n", iface); + return E_NOTIMPL; +} + +static HRESULT WINAPI KSP_Get(IKsPropertySet * iface, REFGUID guidPropSet, DWORD dwPropID, LPVOID pInstanceData, DWORD cbInstanceData, LPVOID pPropData, DWORD cbPropData, DWORD *pcbReturned) +{ + TRACE("()\n"); + if (!IsEqualIID(guidPropSet, &ROPSETID_Pin)) + return E_PROP_SET_UNSUPPORTED; + if (pPropData == NULL && pcbReturned == NULL) + return E_POINTER; + if (pcbReturned) + *pcbReturned = sizeof(GUID); + if (pPropData == NULL) + return S_OK; + if (cbPropData < sizeof(GUID)) + return E_UNEXPECTED; + *(GUID *)pPropData = PIN_CATEGORY_PREVIEW; + FIXME("() Not adding a pin with PIN_CATEGORY_CAPTURE for a reason..\n"); + return S_OK; +} + +static HRESULT WINAPI KSP_QuerySupported(IKsPropertySet * iface, REFGUID guidPropSet, DWORD dwPropID, DWORD *pTypeSupport) +{ + FIXME("%p: stub\n", iface); + return E_NOTIMPL; +} + +static IKsPropertySetVtbl KSP_VTable = +{ + KSP_QueryInterface, + KSP_AddRef, + KSP_Release, + KSP_Set, + KSP_Get, + KSP_QuerySupported +}; + +static HRESULT VfwPin_Construct(IBaseFilter * pBaseFilter, LPCRITICAL_SECTION pCritSec, IPin ** ppPin) +{ + ALLOCATOR_PROPERTIES ap; + VfwPinImpl * pPinImpl; + PIN_INFO piOutput; + + pPinImpl = CoTaskMemAlloc(sizeof(*pPinImpl)); + if (!pPinImpl) + return E_OUTOFMEMORY; + + ap.cBuffers = 3; + ap.cbBuffer = 230400; + ap.cbAlign = 1; + ap.cbPrefix = 0; + + piOutput.dir = PINDIR_OUTPUT; + piOutput.pFilter = pBaseFilter; + strcpyW(piOutput.achName, wszOutputPinName); + + if (SUCCEEDED(OutputPin_Init(&piOutput, &ap, pBaseFilter, NULL, pCritSec, &pPinImpl->pin))) + { + pPinImpl->KSP_VT = &KSP_VTable; + pPinImpl->pin.pin.lpVtbl = &VfwPin_Vtbl; + *ppPin = (IPin *)(&pPinImpl->pin.pin.lpVtbl); + return S_OK; + } + return E_FAIL; +} + +static HRESULT WINAPI VfwPin_QueryInterface(IPin * iface, REFIID riid, LPVOID * ppv) +{ + VfwPinImpl *This = (VfwPinImpl *)iface; + TRACE("%s %p\n", qcdebugstr_guid(riid), ppv); + *ppv = NULL; + if (IsEqualIID(riid, &IID_IUnknown)) + *ppv = (LPVOID)This; + else if (IsEqualIID(riid, &IID_IPin)) + *ppv = (LPVOID)This; + else if (IsEqualIID(riid, &IID_IKsPropertySet)) + *ppv = (LPVOID)&(This->KSP_VT); + + if (*ppv) + { + IUnknown_AddRef((IUnknown *)(*ppv)); + return S_OK; + } + + FIXME("No interface for %s!\n", qcdebugstr_guid(riid)); + return E_NOINTERFACE; +} + +static ULONG WINAPI VfwPin_AddRef(IPin * iface) +{ + VfwPinImpl *This = (VfwPinImpl *)iface; + ULONG refCount = InterlockedIncrement(&This->pin.pin.refCount); + + TRACE("() -> new refcount: %lu\n", refCount); + + return refCount; +} + +static ULONG WINAPI VfwPin_Release(IPin * iface) +{ + VfwPinImpl *This = (VfwPinImpl *)iface; + ULONG refCount = InterlockedDecrement(&This->pin.pin.refCount); + TRACE("() -> new refcount: %lu\n", refCount); + + if (!refCount) + { + CoTaskMemFree(This); + return 0; + } + return refCount; +} + +static HRESULT WINAPI VfwPin_EnumMediaTypes(IPin * iface, IEnumMediaTypes ** ppEnum) +{ + ENUMMEDIADETAILS emd; + AM_MEDIA_TYPE *pmt; + HRESULT hr; + + VfwPinImpl *This = (VfwPinImpl *)iface; + emd.cMediaTypes = 1; + hr = Capture_GetMediaType(This->myCap, &pmt); + emd.pMediaTypes = pmt; + if (SUCCEEDED(hr)) hr = IEnumMediaTypesImpl_Construct(&emd, ppEnum); + TRACE("%p -- %lx\n", This, hr); + DeleteMediaType(pmt); + return hr; +} + +static HRESULT WINAPI VfwPin_QueryInternalConnections(IPin * iface, IPin ** apPin, ULONG * cPin) +{ + TRACE("(%p)->(%p, %p)\n", iface, apPin, cPin); + return E_NOTIMPL; +} + +static HRESULT WINAPI VfwPin_EndOfStream(IPin * iface) +{ + TRACE("()\n"); + return E_UNEXPECTED; +} + +static HRESULT WINAPI VfwPin_BeginFlush(IPin * iface) +{ + TRACE("(%p)->()\n", iface); + return E_UNEXPECTED; +} + +static HRESULT WINAPI VfwPin_EndFlush(IPin * iface) +{ + TRACE("(%p)->()\n", iface); + return E_UNEXPECTED; +} + +static HRESULT WINAPI VfwPin_NewSegment(IPin * iface, REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate) +{ + TRACE("(%p)->(%lx%08lx, %lx%08lx, %e)\n", iface, (ULONG)(tStart >> 32), (ULONG)tStart, (ULONG)(tStop >> 32), (ULONG)tStop, dRate); + return E_UNEXPECTED; +} + +static const IPinVtbl VfwPin_Vtbl = +{ + VfwPin_QueryInterface, + VfwPin_AddRef, + VfwPin_Release, + OutputPin_Connect, + OutputPin_ReceiveConnection, + OutputPin_Disconnect, + IPinImpl_ConnectedTo, + IPinImpl_ConnectionMediaType, + IPinImpl_QueryPinInfo, + IPinImpl_QueryDirection, + IPinImpl_QueryId, + IPinImpl_QueryAccept, + VfwPin_EnumMediaTypes, + VfwPin_QueryInternalConnections, + VfwPin_EndOfStream, + VfwPin_BeginFlush, + VfwPin_EndFlush, + VfwPin_NewSegment +}; +
On Sun, 01 May 2005 03:00:28 +0200, Maarten Lankhorst wrote:
I thought I'd move it around a little and put it in qcap, where I *think* it should reside, I know CaptureGraphBuilder has to, so I moved it to
Hi Maarten,
Do you think this is ready to go into CVS? If so could you submit it to wine-patches ?
thanks -mike
-
Maarten Lankhorst -
Mike Hearn