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