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 (SUCCEEDED(hr = mfplat_get_class_object(clsid, iid, out)))
 150         return hr;
 151
 152     if (IsEqualGUID(clsid, &CLSID_AviSplitter))
 153         factory = &avi_splitter_cf;
 154     else if (IsEqualGUID(clsid, &CLSID_Gstreamer_Splitter))
 155         factory = &gstdemux_cf;
 156     else if (IsEqualGUID(clsid, &CLSID_MPEG1Splitter))
 157         factory = &mpeg_splitter_cf;
 158     else if (IsEqualGUID(clsid, &CLSID_WAVEParser))
 159         factory = &wave_parser_cf;
 160     else
 161     {
 162         FIXME("%s not implemented, returning CLASS_E_CLASSNOTAVAILABLE.\n", debugstr_guid(clsid));
 163         return CLASS_E_CLASSNOTAVAILABLE;
 164     }
 165
 166     return IClassFactory_QueryInterface(&factory->IClassFactory_iface, iid, out);
 167 }
 168
 169 static BOOL CALLBACK init_gstreamer_proc(INIT_ONCE *once, void *param, void **ctx)
 170 {
 171     BOOL *status = param;
 172     char argv0[] = "wine";
 173     char argv1[] = "--gst-disable-registry-fork";
 174     char *args[3];
 175     char **argv = args;
 176     int argc = 2;
 177     GError *err = NULL;
 178
 179     TRACE("Initializing...\n");
 180
 181     argv[0] = argv0;
 182     argv[1] = argv1;
 183     argv[2] = NULL;
 184     *status = gst_init_check(&argc, &argv, &err);
 185     if (*status)
 186     {
 187         HINSTANCE handle;
 188
 189         TRACE("Initialized, version %s. Built with %d.%d.%d.\n", gst_version_string(),
 190                 GST_VERSION_MAJOR, GST_VERSION_MINOR, GST_VERSION_MICRO);
 191
 192         /* Unloading glib is a bad idea.. it installs atexit handlers,
 193          * so never unload the dll after loading */
 194         GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | GET_MODULE_HANDLE_EX_FLAG_PIN,
 195                 (LPCWSTR)winegstreamer_instance, &handle);
 196         if (!handle)
 197             ERR("Failed to pin module %p.\n", winegstreamer_instance);
 198
 199         start_dispatch_thread();
 200     }
 201     else if (err)
 202     {
 203         ERR("Failed to initialize gstreamer: %s\n", debugstr_a(err->message));
 204         g_error_free(err);
 205     }
 206
 207     return TRUE;
 208 }
 209
 210 BOOL init_gstreamer(void)
 211 {
 212     static INIT_ONCE once = INIT_ONCE_STATIC_INIT;
 213     static BOOL status;
 214
 215     InitOnceExecuteOnce(&once, init_gstreamer_proc, &status, NULL);
 216
 217     return status;
 218 }
 219
 220 static const REGPINTYPES reg_audio_mt = {&MEDIATYPE_Audio, &GUID_NULL};
 221 static const REGPINTYPES reg_stream_mt = {&MEDIATYPE_Stream, &GUID_NULL};
 222 static const REGPINTYPES reg_video_mt = {&MEDIATYPE_Video, &GUID_NULL};
 223
 224 static const REGPINTYPES reg_avi_splitter_sink_mt = {&MEDIATYPE_Stream, &MEDIASUBTYPE_Avi};
 225
 226 static const REGFILTERPINS2 reg_avi_splitter_pins[2] =
 227 {
 228     {
 229         .nMediaTypes = 1,
 230         .lpMediaType = &reg_avi_splitter_sink_mt,
 231     },
 232     {
 233         .dwFlags = REG_PINFLAG_B_OUTPUT,
 234         .nMediaTypes = 1,
 235         .lpMediaType = &reg_video_mt,
 236     },
 237 };
 238
 239 static const REGFILTER2 reg_avi_splitter =
 240 {
 241     .dwVersion = 2,
 242     .dwMerit = MERIT_NORMAL,
 243     .u.s2.cPins2 = 2,
 244     .u.s2.rgPins2 = reg_avi_splitter_pins,
 245 };
 246
 247 static const REGPINTYPES reg_mpeg_splitter_sink_mts[4] =
 248 {
 249     {&MEDIATYPE_Stream, &MEDIASUBTYPE_MPEG1Audio},
 250     {&MEDIATYPE_Stream, &MEDIASUBTYPE_MPEG1Video},
 251     {&MEDIATYPE_Stream, &MEDIASUBTYPE_MPEG1System},
 252     {&MEDIATYPE_Stream, &MEDIASUBTYPE_MPEG1VideoCD},
 253 };
 254
 255 static const REGPINTYPES reg_mpeg_splitter_audio_mts[2] =
 256 {
 257     {&MEDIATYPE_Audio, &MEDIASUBTYPE_MPEG1Packet},
 258     {&MEDIATYPE_Audio, &MEDIASUBTYPE_MPEG1AudioPayload},
 259 };
 260
 261 static const REGPINTYPES reg_mpeg_splitter_video_mts[2] =
 262 {
 263     {&MEDIATYPE_Video, &MEDIASUBTYPE_MPEG1Packet},
 264     {&MEDIATYPE_Video, &MEDIASUBTYPE_MPEG1Payload},
 265 };
 266
 267 static const REGFILTERPINS2 reg_mpeg_splitter_pins[3] =
 268 {
 269     {
 270         .nMediaTypes = 4,
 271         .lpMediaType = reg_mpeg_splitter_sink_mts,
 272     },
 273     {
 274         .dwFlags = REG_PINFLAG_B_ZERO | REG_PINFLAG_B_OUTPUT,
 275         .nMediaTypes = 2,
 276         .lpMediaType = reg_mpeg_splitter_audio_mts,
 277     },
 278     {
 279         .dwFlags = REG_PINFLAG_B_ZERO | REG_PINFLAG_B_OUTPUT,
 280         .nMediaTypes = 2,
 281         .lpMediaType = reg_mpeg_splitter_video_mts,
 282     },
 283 };
 284
 285 static const REGFILTER2 reg_mpeg_splitter =
 286 {
 287     .dwVersion = 2,
 288     .dwMerit = MERIT_NORMAL,
 289     .u.s2.cPins2 = 3,
 290     .u.s2.rgPins2 = reg_mpeg_splitter_pins,
 291 };
 292
 293 static const REGPINTYPES reg_wave_parser_sink_mts[3] =
 294 {
 295     {&MEDIATYPE_Stream, &MEDIASUBTYPE_WAVE},
 296     {&MEDIATYPE_Stream, &MEDIASUBTYPE_AU},
 297     {&MEDIATYPE_Stream, &MEDIASUBTYPE_AIFF},
 298 };
 299
 300 static const REGFILTERPINS2 reg_wave_parser_pins[2] =
 301 {
 302     {
 303         .nMediaTypes = 3,
 304         .lpMediaType = reg_wave_parser_sink_mts,
 305     },
 306     {
 307         .dwFlags = REG_PINFLAG_B_OUTPUT,
 308         .nMediaTypes = 1,
 309         .lpMediaType = &reg_audio_mt,
 310     },
 311 };
 312
 313 static const REGFILTER2 reg_wave_parser =
 314 {
 315     .dwVersion = 2,
 316     .dwMerit = MERIT_UNLIKELY,
 317     .u.s2.cPins2 = 2,
 318     .u.s2.rgPins2 = reg_wave_parser_pins,
 319 };
 320
 321 static const REGFILTERPINS2 reg_gstdemux_pins[3] =
 322 {
 323     {
 324         .nMediaTypes = 1,
 325         .lpMediaType = &reg_stream_mt,
 326     },
 327     {
 328         .dwFlags = REG_PINFLAG_B_OUTPUT,
 329         .nMediaTypes = 1,
 330         .lpMediaType = &reg_audio_mt,
 331     },
 332     {
 333         .dwFlags = REG_PINFLAG_B_OUTPUT,
 334         .nMediaTypes = 1,
 335         .lpMediaType = &reg_video_mt,
 336     },
 337 };
 338
 339 static const REGFILTER2 reg_gstdemux =
 340 {
 341     .dwVersion = 2,
 342     .dwMerit = MERIT_PREFERRED,
 343     .u.s2.cPins2 = 3,
 344     .u.s2.rgPins2 = reg_gstdemux_pins,
 345 };
 346
 347 HRESULT WINAPI DllRegisterServer(void)
 348 {
 349     IFilterMapper2 *mapper;
 350     HRESULT hr;
 351
 352     TRACE(".\n");
 353
 354     if (FAILED(hr = __wine_register_resources(winegstreamer_instance)))
 355         return hr;
 356
 357     if (FAILED(hr = CoCreateInstance(&CLSID_FilterMapper2, NULL, CLSCTX_INPROC_SERVER,
 358             &IID_IFilterMapper2, (void **)&mapper)))
 359         return hr;
 360
 361     IFilterMapper2_RegisterFilter(mapper, &CLSID_AviSplitter, avi_splitterW, NULL, NULL, NULL, &reg_avi_splitter);
 362     IFilterMapper2_RegisterFilter(mapper, &CLSID_Gstreamer_Splitter,
 363             wGstreamer_Splitter, NULL, NULL, NULL, &reg_gstdemux);
 364     IFilterMapper2_RegisterFilter(mapper, &CLSID_MPEG1Splitter, mpeg_splitterW, NULL, NULL, NULL, &reg_mpeg_splitter);
 365     IFilterMapper2_RegisterFilter(mapper, &CLSID_WAVEParser, wave_parserW, NULL, NULL, NULL, &reg_wave_parser);
 366
 367     IFilterMapper2_Release(mapper);
 368     return S_OK;
 369 }
 370
 371 HRESULT WINAPI DllUnregisterServer(void)
 372 {
 373     IFilterMapper2 *mapper;
 374     HRESULT hr;
 375
 376     TRACE(".\n");
 377
 378     if (FAILED(hr = __wine_unregister_resources(winegstreamer_instance)))
 379         return hr;
 380
 381     if (FAILED(hr = CoCreateInstance(&CLSID_FilterMapper2, NULL, CLSCTX_INPROC_SERVER,
 382             &IID_IFilterMapper2, (void **)&mapper)))
 383         return hr;
 384
 385     IFilterMapper2_UnregisterFilter(mapper, NULL, NULL, &CLSID_AviSplitter);
 386     IFilterMapper2_UnregisterFilter(mapper, NULL, NULL, &CLSID_Gstreamer_Splitter);
 387     IFilterMapper2_UnregisterFilter(mapper, NULL, NULL, &CLSID_MPEG1Splitter);
 388     IFilterMapper2_UnregisterFilter(mapper, NULL, NULL, &CLSID_WAVEParser);
 389
 390     IFilterMapper2_Release(mapper);
 391     return S_OK;
 392 }