dlls/quartz/main.c

   1 /*              DirectShow Base Functions (QUARTZ.DLL)
   2  *
   3  * Copyright 2002 Lionel Ulmer
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #include "wine/debug.h"
  21
  22 #include "quartz_private.h"
  23
  24 WINE_DEFAULT_DEBUG_CHANNEL(quartz);
  25
  26 extern HRESULT WINAPI QUARTZ_DllGetClassObject(REFCLSID, REFIID, LPVOID *) DECLSPEC_HIDDEN;
  27 extern BOOL WINAPI QUARTZ_DllMain(HINSTANCE, DWORD, LPVOID) DECLSPEC_HIDDEN;
  28
  29 BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, void *reserved)
  30 {
  31     if (reason == DLL_PROCESS_DETACH && !reserved)
  32     {
  33         video_window_unregister_class();
  34         strmbase_release_typelibs();
  35     }
  36     return QUARTZ_DllMain(instance, reason, reserved);
  37 }
  38
  39 /******************************************************************************
  40  * DirectShow ClassFactory
  41  */
  42 typedef struct {
  43     IClassFactory IClassFactory_iface;
  44     LONG ref;
  45     HRESULT (*create_instance)(IUnknown *outer, IUnknown **out);
  46 } IClassFactoryImpl;
  47
  48 static inline IClassFactoryImpl *impl_from_IClassFactory(IClassFactory *iface)
  49 {
  50     return CONTAINING_RECORD(iface, IClassFactoryImpl, IClassFactory_iface);
  51 }
  52
  53 struct object_creation_info
  54 {
  55     const CLSID *clsid;
  56     HRESULT (*create_instance)(IUnknown *outer, IUnknown **out);
  57 };
  58
  59 static const struct object_creation_info object_creation[] =
  60 {
  61     { &CLSID_ACMWrapper, acm_wrapper_create },
  62     { &CLSID_AsyncReader, async_reader_create },
  63     { &CLSID_AudioRender, dsound_render_create },
  64     { &CLSID_AVIDec, avi_dec_create },
  65     { &CLSID_DSoundRender, dsound_render_create },
  66     { &CLSID_FilterGraph, filter_graph_create },
  67     { &CLSID_FilterGraphNoThread, filter_graph_no_thread_create },
  68     { &CLSID_FilterMapper, filter_mapper_create },
  69     { &CLSID_FilterMapper2, filter_mapper_create },
  70     { &CLSID_MemoryAllocator, mem_allocator_create },
  71     { &CLSID_SeekingPassThru, seeking_passthrough_create },
  72     { &CLSID_SystemClock, system_clock_create },
  73     { &CLSID_VideoRenderer, video_renderer_create },
  74     { &CLSID_VideoMixingRenderer, vmr7_create },
  75     { &CLSID_VideoMixingRenderer9, vmr9_create },
  76     { &CLSID_VideoRendererDefault, video_renderer_default_create },
  77 };
  78
  79 static HRESULT WINAPI DSCF_QueryInterface(IClassFactory *iface, REFIID riid, void **ppobj)
  80 {
  81     if (IsEqualGUID(riid, &IID_IUnknown)
  82         || IsEqualGUID(riid, &IID_IClassFactory))
  83     {
  84         IClassFactory_AddRef(iface);
  85         *ppobj = iface;
  86         return S_OK;
  87     }
  88
  89     *ppobj = NULL;
  90     WARN("(%p)->(%s,%p), not found\n", iface, debugstr_guid(riid), ppobj);
  91     return E_NOINTERFACE;
  92 }
  93
  94 static ULONG WINAPI DSCF_AddRef(IClassFactory *iface)
  95 {
  96     IClassFactoryImpl *This = impl_from_IClassFactory(iface);
  97     return InterlockedIncrement(&This->ref);
  98 }
  99
 100 static ULONG WINAPI DSCF_Release(IClassFactory *iface)
 101 {
 102     IClassFactoryImpl *This = impl_from_IClassFactory(iface);
 103     ULONG ref = InterlockedDecrement(&This->ref);
 104
 105     if (ref == 0)
 106         CoTaskMemFree(This);
 107
 108     return ref;
 109 }
 110
 111
 112 static HRESULT WINAPI DSCF_CreateInstance(IClassFactory *iface, IUnknown *pOuter,
 113                                           REFIID riid, void **ppobj)
 114 {
 115     IClassFactoryImpl *This = impl_from_IClassFactory(iface);
 116     HRESULT hres;
 117     LPUNKNOWN punk;
 118
 119     TRACE("(%p)->(%p,%s,%p)\n",This,pOuter,debugstr_guid(riid),ppobj);
 120
 121     *ppobj = NULL;
 122     if(pOuter && !IsEqualGUID(&IID_IUnknown, riid))
 123         return E_NOINTERFACE;
 124
 125     if (SUCCEEDED(hres = This->create_instance(pOuter, &punk)))
 126     {
 127         hres = IUnknown_QueryInterface(punk, riid, ppobj);
 128         IUnknown_Release(punk);
 129     }
 130     return hres;
 131 }
 132
 133 static HRESULT WINAPI DSCF_LockServer(IClassFactory *iface, BOOL lock)
 134 {
 135     FIXME("iface %p, lock %d, stub!\n", iface, lock);
 136     return S_OK;
 137 }
 138
 139 static const IClassFactoryVtbl DSCF_Vtbl =
 140 {
 141     DSCF_QueryInterface,
 142     DSCF_AddRef,
 143     DSCF_Release,
 144     DSCF_CreateInstance,
 145     DSCF_LockServer
 146 };
 147
 148 /*******************************************************************************
 149  * DllGetClassObject [QUARTZ.@]
 150  * Retrieves class object from a DLL object
 151  *
 152  * NOTES
 153  *    Docs say returns STDAPI
 154  *
 155  * PARAMS
 156  *    rclsid [I] CLSID for the class object
 157  *    riid   [I] Reference to identifier of interface for class object
 158  *    ppv    [O] Address of variable to receive interface pointer for riid
 159  *
 160  * RETURNS
 161  *    Success: S_OK
 162  *    Failure: CLASS_E_CLASSNOTAVAILABLE, E_OUTOFMEMORY, E_INVALIDARG,
 163  *             E_UNEXPECTED
 164  */
 165 HRESULT WINAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv)
 166 {
 167     unsigned int i;
 168
 169     TRACE("(%s,%s,%p)\n", debugstr_guid(rclsid), debugstr_guid(riid), ppv);
 170
 171     if (IsEqualGUID( &IID_IClassFactory, riid ) || IsEqualGUID( &IID_IUnknown, riid))
 172     {
 173         for (i = 0; i < ARRAY_SIZE(object_creation); i++)
 174         {
 175             if (IsEqualGUID(object_creation[i].clsid, rclsid))
 176             {
 177                 IClassFactoryImpl *factory = CoTaskMemAlloc(sizeof(*factory));
 178                 if (factory == NULL) return E_OUTOFMEMORY;
 179
 180                 factory->IClassFactory_iface.lpVtbl = &DSCF_Vtbl;
 181                 factory->ref = 1;
 182
 183                 factory->create_instance = object_creation[i].create_instance;
 184
 185                 *ppv = &factory->IClassFactory_iface;
 186                 return S_OK;
 187             }
 188         }
 189     }
 190     return QUARTZ_DllGetClassObject( rclsid, riid, ppv );
 191 }
 192
 193 #define OUR_GUID_ENTRY(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \
 194     { { l, w1, w2, { b1, b2,  b3,  b4,  b5,  b6,  b7,  b8 } } , #name },
 195
 196 static const struct {
 197         const GUID      riid;
 198         const char      *name;
 199 } InterfaceDesc[] =
 200 {
 201 #include "uuids.h"
 202     { { 0, 0, 0, {0, 0, 0, 0, 0, 0, 0, 0} }, NULL }
 203 };
 204
 205 /***********************************************************************
 206  *              proxies
 207  */
 208 HRESULT CALLBACK ICaptureGraphBuilder_FindInterface_Proxy( ICaptureGraphBuilder *This,
 209                                                            const GUID *pCategory,
 210                                                            IBaseFilter *pf,
 211                                                            REFIID riid,
 212                                                            void **ppint )
 213 {
 214     return ICaptureGraphBuilder_RemoteFindInterface_Proxy( This, pCategory, pf,
 215                                                            riid, (IUnknown **)ppint );
 216 }
 217
 218 HRESULT __RPC_STUB ICaptureGraphBuilder_FindInterface_Stub( ICaptureGraphBuilder *This,
 219                                                             const GUID *pCategory,
 220                                                             IBaseFilter *pf,
 221                                                             REFIID riid,
 222                                                             IUnknown **ppint )
 223 {
 224     return ICaptureGraphBuilder_FindInterface( This, pCategory, pf, riid, (void **)ppint );
 225 }
 226
 227 HRESULT CALLBACK ICaptureGraphBuilder2_FindInterface_Proxy( ICaptureGraphBuilder2 *This,
 228                                                             const GUID *pCategory,
 229                                                             const GUID *pType,
 230                                                             IBaseFilter *pf,
 231                                                             REFIID riid,
 232                                                             void **ppint )
 233 {
 234     return ICaptureGraphBuilder2_RemoteFindInterface_Proxy( This, pCategory, pType,
 235                                                             pf, riid, (IUnknown **)ppint );
 236 }
 237
 238 HRESULT __RPC_STUB ICaptureGraphBuilder2_FindInterface_Stub( ICaptureGraphBuilder2 *This,
 239                                                              const GUID *pCategory,
 240                                                              const GUID *pType,
 241                                                              IBaseFilter *pf,
 242                                                              REFIID riid,
 243                                                              IUnknown **ppint )
 244 {
 245     return ICaptureGraphBuilder2_FindInterface( This, pCategory, pType, pf, riid, (void **)ppint );
 246 }
 247
 248 /***********************************************************************
 249  *              qzdebugstr_guid (internal)
 250  *
 251  * Gives a text version of DirectShow GUIDs
 252  */
 253 const char * qzdebugstr_guid( const GUID * id )
 254 {
 255     int i;
 256
 257     for (i=0; InterfaceDesc[i].name; i++)
 258         if (IsEqualGUID(&InterfaceDesc[i].riid, id)) return InterfaceDesc[i].name;
 259
 260     return debugstr_guid(id);
 261 }
 262
 263 LONG WINAPI AmpFactorToDB(LONG ampfactor)
 264 {
 265     FIXME("(%d) Stub!\n", ampfactor);
 266     return 0;
 267 }
 268
 269 LONG WINAPI DBToAmpFactor(LONG db)
 270 {
 271     FIXME("(%d) Stub!\n", db);
 272     /* Avoid divide by zero (probably during range computation) in Windows Media Player 6.4 */
 273     if (db < -1000)
 274         return 0;
 275     return 100;
 276 }
 277
 278 /***********************************************************************
 279  *              AMGetErrorTextA (QUARTZ.@)
 280  */
 281 DWORD WINAPI AMGetErrorTextA(HRESULT hr, LPSTR buffer, DWORD maxlen)
 282 {
 283     DWORD res;
 284     WCHAR errorW[MAX_ERROR_TEXT_LEN];
 285
 286     TRACE("(%x,%p,%d)\n", hr, buffer, maxlen);
 287     if (!buffer)
 288         return 0;
 289
 290     res = AMGetErrorTextW(hr, errorW, ARRAY_SIZE(errorW));
 291     if (!res)
 292         return 0;
 293
 294     res = WideCharToMultiByte(CP_ACP, 0, errorW, -1, NULL, 0, 0, 0);
 295     if (res > maxlen || !res)
 296         return 0;
 297     return WideCharToMultiByte(CP_ACP, 0, errorW, -1, buffer, maxlen, 0, 0) - 1;
 298 }
 299
 300 /***********************************************************************
 301  *              AMGetErrorTextW (QUARTZ.@)
 302  */
 303 DWORD WINAPI AMGetErrorTextW(HRESULT hr, LPWSTR buffer, DWORD maxlen)
 304 {
 305     unsigned int len;
 306     WCHAR error[MAX_ERROR_TEXT_LEN];
 307
 308     FIXME("(%x,%p,%d) stub\n", hr, buffer, maxlen);
 309
 310     if (!buffer) return 0;
 311     swprintf(error, ARRAY_SIZE(error), L"Error: 0x%lx", hr);
 312     if ((len = wcslen(error)) >= maxlen)
 313         return 0;
 314     wcscpy(buffer, error);
 315     return len;
 316 }