dlls/wmphoto/main.c

   1 /*
   2  * Copyright 2017 Vincent Povirk for CodeWeavers
   3  * Copyright 2020 Rémi Bernon for CodeWeavers
   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 <stdarg.h>
  21
  22 #define COBJMACROS
  23
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "objbase.h"
  27 #include "rpcproxy.h"
  28
  29 #include "wincodecs_private.h"
  30 #include "wine/debug.h"
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(wincodecs);
  33
  34 HRESULT create_instance(const CLSID *clsid, const IID *iid, void **ppv)
  35 {
  36     return CoCreateInstance(clsid, NULL, CLSCTX_INPROC_SERVER, iid, ppv);
  37 }
  38
  39 HRESULT get_decoder_info(REFCLSID clsid, IWICBitmapDecoderInfo **info)
  40 {
  41     IWICImagingFactory* factory;
  42     IWICComponentInfo *compinfo;
  43     HRESULT hr;
  44
  45     hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER,
  46                           &IID_IWICImagingFactory, (void **)&factory);
  47     if (FAILED(hr))
  48         return hr;
  49
  50     hr = IWICImagingFactory_CreateComponentInfo(factory, clsid, &compinfo);
  51     if (FAILED(hr))
  52     {
  53         IWICImagingFactory_Release(factory);
  54         return hr;
  55     }
  56
  57     hr = IWICComponentInfo_QueryInterface(compinfo, &IID_IWICBitmapDecoderInfo,
  58         (void **)info);
  59
  60     IWICComponentInfo_Release(compinfo);
  61     IWICImagingFactory_Release(factory);
  62     return hr;
  63 }
  64
  65 struct class_factory
  66 {
  67     IClassFactory IClassFactory_iface;
  68 };
  69
  70 static HRESULT WINAPI wmp_class_factory_QueryInterface(IClassFactory *iface, REFIID iid, void **out)
  71 {
  72     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
  73
  74     if (IsEqualGUID(iid, &IID_IUnknown) || IsEqualGUID(iid, &IID_IClassFactory))
  75     {
  76         *out = iface;
  77         IClassFactory_AddRef(iface);
  78         return S_OK;
  79     }
  80
  81     *out = NULL;
  82     FIXME("%s not implemented.\n", debugstr_guid(iid));
  83     return E_NOINTERFACE;
  84 }
  85
  86 static ULONG WINAPI wmp_class_factory_AddRef(IClassFactory *iface) { return 2; }
  87
  88 static ULONG WINAPI wmp_class_factory_Release(IClassFactory *iface) { return 1; }
  89
  90 static HRESULT WINAPI wmp_class_factory_CreateInstance(IClassFactory *iface, IUnknown *outer, REFIID iid, void **out)
  91 {
  92     struct decoder_info decoder_info;
  93     struct decoder *decoder;
  94     HRESULT hr;
  95
  96     TRACE("iface %p, outer %p, iid %s, out %p.\n", iface, outer, debugstr_guid(iid), out);
  97
  98     *out = NULL;
  99     if (outer) return CLASS_E_NOAGGREGATION;
 100
 101     hr = get_unix_decoder(&CLSID_WICWmpDecoder, &decoder_info, &decoder);
 102
 103     if (SUCCEEDED(hr))
 104         hr = CommonDecoder_CreateInstance(decoder, &decoder_info, iid, out);
 105
 106     return hr;
 107 }
 108
 109 static HRESULT WINAPI wmp_class_factory_LockServer(IClassFactory *iface, BOOL lock)
 110 {
 111     FIXME("iface %p, lock %d, stub!\n", iface, lock);
 112     return S_OK;
 113 }
 114
 115 static const IClassFactoryVtbl wmp_class_factory_vtbl =
 116 {
 117     wmp_class_factory_QueryInterface,
 118     wmp_class_factory_AddRef,
 119     wmp_class_factory_Release,
 120     wmp_class_factory_CreateInstance,
 121     wmp_class_factory_LockServer,
 122 };
 123
 124 static struct class_factory wmp_class_factory = {{&wmp_class_factory_vtbl}};
 125
 126 HMODULE windowscodecs_module = 0;
 127
 128 BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID reserved)
 129 {
 130     TRACE("instance %p, reason %d, reserved %p\n", instance, reason, reserved);
 131
 132     switch (reason)
 133     {
 134     case DLL_PROCESS_ATTACH:
 135         windowscodecs_module = instance;
 136         DisableThreadLibraryCalls(instance);
 137         break;
 138     case DLL_WINE_PREATTACH:
 139         return FALSE; /* prefer native version */
 140     }
 141
 142     return TRUE;
 143 }
 144
 145 HRESULT WINAPI DllCanUnloadNow(void)
 146 {
 147     return S_FALSE;
 148 }
 149
 150 HRESULT WINAPI DllGetClassObject(REFCLSID clsid, REFIID iid, LPVOID *out)
 151 {
 152     struct class_factory *factory;
 153
 154     TRACE("clsid %s, iid %s, out %p.\n", debugstr_guid(clsid), debugstr_guid(iid), out);
 155
 156     if (IsEqualGUID(clsid, &CLSID_WICWmpDecoder)) factory = &wmp_class_factory;
 157     else
 158     {
 159         FIXME("%s not implemented.\n", debugstr_guid(clsid));
 160         return CLASS_E_CLASSNOTAVAILABLE;
 161     }
 162
 163     return IClassFactory_QueryInterface(&factory->IClassFactory_iface, iid, out);
 164 }
 165
 166 HRESULT WINAPI DllRegisterServer(void)
 167 {
 168     return __wine_register_resources( windowscodecs_module );
 169 }
 170
 171 HRESULT WINAPI DllUnregisterServer(void)
 172 {
 173     return __wine_unregister_resources( windowscodecs_module );
 174 }