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 #define EXTERN_GUID DEFINE_GUID
  24 #include "initguid.h"
  25 #include "gst_private.h"
  26 #include "winternl.h"
  27 #include "rpcproxy.h"
  28 #include "dmoreg.h"
  29 #include "gst_guids.h"
  30 #include "wmcodecdsp.h"
  31
  32 static unixlib_handle_t unix_handle;
  33
  34 WINE_DEFAULT_DEBUG_CHANNEL(quartz);
  35
  36 DEFINE_GUID(GUID_NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
  37
  38 bool array_reserve(void **elements, size_t *capacity, size_t count, size_t size)
  39 {
  40     unsigned int new_capacity, max_capacity;
  41     void *new_elements;
  42
  43     if (count <= *capacity)
  44         return TRUE;
  45
  46     max_capacity = ~(SIZE_T)0 / size;
  47     if (count > max_capacity)
  48         return FALSE;
  49
  50     new_capacity = max(4, *capacity);
  51     while (new_capacity < count && new_capacity <= max_capacity / 2)
  52         new_capacity *= 2;
  53     if (new_capacity < count)
  54         new_capacity = max_capacity;
  55
  56     if (!(new_elements = realloc(*elements, new_capacity * size)))
  57         return FALSE;
  58
  59     *elements = new_elements;
  60     *capacity = new_capacity;
  61
  62     return TRUE;
  63 }
  64
  65 struct wg_parser *wg_parser_create(enum wg_parser_type type, bool unlimited_buffering)
  66 {
  67     struct wg_parser_create_params params =
  68     {
  69         .type = type,
  70         .unlimited_buffering = unlimited_buffering,
  71     };
  72
  73     TRACE("type %#x, unlimited_buffering %d.\n", type, unlimited_buffering);
  74
  75     if (__wine_unix_call(unix_handle, unix_wg_parser_create, &params))
  76         return NULL;
  77
  78     TRACE("Returning parser %p.\n", params.parser);
  79
  80     return params.parser;
  81 }
  82
  83 void wg_parser_destroy(struct wg_parser *parser)
  84 {
  85     TRACE("parser %p.\n", parser);
  86
  87     __wine_unix_call(unix_handle, unix_wg_parser_destroy, parser);
  88 }
  89
  90 HRESULT wg_parser_connect(struct wg_parser *parser, uint64_t file_size)
  91 {
  92     struct wg_parser_connect_params params =
  93     {
  94         .parser = parser,
  95         .file_size = file_size,
  96     };
  97
  98     TRACE("parser %p, file_size %I64u.\n", parser, file_size);
  99
 100     return __wine_unix_call(unix_handle, unix_wg_parser_connect, &params);
 101 }
 102
 103 void wg_parser_disconnect(struct wg_parser *parser)
 104 {
 105     TRACE("parser %p.\n", parser);
 106
 107     __wine_unix_call(unix_handle, unix_wg_parser_disconnect, parser);
 108 }
 109
 110 bool wg_parser_get_next_read_offset(struct wg_parser *parser, uint64_t *offset, uint32_t *size)
 111 {
 112     struct wg_parser_get_next_read_offset_params params =
 113     {
 114         .parser = parser,
 115     };
 116
 117     TRACE("parser %p, offset %p, size %p.\n", parser, offset, size);
 118
 119     if (__wine_unix_call(unix_handle, unix_wg_parser_get_next_read_offset, &params))
 120         return false;
 121     *offset = params.offset;
 122     *size = params.size;
 123     return true;
 124 }
 125
 126 void wg_parser_push_data(struct wg_parser *parser, const void *data, uint32_t size)
 127 {
 128     struct wg_parser_push_data_params params =
 129     {
 130         .parser = parser,
 131         .data = data,
 132         .size = size,
 133     };
 134
 135     TRACE("parser %p, data %p, size %u.\n", parser, data, size);
 136
 137     __wine_unix_call(unix_handle, unix_wg_parser_push_data, &params);
 138 }
 139
 140 uint32_t wg_parser_get_stream_count(struct wg_parser *parser)
 141 {
 142     struct wg_parser_get_stream_count_params params =
 143     {
 144         .parser = parser,
 145     };
 146
 147     TRACE("parser %p.\n", parser);
 148
 149     __wine_unix_call(unix_handle, unix_wg_parser_get_stream_count, &params);
 150     return params.count;
 151 }
 152
 153 struct wg_parser_stream *wg_parser_get_stream(struct wg_parser *parser, uint32_t index)
 154 {
 155     struct wg_parser_get_stream_params params =
 156     {
 157         .parser = parser,
 158         .index = index,
 159     };
 160
 161     TRACE("parser %p, index %u.\n", parser, index);
 162
 163     __wine_unix_call(unix_handle, unix_wg_parser_get_stream, &params);
 164
 165     TRACE("Returning stream %p.\n", params.stream);
 166     return params.stream;
 167 }
 168
 169 void wg_parser_stream_get_preferred_format(struct wg_parser_stream *stream, struct wg_format *format)
 170 {
 171     struct wg_parser_stream_get_preferred_format_params params =
 172     {
 173         .stream = stream,
 174         .format = format,
 175     };
 176
 177     TRACE("stream %p, format %p.\n", stream, format);
 178
 179     __wine_unix_call(unix_handle, unix_wg_parser_stream_get_preferred_format, &params);
 180 }
 181
 182 void wg_parser_stream_enable(struct wg_parser_stream *stream, const struct wg_format *format)
 183 {
 184     struct wg_parser_stream_enable_params params =
 185     {
 186         .stream = stream,
 187         .format = format,
 188     };
 189
 190     TRACE("stream %p, format %p.\n", stream, format);
 191
 192     __wine_unix_call(unix_handle, unix_wg_parser_stream_enable, &params);
 193 }
 194
 195 void wg_parser_stream_disable(struct wg_parser_stream *stream)
 196 {
 197     TRACE("stream %p.\n", stream);
 198
 199     __wine_unix_call(unix_handle, unix_wg_parser_stream_disable, stream);
 200 }
 201
 202 bool wg_parser_stream_get_buffer(struct wg_parser_stream *stream, struct wg_parser_buffer *buffer)
 203 {
 204     struct wg_parser_stream_get_buffer_params params =
 205     {
 206         .stream = stream,
 207         .buffer = buffer,
 208     };
 209
 210     TRACE("stream %p, buffer %p.\n", stream, buffer);
 211
 212     return !__wine_unix_call(unix_handle, unix_wg_parser_stream_get_buffer, &params);
 213 }
 214
 215 bool wg_parser_stream_copy_buffer(struct wg_parser_stream *stream,
 216         void *data, uint32_t offset, uint32_t size)
 217 {
 218     struct wg_parser_stream_copy_buffer_params params =
 219     {
 220         .stream = stream,
 221         .data = data,
 222         .offset = offset,
 223         .size = size,
 224     };
 225
 226     TRACE("stream %p, data %p, offset %u, size %u.\n", stream, data, offset, size);
 227
 228     return !__wine_unix_call(unix_handle, unix_wg_parser_stream_copy_buffer, &params);
 229 }
 230
 231 void wg_parser_stream_release_buffer(struct wg_parser_stream *stream)
 232 {
 233     TRACE("stream %p.\n", stream);
 234
 235     __wine_unix_call(unix_handle, unix_wg_parser_stream_release_buffer, stream);
 236 }
 237
 238 void wg_parser_stream_notify_qos(struct wg_parser_stream *stream,
 239         bool underflow, double proportion, int64_t diff, uint64_t timestamp)
 240 {
 241     struct wg_parser_stream_notify_qos_params params =
 242     {
 243         .stream = stream,
 244         .underflow = underflow,
 245         .proportion = proportion,
 246         .diff = diff,
 247         .timestamp = timestamp,
 248     };
 249
 250     TRACE("stream %p, underflow %d, proportion %.16e, diff %I64d, timestamp %I64u.\n",
 251             stream, underflow, proportion, diff, timestamp);
 252
 253     __wine_unix_call(unix_handle, unix_wg_parser_stream_notify_qos, &params);
 254 }
 255
 256 uint64_t wg_parser_stream_get_duration(struct wg_parser_stream *stream)
 257 {
 258     struct wg_parser_stream_get_duration_params params =
 259     {
 260         .stream = stream,
 261     };
 262
 263     TRACE("stream %p.\n", stream);
 264
 265     __wine_unix_call(unix_handle, unix_wg_parser_stream_get_duration, &params);
 266
 267     TRACE("Returning duration %I64u.\n", params.duration);
 268     return params.duration;
 269 }
 270
 271 void wg_parser_stream_seek(struct wg_parser_stream *stream, double rate,
 272         uint64_t start_pos, uint64_t stop_pos, DWORD start_flags, DWORD stop_flags)
 273 {
 274     struct wg_parser_stream_seek_params params =
 275     {
 276         .stream = stream,
 277         .rate = rate,
 278         .start_pos = start_pos,
 279         .stop_pos = stop_pos,
 280         .start_flags = start_flags,
 281         .stop_flags = stop_flags,
 282     };
 283
 284     TRACE("stream %p, rate %.16e, start_pos %I64u, stop_pos %I64u, start_flags %#lx, stop_flags %#lx.\n",
 285             stream, rate, start_pos, stop_pos, start_flags, stop_flags);
 286
 287     __wine_unix_call(unix_handle, unix_wg_parser_stream_seek, &params);
 288 }
 289
 290 struct wg_transform *wg_transform_create(const struct wg_format *input_format,
 291         const struct wg_format *output_format)
 292 {
 293     struct wg_transform_create_params params =
 294     {
 295         .input_format = input_format,
 296         .output_format = output_format,
 297     };
 298
 299     TRACE("input_format %p, output_format %p.\n", input_format, output_format);
 300
 301     if (__wine_unix_call(unix_handle, unix_wg_transform_create, &params))
 302         return NULL;
 303
 304     TRACE("Returning transform %p.\n", params.transform);
 305     return params.transform;
 306 }
 307
 308 void wg_transform_destroy(struct wg_transform *transform)
 309 {
 310     TRACE("transform %p.\n", transform);
 311
 312     __wine_unix_call(unix_handle, unix_wg_transform_destroy, transform);
 313 }
 314
 315 HRESULT wg_transform_push_data(struct wg_transform *transform, struct wg_sample *sample)
 316 {
 317     struct wg_transform_push_data_params params =
 318     {
 319         .transform = transform,
 320         .sample = sample,
 321     };
 322     NTSTATUS status;
 323
 324     TRACE("transform %p, sample %p.\n", transform, sample);
 325
 326     if ((status = __wine_unix_call(unix_handle, unix_wg_transform_push_data, &params)))
 327         return HRESULT_FROM_NT(status);
 328
 329     return params.result;
 330 }
 331
 332 HRESULT wg_transform_read_data(struct wg_transform *transform, struct wg_sample *sample)
 333 {
 334     struct wg_transform_read_data_params params =
 335     {
 336         .transform = transform,
 337         .sample = sample,
 338     };
 339     NTSTATUS status;
 340
 341     TRACE("transform %p, sample %p.\n", transform, sample);
 342
 343     if ((status = __wine_unix_call(unix_handle, unix_wg_transform_read_data, &params)))
 344         return HRESULT_FROM_NT(status);
 345
 346     return params.result;
 347 }
 348
 349 BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, void *reserved)
 350 {
 351     if (reason == DLL_PROCESS_ATTACH)
 352     {
 353         DisableThreadLibraryCalls(instance);
 354         NtQueryVirtualMemory(GetCurrentProcess(), instance, MemoryWineUnixFuncs,
 355                 &unix_handle, sizeof(unix_handle), NULL);
 356     }
 357     return TRUE;
 358 }
 359
 360 struct class_factory
 361 {
 362     IClassFactory IClassFactory_iface;
 363     HRESULT (*create_instance)(IUnknown *outer, IUnknown **out);
 364 };
 365
 366 static inline struct class_factory *impl_from_IClassFactory(IClassFactory *iface)
 367 {
 368     return CONTAINING_RECORD(iface, struct class_factory, IClassFactory_iface);
 369 }
 370
 371 static HRESULT WINAPI class_factory_QueryInterface(IClassFactory *iface, REFIID iid, void **out)
 372 {
 373     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
 374
 375     if (IsEqualGUID(iid, &IID_IUnknown) || IsEqualGUID(iid, &IID_IClassFactory))
 376     {
 377         *out = iface;
 378         IClassFactory_AddRef(iface);
 379         return S_OK;
 380     }
 381
 382     *out = NULL;
 383     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
 384     return E_NOINTERFACE;
 385 }
 386
 387 static ULONG WINAPI class_factory_AddRef(IClassFactory *iface)
 388 {
 389     return 2;
 390 }
 391
 392 static ULONG WINAPI class_factory_Release(IClassFactory *iface)
 393 {
 394     return 1;
 395 }
 396
 397 static HRESULT WINAPI class_factory_CreateInstance(IClassFactory *iface, IUnknown *outer, REFIID iid, void **out)
 398 {
 399     struct class_factory *factory = impl_from_IClassFactory(iface);
 400     IUnknown *unk;
 401     HRESULT hr;
 402
 403     TRACE("iface %p, outer %p, iid %s, out %p.\n", iface, outer, debugstr_guid(iid), out);
 404
 405     if (outer && !IsEqualGUID(iid, &IID_IUnknown))
 406         return E_NOINTERFACE;
 407
 408     *out = NULL;
 409     if (SUCCEEDED(hr = factory->create_instance(outer, &unk)))
 410     {
 411         hr = IUnknown_QueryInterface(unk, iid, out);
 412         IUnknown_Release(unk);
 413     }
 414     return hr;
 415 }
 416
 417 static HRESULT WINAPI class_factory_LockServer(IClassFactory *iface, BOOL lock)
 418 {
 419     TRACE("iface %p, lock %d.\n", iface, lock);
 420     return S_OK;
 421 }
 422
 423 static const IClassFactoryVtbl class_factory_vtbl =
 424 {
 425     class_factory_QueryInterface,
 426     class_factory_AddRef,
 427     class_factory_Release,
 428     class_factory_CreateInstance,
 429     class_factory_LockServer,
 430 };
 431
 432 static struct class_factory avi_splitter_cf = {{&class_factory_vtbl}, avi_splitter_create};
 433 static struct class_factory decodebin_parser_cf = {{&class_factory_vtbl}, decodebin_parser_create};
 434 static struct class_factory mpeg_audio_codec_cf = {{&class_factory_vtbl}, mpeg_audio_codec_create};
 435 static struct class_factory mpeg_splitter_cf = {{&class_factory_vtbl}, mpeg_splitter_create};
 436 static struct class_factory wave_parser_cf = {{&class_factory_vtbl}, wave_parser_create};
 437 static struct class_factory wma_decoder_cf = {{&class_factory_vtbl}, wma_decoder_create};
 438
 439 HRESULT WINAPI DllGetClassObject(REFCLSID clsid, REFIID iid, void **out)
 440 {
 441     struct class_factory *factory;
 442     HRESULT hr;
 443
 444     TRACE("clsid %s, iid %s, out %p.\n", debugstr_guid(clsid), debugstr_guid(iid), out);
 445
 446     if (!init_gstreamer())
 447         return CLASS_E_CLASSNOTAVAILABLE;
 448
 449     if (SUCCEEDED(hr = mfplat_get_class_object(clsid, iid, out)))
 450         return hr;
 451
 452     if (IsEqualGUID(clsid, &CLSID_AviSplitter))
 453         factory = &avi_splitter_cf;
 454     else if (IsEqualGUID(clsid, &CLSID_decodebin_parser))
 455         factory = &decodebin_parser_cf;
 456     else if (IsEqualGUID(clsid, &CLSID_CMpegAudioCodec))
 457         factory = &mpeg_audio_codec_cf;
 458     else if (IsEqualGUID(clsid, &CLSID_MPEG1Splitter))
 459         factory = &mpeg_splitter_cf;
 460     else if (IsEqualGUID(clsid, &CLSID_WAVEParser))
 461         factory = &wave_parser_cf;
 462     else if (IsEqualGUID(clsid, &CLSID_WMADecMediaObject))
 463         factory = &wma_decoder_cf;
 464     else
 465     {
 466         FIXME("%s not implemented, returning CLASS_E_CLASSNOTAVAILABLE.\n", debugstr_guid(clsid));
 467         return CLASS_E_CLASSNOTAVAILABLE;
 468     }
 469
 470     return IClassFactory_QueryInterface(&factory->IClassFactory_iface, iid, out);
 471 }
 472
 473 static BOOL CALLBACK init_gstreamer_proc(INIT_ONCE *once, void *param, void **ctx)
 474 {
 475     HINSTANCE handle;
 476
 477     /* Unloading glib is a bad idea.. it installs atexit handlers,
 478      * so never unload the dll after loading */
 479     GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | GET_MODULE_HANDLE_EX_FLAG_PIN,
 480             (LPCWSTR)init_gstreamer_proc, &handle);
 481     if (!handle)
 482         ERR("Failed to pin module.\n");
 483
 484     return TRUE;
 485 }
 486
 487 BOOL init_gstreamer(void)
 488 {
 489     static INIT_ONCE once = INIT_ONCE_STATIC_INIT;
 490
 491     InitOnceExecuteOnce(&once, init_gstreamer_proc, NULL, NULL);
 492
 493     return TRUE;
 494 }
 495
 496 static const REGPINTYPES reg_audio_mt = {&MEDIATYPE_Audio, &GUID_NULL};
 497 static const REGPINTYPES reg_stream_mt = {&MEDIATYPE_Stream, &GUID_NULL};
 498 static const REGPINTYPES reg_video_mt = {&MEDIATYPE_Video, &GUID_NULL};
 499
 500 static const REGPINTYPES reg_avi_splitter_sink_mt = {&MEDIATYPE_Stream, &MEDIASUBTYPE_Avi};
 501
 502 static const REGFILTERPINS2 reg_avi_splitter_pins[2] =
 503 {
 504     {
 505         .nMediaTypes = 1,
 506         .lpMediaType = &reg_avi_splitter_sink_mt,
 507     },
 508     {
 509         .dwFlags = REG_PINFLAG_B_OUTPUT,
 510         .nMediaTypes = 1,
 511         .lpMediaType = &reg_video_mt,
 512     },
 513 };
 514
 515 static const REGFILTER2 reg_avi_splitter =
 516 {
 517     .dwVersion = 2,
 518     .dwMerit = MERIT_NORMAL,
 519     .u.s2.cPins2 = 2,
 520     .u.s2.rgPins2 = reg_avi_splitter_pins,
 521 };
 522
 523 static const REGPINTYPES reg_mpeg_audio_codec_sink_mts[3] =
 524 {
 525     {&MEDIATYPE_Audio, &MEDIASUBTYPE_MPEG1Packet},
 526     {&MEDIATYPE_Audio, &MEDIASUBTYPE_MPEG1Payload},
 527     {&MEDIATYPE_Audio, &MEDIASUBTYPE_MPEG1AudioPayload},
 528 };
 529
 530 static const REGPINTYPES reg_mpeg_audio_codec_source_mts[1] =
 531 {
 532     {&MEDIATYPE_Audio, &MEDIASUBTYPE_PCM},
 533 };
 534
 535 static const REGFILTERPINS2 reg_mpeg_audio_codec_pins[2] =
 536 {
 537     {
 538         .nMediaTypes = 3,
 539         .lpMediaType = reg_mpeg_audio_codec_sink_mts,
 540     },
 541     {
 542         .dwFlags = REG_PINFLAG_B_OUTPUT,
 543         .nMediaTypes = 1,
 544         .lpMediaType = reg_mpeg_audio_codec_source_mts,
 545     },
 546 };
 547
 548 static const REGFILTER2 reg_mpeg_audio_codec =
 549 {
 550     .dwVersion = 2,
 551     .dwMerit = 0x03680001,
 552     .u.s2.cPins2 = 2,
 553     .u.s2.rgPins2 = reg_mpeg_audio_codec_pins,
 554 };
 555
 556 static const REGPINTYPES reg_mpeg_splitter_sink_mts[4] =
 557 {
 558     {&MEDIATYPE_Stream, &MEDIASUBTYPE_MPEG1Audio},
 559     {&MEDIATYPE_Stream, &MEDIASUBTYPE_MPEG1Video},
 560     {&MEDIATYPE_Stream, &MEDIASUBTYPE_MPEG1System},
 561     {&MEDIATYPE_Stream, &MEDIASUBTYPE_MPEG1VideoCD},
 562 };
 563
 564 static const REGPINTYPES reg_mpeg_splitter_audio_mts[2] =
 565 {
 566     {&MEDIATYPE_Audio, &MEDIASUBTYPE_MPEG1Packet},
 567     {&MEDIATYPE_Audio, &MEDIASUBTYPE_MPEG1AudioPayload},
 568 };
 569
 570 static const REGPINTYPES reg_mpeg_splitter_video_mts[2] =
 571 {
 572     {&MEDIATYPE_Video, &MEDIASUBTYPE_MPEG1Packet},
 573     {&MEDIATYPE_Video, &MEDIASUBTYPE_MPEG1Payload},
 574 };
 575
 576 static const REGFILTERPINS2 reg_mpeg_splitter_pins[3] =
 577 {
 578     {
 579         .nMediaTypes = 4,
 580         .lpMediaType = reg_mpeg_splitter_sink_mts,
 581     },
 582     {
 583         .dwFlags = REG_PINFLAG_B_ZERO | REG_PINFLAG_B_OUTPUT,
 584         .nMediaTypes = 2,
 585         .lpMediaType = reg_mpeg_splitter_audio_mts,
 586     },
 587     {
 588         .dwFlags = REG_PINFLAG_B_ZERO | REG_PINFLAG_B_OUTPUT,
 589         .nMediaTypes = 2,
 590         .lpMediaType = reg_mpeg_splitter_video_mts,
 591     },
 592 };
 593
 594 static const REGFILTER2 reg_mpeg_splitter =
 595 {
 596     .dwVersion = 2,
 597     .dwMerit = MERIT_NORMAL,
 598     .u.s2.cPins2 = 3,
 599     .u.s2.rgPins2 = reg_mpeg_splitter_pins,
 600 };
 601
 602 static const REGPINTYPES reg_wave_parser_sink_mts[3] =
 603 {
 604     {&MEDIATYPE_Stream, &MEDIASUBTYPE_WAVE},
 605     {&MEDIATYPE_Stream, &MEDIASUBTYPE_AU},
 606     {&MEDIATYPE_Stream, &MEDIASUBTYPE_AIFF},
 607 };
 608
 609 static const REGFILTERPINS2 reg_wave_parser_pins[2] =
 610 {
 611     {
 612         .nMediaTypes = 3,
 613         .lpMediaType = reg_wave_parser_sink_mts,
 614     },
 615     {
 616         .dwFlags = REG_PINFLAG_B_OUTPUT,
 617         .nMediaTypes = 1,
 618         .lpMediaType = &reg_audio_mt,
 619     },
 620 };
 621
 622 static const REGFILTER2 reg_wave_parser =
 623 {
 624     .dwVersion = 2,
 625     .dwMerit = MERIT_UNLIKELY,
 626     .u.s2.cPins2 = 2,
 627     .u.s2.rgPins2 = reg_wave_parser_pins,
 628 };
 629
 630 static const REGFILTERPINS2 reg_decodebin_parser_pins[3] =
 631 {
 632     {
 633         .nMediaTypes = 1,
 634         .lpMediaType = &reg_stream_mt,
 635     },
 636     {
 637         .dwFlags = REG_PINFLAG_B_OUTPUT,
 638         .nMediaTypes = 1,
 639         .lpMediaType = &reg_audio_mt,
 640     },
 641     {
 642         .dwFlags = REG_PINFLAG_B_OUTPUT,
 643         .nMediaTypes = 1,
 644         .lpMediaType = &reg_video_mt,
 645     },
 646 };
 647
 648 static const REGFILTER2 reg_decodebin_parser =
 649 {
 650     .dwVersion = 2,
 651     .dwMerit = MERIT_PREFERRED,
 652     .u.s2.cPins2 = 3,
 653     .u.s2.rgPins2 = reg_decodebin_parser_pins,
 654 };
 655
 656 HRESULT WINAPI DllRegisterServer(void)
 657 {
 658     DMO_PARTIAL_MEDIATYPE wma_decoder_output[2] =
 659     {
 660         {.type = MEDIATYPE_Audio, .subtype = MEDIASUBTYPE_PCM},
 661         {.type = MEDIATYPE_Audio, .subtype = MEDIASUBTYPE_IEEE_FLOAT},
 662     };
 663     DMO_PARTIAL_MEDIATYPE wma_decoder_input[4] =
 664     {
 665         {.type = MEDIATYPE_Audio, .subtype = MEDIASUBTYPE_MSAUDIO1},
 666         {.type = MEDIATYPE_Audio, .subtype = MEDIASUBTYPE_WMAUDIO2},
 667         {.type = MEDIATYPE_Audio, .subtype = MEDIASUBTYPE_WMAUDIO3},
 668         {.type = MEDIATYPE_Audio, .subtype = MEDIASUBTYPE_WMAUDIO_LOSSLESS},
 669     };
 670
 671     IFilterMapper2 *mapper;
 672     HRESULT hr;
 673
 674     TRACE(".\n");
 675
 676     if (FAILED(hr = __wine_register_resources()))
 677         return hr;
 678
 679     if (FAILED(hr = CoCreateInstance(&CLSID_FilterMapper2, NULL, CLSCTX_INPROC_SERVER,
 680             &IID_IFilterMapper2, (void **)&mapper)))
 681         return hr;
 682
 683     IFilterMapper2_RegisterFilter(mapper, &CLSID_AviSplitter, L"AVI Splitter", NULL, NULL, NULL, &reg_avi_splitter);
 684     IFilterMapper2_RegisterFilter(mapper, &CLSID_decodebin_parser,
 685             L"GStreamer splitter filter", NULL, NULL, NULL, &reg_decodebin_parser);
 686     IFilterMapper2_RegisterFilter(mapper, &CLSID_CMpegAudioCodec,
 687             L"MPEG Audio Decoder", NULL, NULL, NULL, &reg_mpeg_audio_codec);
 688     IFilterMapper2_RegisterFilter(mapper, &CLSID_MPEG1Splitter,
 689             L"MPEG-I Stream Splitter", NULL, NULL, NULL, &reg_mpeg_splitter);
 690     IFilterMapper2_RegisterFilter(mapper, &CLSID_WAVEParser, L"Wave Parser", NULL, NULL, NULL, &reg_wave_parser);
 691
 692     IFilterMapper2_Release(mapper);
 693
 694     if (FAILED(hr = DMORegister(L"WMA Decoder DMO", &CLSID_WMADecMediaObject, &DMOCATEGORY_AUDIO_DECODER,
 695             0, ARRAY_SIZE(wma_decoder_input), wma_decoder_input, ARRAY_SIZE(wma_decoder_output), wma_decoder_output)))
 696         return hr;
 697
 698     return mfplat_DllRegisterServer();
 699 }
 700
 701 HRESULT WINAPI DllUnregisterServer(void)
 702 {
 703     IFilterMapper2 *mapper;
 704     HRESULT hr;
 705
 706     TRACE(".\n");
 707
 708     if (FAILED(hr = __wine_unregister_resources()))
 709         return hr;
 710
 711     if (FAILED(hr = CoCreateInstance(&CLSID_FilterMapper2, NULL, CLSCTX_INPROC_SERVER,
 712             &IID_IFilterMapper2, (void **)&mapper)))
 713         return hr;
 714
 715     IFilterMapper2_UnregisterFilter(mapper, NULL, NULL, &CLSID_AviSplitter);
 716     IFilterMapper2_UnregisterFilter(mapper, NULL, NULL, &CLSID_decodebin_parser);
 717     IFilterMapper2_UnregisterFilter(mapper, NULL, NULL, &CLSID_CMpegAudioCodec);
 718     IFilterMapper2_UnregisterFilter(mapper, NULL, NULL, &CLSID_MPEG1Splitter);
 719     IFilterMapper2_UnregisterFilter(mapper, NULL, NULL, &CLSID_WAVEParser);
 720
 721     IFilterMapper2_Release(mapper);
 722
 723     if (FAILED(hr = DMOUnregister(&CLSID_WMADecMediaObject, &DMOCATEGORY_AUDIO_DECODER)))
 724         return hr;
 725
 726     return S_OK;
 727 }