dlls/winegstreamer/main.c

   1 /* GStreamer Base Functions
   2  *
   3  * Copyright 2002 Lionel Ulmer
   4  * Copyright 2010 Aric Stewart, CodeWeavers
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #define WINE_NO_NAMELESS_EXTENSION
  22
  23 #include "gst_private.h"
  24 #include "winternl.h"
  25 #include "rpcproxy.h"
  26
  27 #include "initguid.h"
  28 #include "gst_guids.h"
  29
  30 LONG object_locks;
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(quartz);
  33
  34 const struct unix_funcs *unix_funcs = NULL;
  35
  36 BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, void *reserved)
  37 {
  38     if (reason == DLL_PROCESS_ATTACH)
  39     {
  40         DisableThreadLibraryCalls(instance);
  41         __wine_init_unix_lib(instance, reason, NULL, &unix_funcs);
  42     }
  43     return TRUE;
  44 }
  45
  46 HRESULT WINAPI DllCanUnloadNow(void)
  47 {
  48     TRACE(".\n");
  49
  50     return object_locks ? S_FALSE : S_OK;
  51 }
  52
  53 struct class_factory
  54 {
  55     IClassFactory IClassFactory_iface;
  56     HRESULT (*create_instance)(IUnknown *outer, IUnknown **out);
  57 };
  58
  59 static inline struct class_factory *impl_from_IClassFactory(IClassFactory *iface)
  60 {
  61     return CONTAINING_RECORD(iface, struct class_factory, IClassFactory_iface);
  62 }
  63
  64 static HRESULT WINAPI class_factory_QueryInterface(IClassFactory *iface, REFIID iid, void **out)
  65 {
  66     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
  67
  68     if (IsEqualGUID(iid, &IID_IUnknown) || IsEqualGUID(iid, &IID_IClassFactory))
  69     {
  70         *out = iface;
  71         IClassFactory_AddRef(iface);
  72         return S_OK;
  73     }
  74
  75     *out = NULL;
  76     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
  77     return E_NOINTERFACE;
  78 }
  79
  80 static ULONG WINAPI class_factory_AddRef(IClassFactory *iface)
  81 {
  82     return 2;
  83 }
  84
  85 static ULONG WINAPI class_factory_Release(IClassFactory *iface)
  86 {
  87     return 1;
  88 }
  89
  90 static HRESULT WINAPI class_factory_CreateInstance(IClassFactory *iface, IUnknown *outer, REFIID iid, void **out)
  91 {
  92     struct class_factory *factory = impl_from_IClassFactory(iface);
  93     IUnknown *unk;
  94     HRESULT hr;
  95
  96     TRACE("iface %p, outer %p, iid %s, out %p.\n", iface, outer, debugstr_guid(iid), out);
  97
  98     if (outer && !IsEqualGUID(iid, &IID_IUnknown))
  99         return E_NOINTERFACE;
 100
 101     *out = NULL;
 102     if (SUCCEEDED(hr = factory->create_instance(outer, &unk)))
 103     {
 104         hr = IUnknown_QueryInterface(unk, iid, out);
 105         IUnknown_Release(unk);
 106     }
 107     return hr;
 108 }
 109
 110 static HRESULT WINAPI class_factory_LockServer(IClassFactory *iface, BOOL lock)
 111 {
 112     TRACE("iface %p, lock %d.\n", iface, lock);
 113
 114     if (lock)
 115         InterlockedIncrement(&object_locks);
 116     else
 117         InterlockedDecrement(&object_locks);
 118     return S_OK;
 119 }
 120
 121 static const IClassFactoryVtbl class_factory_vtbl =
 122 {
 123     class_factory_QueryInterface,
 124     class_factory_AddRef,
 125     class_factory_Release,
 126     class_factory_CreateInstance,
 127     class_factory_LockServer,
 128 };
 129
 130 static struct class_factory avi_splitter_cf = {{&class_factory_vtbl}, avi_splitter_create};
 131 static struct class_factory decodebin_parser_cf = {{&class_factory_vtbl}, decodebin_parser_create};
 132 static struct class_factory mpeg_splitter_cf = {{&class_factory_vtbl}, mpeg_splitter_create};
 133 static struct class_factory wave_parser_cf = {{&class_factory_vtbl}, wave_parser_create};
 134
 135 HRESULT WINAPI DllGetClassObject(REFCLSID clsid, REFIID iid, void **out)
 136 {
 137     struct class_factory *factory;
 138     HRESULT hr;
 139
 140     TRACE("clsid %s, iid %s, out %p.\n", debugstr_guid(clsid), debugstr_guid(iid), out);
 141
 142     if (!init_gstreamer())
 143         return CLASS_E_CLASSNOTAVAILABLE;
 144
 145     if (SUCCEEDED(hr = mfplat_get_class_object(clsid, iid, out)))
 146         return hr;
 147
 148     if (IsEqualGUID(clsid, &CLSID_AviSplitter))
 149         factory = &avi_splitter_cf;
 150     else if (IsEqualGUID(clsid, &CLSID_decodebin_parser))
 151         factory = &decodebin_parser_cf;
 152     else if (IsEqualGUID(clsid, &CLSID_MPEG1Splitter))
 153         factory = &mpeg_splitter_cf;
 154     else if (IsEqualGUID(clsid, &CLSID_WAVEParser))
 155         factory = &wave_parser_cf;
 156     else
 157     {
 158         FIXME("%s not implemented, returning CLASS_E_CLASSNOTAVAILABLE.\n", debugstr_guid(clsid));
 159         return CLASS_E_CLASSNOTAVAILABLE;
 160     }
 161
 162     return IClassFactory_QueryInterface(&factory->IClassFactory_iface, iid, out);
 163 }
 164
 165 static BOOL CALLBACK init_gstreamer_proc(INIT_ONCE *once, void *param, void **ctx)
 166 {
 167     HINSTANCE handle;
 168
 169     /* Unloading glib is a bad idea.. it installs atexit handlers,
 170      * so never unload the dll after loading */
 171     GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | GET_MODULE_HANDLE_EX_FLAG_PIN,
 172             (LPCWSTR)init_gstreamer_proc, &handle);
 173     if (!handle)
 174         ERR("Failed to pin module.\n");
 175
 176     return TRUE;
 177 }
 178
 179 BOOL init_gstreamer(void)
 180 {
 181     static INIT_ONCE once = INIT_ONCE_STATIC_INIT;
 182
 183     InitOnceExecuteOnce(&once, init_gstreamer_proc, NULL, NULL);
 184
 185     return TRUE;
 186 }
 187
 188 static const REGPINTYPES reg_audio_mt = {&MEDIATYPE_Audio, &GUID_NULL};
 189 static const REGPINTYPES reg_stream_mt = {&MEDIATYPE_Stream, &GUID_NULL};
 190 static const REGPINTYPES reg_video_mt = {&MEDIATYPE_Video, &GUID_NULL};
 191
 192 static const REGPINTYPES reg_avi_splitter_sink_mt = {&MEDIATYPE_Stream, &MEDIASUBTYPE_Avi};
 193
 194 static const REGFILTERPINS2 reg_avi_splitter_pins[2] =
 195 {
 196     {
 197         .nMediaTypes = 1,
 198         .lpMediaType = &reg_avi_splitter_sink_mt,
 199     },
 200     {
 201         .dwFlags = REG_PINFLAG_B_OUTPUT,
 202         .nMediaTypes = 1,
 203         .lpMediaType = &reg_video_mt,
 204     },
 205 };
 206
 207 static const REGFILTER2 reg_avi_splitter =
 208 {
 209     .dwVersion = 2,
 210     .dwMerit = MERIT_NORMAL,
 211     .u.s2.cPins2 = 2,
 212     .u.s2.rgPins2 = reg_avi_splitter_pins,
 213 };
 214
 215 static const REGPINTYPES reg_mpeg_splitter_sink_mts[4] =
 216 {
 217     {&MEDIATYPE_Stream, &MEDIASUBTYPE_MPEG1Audio},
 218     {&MEDIATYPE_Stream, &MEDIASUBTYPE_MPEG1Video},
 219     {&MEDIATYPE_Stream, &MEDIASUBTYPE_MPEG1System},
 220     {&MEDIATYPE_Stream, &MEDIASUBTYPE_MPEG1VideoCD},
 221 };
 222
 223 static const REGPINTYPES reg_mpeg_splitter_audio_mts[2] =
 224 {
 225     {&MEDIATYPE_Audio, &MEDIASUBTYPE_MPEG1Packet},
 226     {&MEDIATYPE_Audio, &MEDIASUBTYPE_MPEG1AudioPayload},
 227 };
 228
 229 static const REGPINTYPES reg_mpeg_splitter_video_mts[2] =
 230 {
 231     {&MEDIATYPE_Video, &MEDIASUBTYPE_MPEG1Packet},
 232     {&MEDIATYPE_Video, &MEDIASUBTYPE_MPEG1Payload},
 233 };
 234
 235 static const REGFILTERPINS2 reg_mpeg_splitter_pins[3] =
 236 {
 237     {
 238         .nMediaTypes = 4,
 239         .lpMediaType = reg_mpeg_splitter_sink_mts,
 240     },
 241     {
 242         .dwFlags = REG_PINFLAG_B_ZERO | REG_PINFLAG_B_OUTPUT,
 243         .nMediaTypes = 2,
 244         .lpMediaType = reg_mpeg_splitter_audio_mts,
 245     },
 246     {
 247         .dwFlags = REG_PINFLAG_B_ZERO | REG_PINFLAG_B_OUTPUT,
 248         .nMediaTypes = 2,
 249         .lpMediaType = reg_mpeg_splitter_video_mts,
 250     },
 251 };
 252
 253 static const REGFILTER2 reg_mpeg_splitter =
 254 {
 255     .dwVersion = 2,
 256     .dwMerit = MERIT_NORMAL,
 257     .u.s2.cPins2 = 3,
 258     .u.s2.rgPins2 = reg_mpeg_splitter_pins,
 259 };
 260
 261 static const REGPINTYPES reg_wave_parser_sink_mts[3] =
 262 {
 263     {&MEDIATYPE_Stream, &MEDIASUBTYPE_WAVE},
 264     {&MEDIATYPE_Stream, &MEDIASUBTYPE_AU},
 265     {&MEDIATYPE_Stream, &MEDIASUBTYPE_AIFF},
 266 };
 267
 268 static const REGFILTERPINS2 reg_wave_parser_pins[2] =
 269 {
 270     {
 271         .nMediaTypes = 3,
 272         .lpMediaType = reg_wave_parser_sink_mts,
 273     },
 274     {
 275         .dwFlags = REG_PINFLAG_B_OUTPUT,
 276         .nMediaTypes = 1,
 277         .lpMediaType = &reg_audio_mt,
 278     },
 279 };
 280
 281 static const REGFILTER2 reg_wave_parser =
 282 {
 283     .dwVersion = 2,
 284     .dwMerit = MERIT_UNLIKELY,
 285     .u.s2.cPins2 = 2,
 286     .u.s2.rgPins2 = reg_wave_parser_pins,
 287 };
 288
 289 static const REGFILTERPINS2 reg_decodebin_parser_pins[3] =
 290 {
 291     {
 292         .nMediaTypes = 1,
 293         .lpMediaType = &reg_stream_mt,
 294     },
 295     {
 296         .dwFlags = REG_PINFLAG_B_OUTPUT,
 297         .nMediaTypes = 1,
 298         .lpMediaType = &reg_audio_mt,
 299     },
 300     {
 301         .dwFlags = REG_PINFLAG_B_OUTPUT,
 302         .nMediaTypes = 1,
 303         .lpMediaType = &reg_video_mt,
 304     },
 305 };
 306
 307 static const REGFILTER2 reg_decodebin_parser =
 308 {
 309     .dwVersion = 2,
 310     .dwMerit = MERIT_PREFERRED,
 311     .u.s2.cPins2 = 3,
 312     .u.s2.rgPins2 = reg_decodebin_parser_pins,
 313 };
 314
 315 HRESULT WINAPI DllRegisterServer(void)
 316 {
 317     IFilterMapper2 *mapper;
 318     HRESULT hr;
 319
 320     TRACE(".\n");
 321
 322     if (FAILED(hr = __wine_register_resources()))
 323         return hr;
 324
 325     if (FAILED(hr = CoCreateInstance(&CLSID_FilterMapper2, NULL, CLSCTX_INPROC_SERVER,
 326             &IID_IFilterMapper2, (void **)&mapper)))
 327         return hr;
 328
 329     IFilterMapper2_RegisterFilter(mapper, &CLSID_AviSplitter, L"AVI Splitter", NULL, NULL, NULL, &reg_avi_splitter);
 330     IFilterMapper2_RegisterFilter(mapper, &CLSID_decodebin_parser,
 331             L"GStreamer splitter filter", NULL, NULL, NULL, &reg_decodebin_parser);
 332     IFilterMapper2_RegisterFilter(mapper, &CLSID_MPEG1Splitter,
 333             L"MPEG-I Stream Splitter", NULL, NULL, NULL, &reg_mpeg_splitter);
 334     IFilterMapper2_RegisterFilter(mapper, &CLSID_WAVEParser, L"Wave Parser", NULL, NULL, NULL, &reg_wave_parser);
 335
 336     IFilterMapper2_Release(mapper);
 337
 338     return mfplat_DllRegisterServer();
 339 }
 340
 341 HRESULT WINAPI DllUnregisterServer(void)
 342 {
 343     IFilterMapper2 *mapper;
 344     HRESULT hr;
 345
 346     TRACE(".\n");
 347
 348     if (FAILED(hr = __wine_unregister_resources()))
 349         return hr;
 350
 351     if (FAILED(hr = CoCreateInstance(&CLSID_FilterMapper2, NULL, CLSCTX_INPROC_SERVER,
 352             &IID_IFilterMapper2, (void **)&mapper)))
 353         return hr;
 354
 355     IFilterMapper2_UnregisterFilter(mapper, NULL, NULL, &CLSID_AviSplitter);
 356     IFilterMapper2_UnregisterFilter(mapper, NULL, NULL, &CLSID_decodebin_parser);
 357     IFilterMapper2_UnregisterFilter(mapper, NULL, NULL, &CLSID_MPEG1Splitter);
 358     IFilterMapper2_UnregisterFilter(mapper, NULL, NULL, &CLSID_WAVEParser);
 359
 360     IFilterMapper2_Release(mapper);
 361     return S_OK;
 362 }