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
  25 #include "ntstatus.h"
  26 #define WIN32_NO_STATUS
  27 #include "initguid.h"
  28 #include "gst_private.h"
  29 #include "winternl.h"
  30 #include "rpcproxy.h"
  31 #include "dmoreg.h"
  32 #include "gst_guids.h"
  33 #include "wmcodecdsp.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(quartz);
  36
  37 DEFINE_GUID(GUID_NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
  38 DEFINE_GUID(MEDIASUBTYPE_VC1S,MAKEFOURCC('V','C','1','S'),0x0000,0x0010,0x80,0x00,0x00,0xaa,0x00,0x38,0x9b,0x71);
  39
  40 static const GUID MEDIASUBTYPE_MP3 = {0x00000055, 0x0000, 0x0010, {0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}};
  41
  42 bool array_reserve(void **elements, size_t *capacity, size_t count, size_t size)
  43 {
  44     unsigned int new_capacity, max_capacity;
  45     void *new_elements;
  46
  47     if (count <= *capacity)
  48         return TRUE;
  49
  50     max_capacity = ~(SIZE_T)0 / size;
  51     if (count > max_capacity)
  52         return FALSE;
  53
  54     new_capacity = max(4, *capacity);
  55     while (new_capacity < count && new_capacity <= max_capacity / 2)
  56         new_capacity *= 2;
  57     if (new_capacity < count)
  58         new_capacity = max_capacity;
  59
  60     if (!(new_elements = realloc(*elements, new_capacity * size)))
  61         return FALSE;
  62
  63     *elements = new_elements;
  64     *capacity = new_capacity;
  65
  66     return TRUE;
  67 }
  68
  69 struct wg_parser *wg_parser_create(enum wg_parser_type type, bool unlimited_buffering)
  70 {
  71     struct wg_parser_create_params params =
  72     {
  73         .type = type,
  74         .unlimited_buffering = unlimited_buffering,
  75         .err_on = ERR_ON(quartz),
  76         .warn_on = WARN_ON(quartz),
  77     };
  78
  79     TRACE("type %#x, unlimited_buffering %d.\n", type, unlimited_buffering);
  80
  81     if (WINE_UNIX_CALL(unix_wg_parser_create, &params))
  82         return NULL;
  83
  84     TRACE("Returning parser %p.\n", params.parser);
  85
  86     return params.parser;
  87 }
  88
  89 void wg_parser_destroy(struct wg_parser *parser)
  90 {
  91     TRACE("parser %p.\n", parser);
  92
  93     WINE_UNIX_CALL(unix_wg_parser_destroy, parser);
  94 }
  95
  96 HRESULT wg_parser_connect(struct wg_parser *parser, uint64_t file_size)
  97 {
  98     struct wg_parser_connect_params params =
  99     {
 100         .parser = parser,
 101         .file_size = file_size,
 102     };
 103
 104     TRACE("parser %p, file_size %I64u.\n", parser, file_size);
 105
 106     return WINE_UNIX_CALL(unix_wg_parser_connect, &params);
 107 }
 108
 109 void wg_parser_disconnect(struct wg_parser *parser)
 110 {
 111     TRACE("parser %p.\n", parser);
 112
 113     WINE_UNIX_CALL(unix_wg_parser_disconnect, parser);
 114 }
 115
 116 bool wg_parser_get_next_read_offset(struct wg_parser *parser, uint64_t *offset, uint32_t *size)
 117 {
 118     struct wg_parser_get_next_read_offset_params params =
 119     {
 120         .parser = parser,
 121     };
 122
 123     TRACE("parser %p, offset %p, size %p.\n", parser, offset, size);
 124
 125     if (WINE_UNIX_CALL(unix_wg_parser_get_next_read_offset, &params))
 126         return false;
 127     *offset = params.offset;
 128     *size = params.size;
 129     return true;
 130 }
 131
 132 void wg_parser_push_data(struct wg_parser *parser, const void *data, uint32_t size)
 133 {
 134     struct wg_parser_push_data_params params =
 135     {
 136         .parser = parser,
 137         .data = data,
 138         .size = size,
 139     };
 140
 141     TRACE("parser %p, data %p, size %u.\n", parser, data, size);
 142
 143     WINE_UNIX_CALL(unix_wg_parser_push_data, &params);
 144 }
 145
 146 uint32_t wg_parser_get_stream_count(struct wg_parser *parser)
 147 {
 148     struct wg_parser_get_stream_count_params params =
 149     {
 150         .parser = parser,
 151     };
 152
 153     TRACE("parser %p.\n", parser);
 154
 155     WINE_UNIX_CALL(unix_wg_parser_get_stream_count, &params);
 156     return params.count;
 157 }
 158
 159 struct wg_parser_stream *wg_parser_get_stream(struct wg_parser *parser, uint32_t index)
 160 {
 161     struct wg_parser_get_stream_params params =
 162     {
 163         .parser = parser,
 164         .index = index,
 165     };
 166
 167     TRACE("parser %p, index %u.\n", parser, index);
 168
 169     WINE_UNIX_CALL(unix_wg_parser_get_stream, &params);
 170
 171     TRACE("Returning stream %p.\n", params.stream);
 172     return params.stream;
 173 }
 174
 175 void wg_parser_stream_get_preferred_format(struct wg_parser_stream *stream, struct wg_format *format)
 176 {
 177     struct wg_parser_stream_get_preferred_format_params params =
 178     {
 179         .stream = stream,
 180         .format = format,
 181     };
 182
 183     TRACE("stream %p, format %p.\n", stream, format);
 184
 185     WINE_UNIX_CALL(unix_wg_parser_stream_get_preferred_format, &params);
 186 }
 187
 188 void wg_parser_stream_get_codec_format(struct wg_parser_stream *stream, struct wg_format *format)
 189 {
 190     struct wg_parser_stream_get_codec_format_params params =
 191     {
 192         .stream = stream,
 193         .format = format,
 194     };
 195
 196     TRACE("stream %p, format %p.\n", stream, format);
 197
 198     WINE_UNIX_CALL(unix_wg_parser_stream_get_codec_format, &params);
 199 }
 200
 201 void wg_parser_stream_enable(struct wg_parser_stream *stream, const struct wg_format *format)
 202 {
 203     struct wg_parser_stream_enable_params params =
 204     {
 205         .stream = stream,
 206         .format = format,
 207     };
 208
 209     TRACE("stream %p, format %p.\n", stream, format);
 210
 211     WINE_UNIX_CALL(unix_wg_parser_stream_enable, &params);
 212 }
 213
 214 void wg_parser_stream_disable(struct wg_parser_stream *stream)
 215 {
 216     TRACE("stream %p.\n", stream);
 217
 218     WINE_UNIX_CALL(unix_wg_parser_stream_disable, stream);
 219 }
 220
 221 bool wg_parser_stream_get_buffer(struct wg_parser *parser, struct wg_parser_stream *stream,
 222         struct wg_parser_buffer *buffer)
 223 {
 224     struct wg_parser_stream_get_buffer_params params =
 225     {
 226         .parser = parser,
 227         .stream = stream,
 228         .buffer = buffer,
 229     };
 230
 231     TRACE("parser %p, stream %p, buffer %p.\n", parser, stream, buffer);
 232
 233     return !WINE_UNIX_CALL(unix_wg_parser_stream_get_buffer, &params);
 234 }
 235
 236 bool wg_parser_stream_copy_buffer(struct wg_parser_stream *stream,
 237         void *data, uint32_t offset, uint32_t size)
 238 {
 239     struct wg_parser_stream_copy_buffer_params params =
 240     {
 241         .stream = stream,
 242         .data = data,
 243         .offset = offset,
 244         .size = size,
 245     };
 246
 247     TRACE("stream %p, data %p, offset %u, size %u.\n", stream, data, offset, size);
 248
 249     return !WINE_UNIX_CALL(unix_wg_parser_stream_copy_buffer, &params);
 250 }
 251
 252 void wg_parser_stream_release_buffer(struct wg_parser_stream *stream)
 253 {
 254     TRACE("stream %p.\n", stream);
 255
 256     WINE_UNIX_CALL(unix_wg_parser_stream_release_buffer, stream);
 257 }
 258
 259 void wg_parser_stream_notify_qos(struct wg_parser_stream *stream,
 260         bool underflow, double proportion, int64_t diff, uint64_t timestamp)
 261 {
 262     struct wg_parser_stream_notify_qos_params params =
 263     {
 264         .stream = stream,
 265         .underflow = underflow,
 266         .proportion = proportion,
 267         .diff = diff,
 268         .timestamp = timestamp,
 269     };
 270
 271     TRACE("stream %p, underflow %d, proportion %.16e, diff %I64d, timestamp %I64u.\n",
 272             stream, underflow, proportion, diff, timestamp);
 273
 274     WINE_UNIX_CALL(unix_wg_parser_stream_notify_qos, &params);
 275 }
 276
 277 uint64_t wg_parser_stream_get_duration(struct wg_parser_stream *stream)
 278 {
 279     struct wg_parser_stream_get_duration_params params =
 280     {
 281         .stream = stream,
 282     };
 283
 284     TRACE("stream %p.\n", stream);
 285
 286     WINE_UNIX_CALL(unix_wg_parser_stream_get_duration, &params);
 287
 288     TRACE("Returning duration %I64u.\n", params.duration);
 289     return params.duration;
 290 }
 291
 292 char *wg_parser_stream_get_tag(struct wg_parser_stream *stream, enum wg_parser_tag tag)
 293 {
 294     uint32_t size = 0;
 295     struct wg_parser_stream_get_tag_params params =
 296     {
 297         .stream = stream,
 298         .tag = tag,
 299         .size = &size,
 300     };
 301     char *buffer;
 302
 303     if (WINE_UNIX_CALL(unix_wg_parser_stream_get_tag, &params) != STATUS_BUFFER_TOO_SMALL)
 304         return NULL;
 305     if (!(buffer = malloc(size)))
 306     {
 307         ERR("No memory.\n");
 308         return NULL;
 309     }
 310     params.buffer = buffer;
 311     if (WINE_UNIX_CALL(unix_wg_parser_stream_get_tag, &params))
 312     {
 313         ERR("wg_parser_stream_get_tag failed unexpectedly.\n");
 314         free(buffer);
 315         return NULL;
 316     }
 317     return buffer;
 318 }
 319
 320 void wg_parser_stream_seek(struct wg_parser_stream *stream, double rate,
 321         uint64_t start_pos, uint64_t stop_pos, DWORD start_flags, DWORD stop_flags)
 322 {
 323     struct wg_parser_stream_seek_params params =
 324     {
 325         .stream = stream,
 326         .rate = rate,
 327         .start_pos = start_pos,
 328         .stop_pos = stop_pos,
 329         .start_flags = start_flags,
 330         .stop_flags = stop_flags,
 331     };
 332
 333     TRACE("stream %p, rate %.16e, start_pos %I64u, stop_pos %I64u, start_flags %#lx, stop_flags %#lx.\n",
 334             stream, rate, start_pos, stop_pos, start_flags, stop_flags);
 335
 336     WINE_UNIX_CALL(unix_wg_parser_stream_seek, &params);
 337 }
 338
 339 struct wg_transform *wg_transform_create(const struct wg_format *input_format,
 340         const struct wg_format *output_format)
 341 {
 342     struct wg_transform_create_params params =
 343     {
 344         .input_format = input_format,
 345         .output_format = output_format,
 346     };
 347
 348     TRACE("input_format %p, output_format %p.\n", input_format, output_format);
 349
 350     if (WINE_UNIX_CALL(unix_wg_transform_create, &params))
 351         return NULL;
 352
 353     TRACE("Returning transform %p.\n", params.transform);
 354     return params.transform;
 355 }
 356
 357 void wg_transform_destroy(struct wg_transform *transform)
 358 {
 359     TRACE("transform %p.\n", transform);
 360
 361     WINE_UNIX_CALL(unix_wg_transform_destroy, transform);
 362 }
 363
 364 HRESULT wg_transform_push_data(struct wg_transform *transform, struct wg_sample *sample)
 365 {
 366     struct wg_transform_push_data_params params =
 367     {
 368         .transform = transform,
 369         .sample = sample,
 370     };
 371     NTSTATUS status;
 372
 373     TRACE("transform %p, sample %p.\n", transform, sample);
 374
 375     if ((status = WINE_UNIX_CALL(unix_wg_transform_push_data, &params)))
 376         return HRESULT_FROM_NT(status);
 377
 378     return params.result;
 379 }
 380
 381 HRESULT wg_transform_read_data(struct wg_transform *transform, struct wg_sample *sample,
 382         struct wg_format *format)
 383 {
 384     struct wg_transform_read_data_params params =
 385     {
 386         .transform = transform,
 387         .sample = sample,
 388         .format = format,
 389     };
 390     NTSTATUS status;
 391
 392     TRACE("transform %p, sample %p, format %p.\n", transform, sample, format);
 393
 394     if ((status = WINE_UNIX_CALL(unix_wg_transform_read_data, &params)))
 395         return HRESULT_FROM_NT(status);
 396
 397     return params.result;
 398 }
 399
 400 bool wg_transform_get_status(struct wg_transform *transform, bool *accepts_input)
 401 {
 402     struct wg_transform_get_status_params params =
 403     {
 404         .transform = transform,
 405     };
 406
 407     TRACE("transform %p, accepts_input %p.\n", transform, accepts_input);
 408
 409     if (WINE_UNIX_CALL(unix_wg_transform_get_status, &params))
 410         return false;
 411
 412     *accepts_input = params.accepts_input;
 413     return true;
 414 }
 415
 416 bool wg_transform_set_output_format(struct wg_transform *transform, struct wg_format *format)
 417 {
 418     struct wg_transform_set_output_format_params params =
 419     {
 420         .transform = transform,
 421         .format = format,
 422     };
 423
 424     TRACE("transform %p, format %p.\n", transform, format);
 425
 426     return !WINE_UNIX_CALL(unix_wg_transform_set_output_format, &params);
 427 }
 428
 429 HRESULT wg_transform_drain(struct wg_transform *transform)
 430 {
 431     NTSTATUS status;
 432
 433     TRACE("transform %p.\n", transform);
 434
 435     if ((status = WINE_UNIX_CALL(unix_wg_transform_drain, transform)))
 436     {
 437         WARN("wg_transform_drain returned status %#lx\n", status);
 438         return HRESULT_FROM_NT(status);
 439     }
 440
 441     return S_OK;
 442 }
 443
 444 HRESULT wg_transform_flush(struct wg_transform *transform)
 445 {
 446     NTSTATUS status;
 447
 448     TRACE("transform %p.\n", transform);
 449
 450     if ((status = WINE_UNIX_CALL(unix_wg_transform_flush, transform)))
 451     {
 452         WARN("wg_transform_flush returned status %#lx\n", status);
 453         return HRESULT_FROM_NT(status);
 454     }
 455
 456     return S_OK;
 457 }
 458
 459 #define ALIGN(n, alignment) (((n) + (alignment) - 1) & ~((alignment) - 1))
 460
 461 unsigned int wg_format_get_stride(const struct wg_format *format)
 462 {
 463     const unsigned int width = format->u.video.width;
 464
 465     switch (format->u.video.format)
 466     {
 467         case WG_VIDEO_FORMAT_AYUV:
 468             return width * 4;
 469
 470         case WG_VIDEO_FORMAT_BGRA:
 471         case WG_VIDEO_FORMAT_BGRx:
 472             return width * 4;
 473
 474         case WG_VIDEO_FORMAT_BGR:
 475             return ALIGN(width * 3, 4);
 476
 477         case WG_VIDEO_FORMAT_UYVY:
 478         case WG_VIDEO_FORMAT_YUY2:
 479         case WG_VIDEO_FORMAT_YVYU:
 480             return ALIGN(width * 2, 4);
 481
 482         case WG_VIDEO_FORMAT_RGB15:
 483         case WG_VIDEO_FORMAT_RGB16:
 484             return ALIGN(width * 2, 4);
 485
 486         case WG_VIDEO_FORMAT_I420:
 487         case WG_VIDEO_FORMAT_NV12:
 488         case WG_VIDEO_FORMAT_YV12:
 489             return ALIGN(width, 4); /* Y plane */
 490
 491         case WG_VIDEO_FORMAT_UNKNOWN:
 492             FIXME("Cannot calculate stride for unknown video format.\n");
 493     }
 494
 495     return 0;
 496 }
 497
 498 bool wg_video_format_is_rgb(enum wg_video_format format)
 499 {
 500     switch (format)
 501     {
 502         case WG_VIDEO_FORMAT_BGRA:
 503         case WG_VIDEO_FORMAT_BGRx:
 504         case WG_VIDEO_FORMAT_BGR:
 505         case WG_VIDEO_FORMAT_RGB15:
 506         case WG_VIDEO_FORMAT_RGB16:
 507             return true;
 508
 509         case WG_VIDEO_FORMAT_AYUV:
 510         case WG_VIDEO_FORMAT_I420:
 511         case WG_VIDEO_FORMAT_NV12:
 512         case WG_VIDEO_FORMAT_UYVY:
 513         case WG_VIDEO_FORMAT_YUY2:
 514         case WG_VIDEO_FORMAT_YV12:
 515         case WG_VIDEO_FORMAT_YVYU:
 516         case WG_VIDEO_FORMAT_UNKNOWN:
 517             break;
 518     }
 519
 520     return false;
 521 }
 522
 523 BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, void *reserved)
 524 {
 525     if (reason == DLL_PROCESS_ATTACH)
 526     {
 527         DisableThreadLibraryCalls(instance);
 528         __wine_init_unix_call();
 529     }
 530     return TRUE;
 531 }
 532
 533 struct class_factory
 534 {
 535     IClassFactory IClassFactory_iface;
 536     HRESULT (*create_instance)(IUnknown *outer, IUnknown **out);
 537 };
 538
 539 static inline struct class_factory *impl_from_IClassFactory(IClassFactory *iface)
 540 {
 541     return CONTAINING_RECORD(iface, struct class_factory, IClassFactory_iface);
 542 }
 543
 544 static HRESULT WINAPI class_factory_QueryInterface(IClassFactory *iface, REFIID iid, void **out)
 545 {
 546     TRACE("iface %p, iid %s, out %p.\n", iface, debugstr_guid(iid), out);
 547
 548     if (IsEqualGUID(iid, &IID_IUnknown) || IsEqualGUID(iid, &IID_IClassFactory))
 549     {
 550         *out = iface;
 551         IClassFactory_AddRef(iface);
 552         return S_OK;
 553     }
 554
 555     *out = NULL;
 556     WARN("%s not implemented, returning E_NOINTERFACE.\n", debugstr_guid(iid));
 557     return E_NOINTERFACE;
 558 }
 559
 560 static ULONG WINAPI class_factory_AddRef(IClassFactory *iface)
 561 {
 562     return 2;
 563 }
 564
 565 static ULONG WINAPI class_factory_Release(IClassFactory *iface)
 566 {
 567     return 1;
 568 }
 569
 570 static HRESULT WINAPI class_factory_CreateInstance(IClassFactory *iface, IUnknown *outer, REFIID iid, void **out)
 571 {
 572     struct class_factory *factory = impl_from_IClassFactory(iface);
 573     IUnknown *unk;
 574     HRESULT hr;
 575
 576     TRACE("iface %p, outer %p, iid %s, out %p.\n", iface, outer, debugstr_guid(iid), out);
 577
 578     if (outer && !IsEqualGUID(iid, &IID_IUnknown))
 579         return E_NOINTERFACE;
 580
 581     *out = NULL;
 582     if (SUCCEEDED(hr = factory->create_instance(outer, &unk)))
 583     {
 584         hr = IUnknown_QueryInterface(unk, iid, out);
 585         IUnknown_Release(unk);
 586     }
 587     return hr;
 588 }
 589
 590 static HRESULT WINAPI class_factory_LockServer(IClassFactory *iface, BOOL lock)
 591 {
 592     TRACE("iface %p, lock %d.\n", iface, lock);
 593     return S_OK;
 594 }
 595
 596 static const IClassFactoryVtbl class_factory_vtbl =
 597 {
 598     class_factory_QueryInterface,
 599     class_factory_AddRef,
 600     class_factory_Release,
 601     class_factory_CreateInstance,
 602     class_factory_LockServer,
 603 };
 604
 605 static struct class_factory avi_splitter_cf = {{&class_factory_vtbl}, avi_splitter_create};
 606 static struct class_factory decodebin_parser_cf = {{&class_factory_vtbl}, decodebin_parser_create};
 607 static struct class_factory mpeg_audio_codec_cf = {{&class_factory_vtbl}, mpeg_audio_codec_create};
 608 static struct class_factory mpeg_layer3_decoder_cf = {{&class_factory_vtbl}, mpeg_layer3_decoder_create};
 609 static struct class_factory mpeg_splitter_cf = {{&class_factory_vtbl}, mpeg_splitter_create};
 610 static struct class_factory wave_parser_cf = {{&class_factory_vtbl}, wave_parser_create};
 611 static struct class_factory wma_decoder_cf = {{&class_factory_vtbl}, wma_decoder_create};
 612 static struct class_factory wmv_decoder_cf = {{&class_factory_vtbl}, wmv_decoder_create};
 613 static struct class_factory resampler_cf = {{&class_factory_vtbl}, resampler_create};
 614 static struct class_factory color_convert_cf = {{&class_factory_vtbl}, color_convert_create};
 615
 616 HRESULT WINAPI DllGetClassObject(REFCLSID clsid, REFIID iid, void **out)
 617 {
 618     struct class_factory *factory;
 619     HRESULT hr;
 620
 621     TRACE("clsid %s, iid %s, out %p.\n", debugstr_guid(clsid), debugstr_guid(iid), out);
 622
 623     if (!init_gstreamer())
 624         return CLASS_E_CLASSNOTAVAILABLE;
 625
 626     if (SUCCEEDED(hr = mfplat_get_class_object(clsid, iid, out)))
 627         return hr;
 628
 629     if (IsEqualGUID(clsid, &CLSID_AviSplitter))
 630         factory = &avi_splitter_cf;
 631     else if (IsEqualGUID(clsid, &CLSID_decodebin_parser))
 632         factory = &decodebin_parser_cf;
 633     else if (IsEqualGUID(clsid, &CLSID_CMpegAudioCodec))
 634         factory = &mpeg_audio_codec_cf;
 635     else if (IsEqualGUID(clsid, &CLSID_mpeg_layer3_decoder))
 636         factory = &mpeg_layer3_decoder_cf;
 637     else if (IsEqualGUID(clsid, &CLSID_MPEG1Splitter))
 638         factory = &mpeg_splitter_cf;
 639     else if (IsEqualGUID(clsid, &CLSID_WAVEParser))
 640         factory = &wave_parser_cf;
 641     else if (IsEqualGUID(clsid, &CLSID_WMADecMediaObject))
 642         factory = &wma_decoder_cf;
 643     else if (IsEqualGUID(clsid, &CLSID_WMVDecoderMFT))
 644         factory = &wmv_decoder_cf;
 645     else if (IsEqualGUID(clsid, &CLSID_CResamplerMediaObject))
 646         factory = &resampler_cf;
 647     else if (IsEqualGUID(clsid, &CLSID_CColorConvertDMO))
 648         factory = &color_convert_cf;
 649     else
 650     {
 651         FIXME("%s not implemented, returning CLASS_E_CLASSNOTAVAILABLE.\n", debugstr_guid(clsid));
 652         return CLASS_E_CLASSNOTAVAILABLE;
 653     }
 654
 655     return IClassFactory_QueryInterface(&factory->IClassFactory_iface, iid, out);
 656 }
 657
 658 static BOOL CALLBACK init_gstreamer_proc(INIT_ONCE *once, void *param, void **ctx)
 659 {
 660     HINSTANCE handle;
 661
 662     if (WINE_UNIX_CALL(unix_wg_init_gstreamer, NULL))
 663         return FALSE;
 664
 665     /* Unloading glib is a bad idea.. it installs atexit handlers,
 666      * so never unload the dll after loading */
 667     GetModuleHandleExW(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | GET_MODULE_HANDLE_EX_FLAG_PIN,
 668             (LPCWSTR)init_gstreamer_proc, &handle);
 669     if (!handle)
 670         ERR("Failed to pin module.\n");
 671
 672     return TRUE;
 673 }
 674
 675 BOOL init_gstreamer(void)
 676 {
 677     static INIT_ONCE once = INIT_ONCE_STATIC_INIT;
 678
 679     InitOnceExecuteOnce(&once, init_gstreamer_proc, NULL, NULL);
 680
 681     return TRUE;
 682 }
 683
 684 static const REGPINTYPES reg_audio_mt = {&MEDIATYPE_Audio, &GUID_NULL};
 685 static const REGPINTYPES reg_stream_mt = {&MEDIATYPE_Stream, &GUID_NULL};
 686 static const REGPINTYPES reg_video_mt = {&MEDIATYPE_Video, &GUID_NULL};
 687
 688 static const REGPINTYPES reg_avi_splitter_sink_mt = {&MEDIATYPE_Stream, &MEDIASUBTYPE_Avi};
 689
 690 static const REGFILTERPINS2 reg_avi_splitter_pins[2] =
 691 {
 692     {
 693         .nMediaTypes = 1,
 694         .lpMediaType = &reg_avi_splitter_sink_mt,
 695     },
 696     {
 697         .dwFlags = REG_PINFLAG_B_OUTPUT,
 698         .nMediaTypes = 1,
 699         .lpMediaType = &reg_video_mt,
 700     },
 701 };
 702
 703 static const REGFILTER2 reg_avi_splitter =
 704 {
 705     .dwVersion = 2,
 706     .dwMerit = MERIT_NORMAL,
 707     .u.s2.cPins2 = 2,
 708     .u.s2.rgPins2 = reg_avi_splitter_pins,
 709 };
 710
 711 static const REGPINTYPES reg_mpeg_audio_codec_sink_mts[3] =
 712 {
 713     {&MEDIATYPE_Audio, &MEDIASUBTYPE_MPEG1Packet},
 714     {&MEDIATYPE_Audio, &MEDIASUBTYPE_MPEG1Payload},
 715     {&MEDIATYPE_Audio, &MEDIASUBTYPE_MPEG1AudioPayload},
 716 };
 717
 718 static const REGPINTYPES reg_mpeg_audio_codec_source_mts[1] =
 719 {
 720     {&MEDIATYPE_Audio, &MEDIASUBTYPE_PCM},
 721 };
 722
 723 static const REGFILTERPINS2 reg_mpeg_audio_codec_pins[2] =
 724 {
 725     {
 726         .nMediaTypes = 3,
 727         .lpMediaType = reg_mpeg_audio_codec_sink_mts,
 728     },
 729     {
 730         .dwFlags = REG_PINFLAG_B_OUTPUT,
 731         .nMediaTypes = 1,
 732         .lpMediaType = reg_mpeg_audio_codec_source_mts,
 733     },
 734 };
 735
 736 static const REGFILTER2 reg_mpeg_audio_codec =
 737 {
 738     .dwVersion = 2,
 739     .dwMerit = 0x03680001,
 740     .u.s2.cPins2 = 2,
 741     .u.s2.rgPins2 = reg_mpeg_audio_codec_pins,
 742 };
 743
 744 static const REGPINTYPES reg_mpeg_layer3_decoder_sink_mts[1] =
 745 {
 746     {&MEDIATYPE_Audio, &MEDIASUBTYPE_MP3},
 747 };
 748
 749 static const REGPINTYPES reg_mpeg_layer3_decoder_source_mts[1] =
 750 {
 751     {&MEDIATYPE_Audio, &MEDIASUBTYPE_PCM},
 752 };
 753
 754 static const REGFILTERPINS2 reg_mpeg_layer3_decoder_pins[2] =
 755 {
 756     {
 757         .nMediaTypes = 1,
 758         .lpMediaType = reg_mpeg_layer3_decoder_sink_mts,
 759     },
 760     {
 761         .dwFlags = REG_PINFLAG_B_OUTPUT,
 762         .nMediaTypes = 1,
 763         .lpMediaType = reg_mpeg_layer3_decoder_source_mts,
 764     },
 765 };
 766
 767 static const REGFILTER2 reg_mpeg_layer3_decoder =
 768 {
 769     .dwVersion = 2,
 770     .dwMerit = 0x00810000,
 771     .u.s2.cPins2 = 2,
 772     .u.s2.rgPins2 = reg_mpeg_layer3_decoder_pins,
 773 };
 774
 775 static const REGPINTYPES reg_mpeg_splitter_sink_mts[4] =
 776 {
 777     {&MEDIATYPE_Stream, &MEDIASUBTYPE_MPEG1Audio},
 778     {&MEDIATYPE_Stream, &MEDIASUBTYPE_MPEG1Video},
 779     {&MEDIATYPE_Stream, &MEDIASUBTYPE_MPEG1System},
 780     {&MEDIATYPE_Stream, &MEDIASUBTYPE_MPEG1VideoCD},
 781 };
 782
 783 static const REGPINTYPES reg_mpeg_splitter_audio_mts[2] =
 784 {
 785     {&MEDIATYPE_Audio, &MEDIASUBTYPE_MPEG1Packet},
 786     {&MEDIATYPE_Audio, &MEDIASUBTYPE_MPEG1AudioPayload},
 787 };
 788
 789 static const REGPINTYPES reg_mpeg_splitter_video_mts[2] =
 790 {
 791     {&MEDIATYPE_Video, &MEDIASUBTYPE_MPEG1Packet},
 792     {&MEDIATYPE_Video, &MEDIASUBTYPE_MPEG1Payload},
 793 };
 794
 795 static const REGFILTERPINS2 reg_mpeg_splitter_pins[3] =
 796 {
 797     {
 798         .nMediaTypes = 4,
 799         .lpMediaType = reg_mpeg_splitter_sink_mts,
 800     },
 801     {
 802         .dwFlags = REG_PINFLAG_B_ZERO | REG_PINFLAG_B_OUTPUT,
 803         .nMediaTypes = 2,
 804         .lpMediaType = reg_mpeg_splitter_audio_mts,
 805     },
 806     {
 807         .dwFlags = REG_PINFLAG_B_ZERO | REG_PINFLAG_B_OUTPUT,
 808         .nMediaTypes = 2,
 809         .lpMediaType = reg_mpeg_splitter_video_mts,
 810     },
 811 };
 812
 813 static const REGFILTER2 reg_mpeg_splitter =
 814 {
 815     .dwVersion = 2,
 816     .dwMerit = MERIT_NORMAL,
 817     .u.s2.cPins2 = 3,
 818     .u.s2.rgPins2 = reg_mpeg_splitter_pins,
 819 };
 820
 821 static const REGPINTYPES reg_wave_parser_sink_mts[3] =
 822 {
 823     {&MEDIATYPE_Stream, &MEDIASUBTYPE_WAVE},
 824     {&MEDIATYPE_Stream, &MEDIASUBTYPE_AU},
 825     {&MEDIATYPE_Stream, &MEDIASUBTYPE_AIFF},
 826 };
 827
 828 static const REGFILTERPINS2 reg_wave_parser_pins[2] =
 829 {
 830     {
 831         .nMediaTypes = 3,
 832         .lpMediaType = reg_wave_parser_sink_mts,
 833     },
 834     {
 835         .dwFlags = REG_PINFLAG_B_OUTPUT,
 836         .nMediaTypes = 1,
 837         .lpMediaType = &reg_audio_mt,
 838     },
 839 };
 840
 841 static const REGFILTER2 reg_wave_parser =
 842 {
 843     .dwVersion = 2,
 844     .dwMerit = MERIT_UNLIKELY,
 845     .u.s2.cPins2 = 2,
 846     .u.s2.rgPins2 = reg_wave_parser_pins,
 847 };
 848
 849 static const REGFILTERPINS2 reg_decodebin_parser_pins[3] =
 850 {
 851     {
 852         .nMediaTypes = 1,
 853         .lpMediaType = &reg_stream_mt,
 854     },
 855     {
 856         .dwFlags = REG_PINFLAG_B_OUTPUT,
 857         .nMediaTypes = 1,
 858         .lpMediaType = &reg_audio_mt,
 859     },
 860     {
 861         .dwFlags = REG_PINFLAG_B_OUTPUT,
 862         .nMediaTypes = 1,
 863         .lpMediaType = &reg_video_mt,
 864     },
 865 };
 866
 867 static const REGFILTER2 reg_decodebin_parser =
 868 {
 869     .dwVersion = 2,
 870     .dwMerit = MERIT_PREFERRED,
 871     .u.s2.cPins2 = 3,
 872     .u.s2.rgPins2 = reg_decodebin_parser_pins,
 873 };
 874
 875 HRESULT WINAPI DllRegisterServer(void)
 876 {
 877     DMO_PARTIAL_MEDIATYPE audio_convert_types[2] =
 878     {
 879         {.type = MEDIATYPE_Audio, .subtype = MEDIASUBTYPE_PCM},
 880         {.type = MEDIATYPE_Audio, .subtype = MEDIASUBTYPE_IEEE_FLOAT},
 881     };
 882     DMO_PARTIAL_MEDIATYPE wma_decoder_output[2] =
 883     {
 884         {.type = MEDIATYPE_Audio, .subtype = MEDIASUBTYPE_PCM},
 885         {.type = MEDIATYPE_Audio, .subtype = MEDIASUBTYPE_IEEE_FLOAT},
 886     };
 887     DMO_PARTIAL_MEDIATYPE wma_decoder_input[4] =
 888     {
 889         {.type = MEDIATYPE_Audio, .subtype = MEDIASUBTYPE_MSAUDIO1},
 890         {.type = MEDIATYPE_Audio, .subtype = MEDIASUBTYPE_WMAUDIO2},
 891         {.type = MEDIATYPE_Audio, .subtype = MEDIASUBTYPE_WMAUDIO3},
 892         {.type = MEDIATYPE_Audio, .subtype = MEDIASUBTYPE_WMAUDIO_LOSSLESS},
 893     };
 894     DMO_PARTIAL_MEDIATYPE wmv_decoder_output[11] =
 895     {
 896         {.type = MEDIATYPE_Video, .subtype = MEDIASUBTYPE_YV12},
 897         {.type = MEDIATYPE_Video, .subtype = MEDIASUBTYPE_YUY2},
 898         {.type = MEDIATYPE_Video, .subtype = MEDIASUBTYPE_UYVY},
 899         {.type = MEDIATYPE_Video, .subtype = MEDIASUBTYPE_YVYU},
 900         {.type = MEDIATYPE_Video, .subtype = MEDIASUBTYPE_NV11},
 901         {.type = MEDIATYPE_Video, .subtype = MEDIASUBTYPE_NV12},
 902         {.type = MEDIATYPE_Video, .subtype = MEDIASUBTYPE_RGB32},
 903         {.type = MEDIATYPE_Video, .subtype = MEDIASUBTYPE_RGB24},
 904         {.type = MEDIATYPE_Video, .subtype = MEDIASUBTYPE_RGB565},
 905         {.type = MEDIATYPE_Video, .subtype = MEDIASUBTYPE_RGB555},
 906         {.type = MEDIATYPE_Video, .subtype = MEDIASUBTYPE_RGB8},
 907     };
 908     DMO_PARTIAL_MEDIATYPE wmv_decoder_input[8] =
 909     {
 910         {.type = MEDIATYPE_Video, .subtype = MEDIASUBTYPE_WMV1},
 911         {.type = MEDIATYPE_Video, .subtype = MEDIASUBTYPE_WMV2},
 912         {.type = MEDIATYPE_Video, .subtype = MEDIASUBTYPE_WMV3},
 913         {.type = MEDIATYPE_Video, .subtype = MEDIASUBTYPE_WMVA},
 914         {.type = MEDIATYPE_Video, .subtype = MEDIASUBTYPE_WVC1},
 915         {.type = MEDIATYPE_Video, .subtype = MEDIASUBTYPE_WMVP},
 916         {.type = MEDIATYPE_Video, .subtype = MEDIASUBTYPE_WVP2},
 917         {.type = MEDIATYPE_Video, .subtype = MEDIASUBTYPE_VC1S},
 918     };
 919     DMO_PARTIAL_MEDIATYPE color_convert_input[20] =
 920     {
 921         {.type = MEDIATYPE_Video, .subtype = MEDIASUBTYPE_YV12},
 922         {.type = MEDIATYPE_Video, .subtype = MEDIASUBTYPE_YUY2},
 923         {.type = MEDIATYPE_Video, .subtype = MEDIASUBTYPE_UYVY},
 924         {.type = MEDIATYPE_Video, .subtype = MEDIASUBTYPE_AYUV},
 925         {.type = MEDIATYPE_Video, .subtype = MEDIASUBTYPE_NV12},
 926         {.type = MEDIATYPE_Video, .subtype = MEDIASUBTYPE_RGB32},
 927         {.type = MEDIATYPE_Video, .subtype = MEDIASUBTYPE_RGB565},
 928         {.type = MEDIATYPE_Video, .subtype = MEDIASUBTYPE_I420},
 929         {.type = MEDIATYPE_Video, .subtype = MEDIASUBTYPE_IYUV},
 930         {.type = MEDIATYPE_Video, .subtype = MEDIASUBTYPE_YVYU},
 931         {.type = MEDIATYPE_Video, .subtype = MEDIASUBTYPE_RGB24},
 932         {.type = MEDIATYPE_Video, .subtype = MEDIASUBTYPE_RGB555},
 933         {.type = MEDIATYPE_Video, .subtype = MEDIASUBTYPE_RGB8},
 934         {.type = MEDIATYPE_Video, .subtype = MEDIASUBTYPE_V216},
 935         {.type = MEDIATYPE_Video, .subtype = MEDIASUBTYPE_V410},
 936         {.type = MEDIATYPE_Video, .subtype = MEDIASUBTYPE_NV11},
 937         {.type = MEDIATYPE_Video, .subtype = MEDIASUBTYPE_Y41P},
 938         {.type = MEDIATYPE_Video, .subtype = MEDIASUBTYPE_Y41T},
 939         {.type = MEDIATYPE_Video, .subtype = MEDIASUBTYPE_Y42T},
 940         {.type = MEDIATYPE_Video, .subtype = MEDIASUBTYPE_YVU9},
 941     };
 942     DMO_PARTIAL_MEDIATYPE color_convert_output[16] =
 943     {
 944         {.type = MEDIATYPE_Video, .subtype = MEDIASUBTYPE_YV12},
 945         {.type = MEDIATYPE_Video, .subtype = MEDIASUBTYPE_YUY2},
 946         {.type = MEDIATYPE_Video, .subtype = MEDIASUBTYPE_UYVY},
 947         {.type = MEDIATYPE_Video, .subtype = MEDIASUBTYPE_AYUV},
 948         {.type = MEDIATYPE_Video, .subtype = MEDIASUBTYPE_NV12},
 949         {.type = MEDIATYPE_Video, .subtype = MEDIASUBTYPE_RGB32},
 950         {.type = MEDIATYPE_Video, .subtype = MEDIASUBTYPE_RGB565},
 951         {.type = MEDIATYPE_Video, .subtype = MEDIASUBTYPE_I420},
 952         {.type = MEDIATYPE_Video, .subtype = MEDIASUBTYPE_IYUV},
 953         {.type = MEDIATYPE_Video, .subtype = MEDIASUBTYPE_YVYU},
 954         {.type = MEDIATYPE_Video, .subtype = MEDIASUBTYPE_RGB24},
 955         {.type = MEDIATYPE_Video, .subtype = MEDIASUBTYPE_RGB555},
 956         {.type = MEDIATYPE_Video, .subtype = MEDIASUBTYPE_RGB8},
 957         {.type = MEDIATYPE_Video, .subtype = MEDIASUBTYPE_V216},
 958         {.type = MEDIATYPE_Video, .subtype = MEDIASUBTYPE_V410},
 959         {.type = MEDIATYPE_Video, .subtype = MEDIASUBTYPE_NV11},
 960     };
 961
 962     IFilterMapper2 *mapper;
 963     HRESULT hr;
 964
 965     TRACE(".\n");
 966
 967     if (FAILED(hr = __wine_register_resources()))
 968         return hr;
 969
 970     if (FAILED(hr = CoCreateInstance(&CLSID_FilterMapper2, NULL, CLSCTX_INPROC_SERVER,
 971             &IID_IFilterMapper2, (void **)&mapper)))
 972         return hr;
 973
 974     IFilterMapper2_RegisterFilter(mapper, &CLSID_AviSplitter, L"AVI Splitter", NULL, NULL, NULL, &reg_avi_splitter);
 975     IFilterMapper2_RegisterFilter(mapper, &CLSID_decodebin_parser,
 976             L"GStreamer splitter filter", NULL, NULL, NULL, &reg_decodebin_parser);
 977     IFilterMapper2_RegisterFilter(mapper, &CLSID_CMpegAudioCodec,
 978             L"MPEG Audio Decoder", NULL, NULL, NULL, &reg_mpeg_audio_codec);
 979     IFilterMapper2_RegisterFilter(mapper, &CLSID_mpeg_layer3_decoder,
 980             L"MPEG Layer-3 Decoder", NULL, NULL, NULL, &reg_mpeg_layer3_decoder);
 981     IFilterMapper2_RegisterFilter(mapper, &CLSID_MPEG1Splitter,
 982             L"MPEG-I Stream Splitter", NULL, NULL, NULL, &reg_mpeg_splitter);
 983     IFilterMapper2_RegisterFilter(mapper, &CLSID_WAVEParser, L"Wave Parser", NULL, NULL, NULL, &reg_wave_parser);
 984
 985     IFilterMapper2_Release(mapper);
 986
 987     if (FAILED(hr = DMORegister(L"WMAudio Decoder DMO", &CLSID_WMADecMediaObject, &DMOCATEGORY_AUDIO_DECODER,
 988             0, ARRAY_SIZE(wma_decoder_input), wma_decoder_input, ARRAY_SIZE(wma_decoder_output), wma_decoder_output)))
 989         return hr;
 990     if (FAILED(hr = DMORegister(L"WMVideo Decoder DMO", &CLSID_WMVDecoderMFT, &DMOCATEGORY_VIDEO_DECODER,
 991             0, ARRAY_SIZE(wmv_decoder_input), wmv_decoder_input, ARRAY_SIZE(wmv_decoder_output), wmv_decoder_output)))
 992         return hr;
 993     if (FAILED(hr = DMORegister(L"Resampler DMO", &CLSID_CResamplerMediaObject, &DMOCATEGORY_AUDIO_EFFECT,
 994             0, ARRAY_SIZE(audio_convert_types), audio_convert_types, ARRAY_SIZE(audio_convert_types), audio_convert_types)))
 995         return hr;
 996     if (FAILED(hr = DMORegister(L"Color Converter DMO", &CLSID_CColorConvertDMO, &DMOCATEGORY_VIDEO_EFFECT,
 997             0, ARRAY_SIZE(color_convert_input), color_convert_input, ARRAY_SIZE(color_convert_output), color_convert_output)))
 998         return hr;
 999
1000     return mfplat_DllRegisterServer();
1001 }
1002
1003 HRESULT WINAPI DllUnregisterServer(void)
1004 {
1005     IFilterMapper2 *mapper;
1006     HRESULT hr;
1007
1008     TRACE(".\n");
1009
1010     if (FAILED(hr = __wine_unregister_resources()))
1011         return hr;
1012
1013     if (FAILED(hr = CoCreateInstance(&CLSID_FilterMapper2, NULL, CLSCTX_INPROC_SERVER,
1014             &IID_IFilterMapper2, (void **)&mapper)))
1015         return hr;
1016
1017     IFilterMapper2_UnregisterFilter(mapper, NULL, NULL, &CLSID_AviSplitter);
1018     IFilterMapper2_UnregisterFilter(mapper, NULL, NULL, &CLSID_decodebin_parser);
1019     IFilterMapper2_UnregisterFilter(mapper, NULL, NULL, &CLSID_CMpegAudioCodec);
1020     IFilterMapper2_UnregisterFilter(mapper, NULL, NULL, &CLSID_mpeg_layer3_decoder);
1021     IFilterMapper2_UnregisterFilter(mapper, NULL, NULL, &CLSID_MPEG1Splitter);
1022     IFilterMapper2_UnregisterFilter(mapper, NULL, NULL, &CLSID_WAVEParser);
1023
1024     IFilterMapper2_Release(mapper);
1025
1026     if (FAILED(hr = DMOUnregister(&CLSID_CColorConvertDMO, &DMOCATEGORY_VIDEO_EFFECT)))
1027         return hr;
1028     if (FAILED(hr = DMOUnregister(&CLSID_CResamplerMediaObject, &DMOCATEGORY_AUDIO_EFFECT)))
1029         return hr;
1030     if (FAILED(hr = DMOUnregister(&CLSID_WMADecMediaObject, &DMOCATEGORY_AUDIO_DECODER)))
1031         return hr;
1032     if (FAILED(hr = DMOUnregister(&CLSID_WMVDecoderMFT, &DMOCATEGORY_VIDEO_DECODER)))
1033         return hr;
1034
1035     return S_OK;
1036 }