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