dlls/mf/topology.c

   1 /*
   2  * Copyright 2017 Nikolay Sivov
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19
  20 #include <stdarg.h>
  21
  22 #define COBJMACROS
  23
  24 #include "windef.h"
  25 #include "winbase.h"
  26
  27 #undef INITGUID
  28 #include <guiddef.h>
  29 #include "mfidl.h"
  30
  31 #include "wine/debug.h"
  32
  33 #include "mf_private.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(mfplat);
  36
  37 static LONG next_node_id;
  38 static TOPOID next_topology_id;
  39
  40 struct node_stream
  41 {
  42     IMFMediaType *preferred_type;
  43     struct topology_node *connection;
  44     DWORD connection_stream;
  45 };
  46
  47 struct node_streams
  48 {
  49     struct node_stream *streams;
  50     size_t size;
  51     size_t count;
  52 };
  53
  54 struct topology_node
  55 {
  56     IMFTopologyNode IMFTopologyNode_iface;
  57     LONG refcount;
  58     IMFAttributes *attributes;
  59     MF_TOPOLOGY_TYPE node_type;
  60     TOPOID id;
  61     IUnknown *object;
  62     IMFMediaType *input_type; /* Only for tee nodes. */
  63     struct node_streams inputs;
  64     struct node_streams outputs;
  65     CRITICAL_SECTION cs;
  66 };
  67
  68 struct topology
  69 {
  70     IMFTopology IMFTopology_iface;
  71     LONG refcount;
  72     IMFAttributes *attributes;
  73     struct
  74     {
  75         struct topology_node **nodes;
  76         size_t size;
  77         size_t count;
  78     } nodes;
  79     TOPOID id;
  80 };
  81
  82 struct seq_source
  83 {
  84     IMFSequencerSource IMFSequencerSource_iface;
  85     IMFMediaSourceTopologyProvider IMFMediaSourceTopologyProvider_iface;
  86     LONG refcount;
  87 };
  88
  89 static inline struct topology *impl_from_IMFTopology(IMFTopology *iface)
  90 {
  91     return CONTAINING_RECORD(iface, struct topology, IMFTopology_iface);
  92 }
  93
  94 static struct topology_node *impl_from_IMFTopologyNode(IMFTopologyNode *iface)
  95 {
  96     return CONTAINING_RECORD(iface, struct topology_node, IMFTopologyNode_iface);
  97 }
  98
  99 static const IMFTopologyNodeVtbl topologynodevtbl;
 100
 101 static struct topology_node *unsafe_impl_from_IMFTopologyNode(IMFTopologyNode *iface)
 102 {
 103     if (!iface || iface->lpVtbl != &topologynodevtbl)
 104         return NULL;
 105     return impl_from_IMFTopologyNode(iface);
 106 }
 107
 108 static HRESULT create_topology_node(MF_TOPOLOGY_TYPE node_type, struct topology_node **node);
 109 static HRESULT topology_node_connect_output(struct topology_node *node, DWORD output_index,
 110         struct topology_node *connection, DWORD input_index);
 111
 112 static struct topology *unsafe_impl_from_IMFTopology(IMFTopology *iface);
 113
 114 static struct seq_source *impl_from_IMFSequencerSource(IMFSequencerSource *iface)
 115 {
 116     return CONTAINING_RECORD(iface, struct seq_source, IMFSequencerSource_iface);
 117 }
 118
 119 static struct seq_source *impl_from_IMFMediaSourceTopologyProvider(IMFMediaSourceTopologyProvider *iface)
 120 {
 121     return CONTAINING_RECORD(iface, struct seq_source, IMFMediaSourceTopologyProvider_iface);
 122 }
 123
 124 static HRESULT topology_node_reserve_streams(struct node_streams *streams, DWORD index)
 125 {
 126     if (!mf_array_reserve((void **)&streams->streams, &streams->size, index + 1, sizeof(*streams->streams)))
 127         return E_OUTOFMEMORY;
 128
 129     if (index >= streams->count)
 130     {
 131         memset(&streams->streams[streams->count], 0, (index - streams->count + 1) * sizeof(*streams->streams));
 132         streams->count = index + 1;
 133     }
 134
 135     return S_OK;
 136 }
 137
 138 static HRESULT WINAPI topology_QueryInterface(IMFTopology *iface, REFIID riid, void **out)
 139 {
 140     struct topology *topology = impl_from_IMFTopology(iface);
 141
 142     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), out);
 143
 144     if (IsEqualIID(riid, &IID_IMFTopology) ||
 145             IsEqualIID(riid, &IID_IMFAttributes) ||
 146             IsEqualIID(riid, &IID_IUnknown))
 147     {
 148         *out = &topology->IMFTopology_iface;
 149     }
 150     else
 151     {
 152         FIXME("(%s, %p)\n", debugstr_guid(riid), out);
 153         *out = NULL;
 154         return E_NOINTERFACE;
 155     }
 156
 157     IUnknown_AddRef((IUnknown*)*out);
 158     return S_OK;
 159 }
 160
 161 static ULONG WINAPI topology_AddRef(IMFTopology *iface)
 162 {
 163     struct topology *topology = impl_from_IMFTopology(iface);
 164     ULONG refcount = InterlockedIncrement(&topology->refcount);
 165
 166     TRACE("%p, refcount %lu.\n", iface, refcount);
 167
 168     return refcount;
 169 }
 170
 171 static HRESULT topology_node_disconnect_output(struct topology_node *node, DWORD output_index)
 172 {
 173     struct topology_node *connection = NULL;
 174     struct node_stream *stream;
 175     DWORD connection_stream;
 176     HRESULT hr = S_OK;
 177
 178     EnterCriticalSection(&node->cs);
 179
 180     if (output_index < node->outputs.count)
 181     {
 182         stream = &node->outputs.streams[output_index];
 183
 184         if (stream->connection)
 185         {
 186             connection = stream->connection;
 187             connection_stream = stream->connection_stream;
 188             stream->connection = NULL;
 189             stream->connection_stream = 0;
 190         }
 191         else
 192             hr = MF_E_NOT_FOUND;
 193     }
 194     else
 195         hr = E_INVALIDARG;
 196
 197     LeaveCriticalSection(&node->cs);
 198
 199     if (connection)
 200     {
 201         EnterCriticalSection(&connection->cs);
 202
 203         if (connection_stream < connection->inputs.count)
 204         {
 205             stream = &connection->inputs.streams[connection_stream];
 206
 207             if (stream->connection)
 208             {
 209                 stream->connection = NULL;
 210                 stream->connection_stream = 0;
 211             }
 212         }
 213
 214         LeaveCriticalSection(&connection->cs);
 215
 216         IMFTopologyNode_Release(&connection->IMFTopologyNode_iface);
 217         IMFTopologyNode_Release(&node->IMFTopologyNode_iface);
 218     }
 219
 220     return hr;
 221 }
 222
 223 static void topology_node_disconnect(struct topology_node *node)
 224 {
 225     struct node_stream *stream;
 226     size_t i;
 227
 228     for (i = 0; i < node->outputs.count; ++i)
 229         topology_node_disconnect_output(node, i);
 230
 231     for (i = 0; i < node->inputs.count; ++i)
 232     {
 233         stream = &node->inputs.streams[i];
 234         if (stream->connection)
 235             topology_node_disconnect_output(stream->connection, stream->connection_stream);
 236     }
 237 }
 238
 239 static void topology_clear(struct topology *topology)
 240 {
 241     size_t i;
 242
 243     for (i = 0; i < topology->nodes.count; ++i)
 244     {
 245         topology_node_disconnect(topology->nodes.nodes[i]);
 246         IMFTopologyNode_Release(&topology->nodes.nodes[i]->IMFTopologyNode_iface);
 247     }
 248     free(topology->nodes.nodes);
 249     topology->nodes.nodes = NULL;
 250     topology->nodes.count = 0;
 251     topology->nodes.size = 0;
 252 }
 253
 254 static ULONG WINAPI topology_Release(IMFTopology *iface)
 255 {
 256     struct topology *topology = impl_from_IMFTopology(iface);
 257     ULONG refcount = InterlockedDecrement(&topology->refcount);
 258
 259     TRACE("%p, refcount %lu.\n", iface, refcount);
 260
 261     if (!refcount)
 262     {
 263         if (topology->attributes)
 264             IMFAttributes_Release(topology->attributes);
 265         topology_clear(topology);
 266         free(topology);
 267     }
 268
 269     return refcount;
 270 }
 271
 272 static HRESULT WINAPI topology_GetItem(IMFTopology *iface, REFGUID key, PROPVARIANT *value)
 273 {
 274     struct topology *topology = impl_from_IMFTopology(iface);
 275
 276     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
 277
 278     return IMFAttributes_GetItem(topology->attributes, key, value);
 279 }
 280
 281 static HRESULT WINAPI topology_GetItemType(IMFTopology *iface, REFGUID key, MF_ATTRIBUTE_TYPE *type)
 282 {
 283     struct topology *topology = impl_from_IMFTopology(iface);
 284
 285     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), type);
 286
 287     return IMFAttributes_GetItemType(topology->attributes, key, type);
 288 }
 289
 290 static HRESULT WINAPI topology_CompareItem(IMFTopology *iface, REFGUID key, REFPROPVARIANT value, BOOL *result)
 291 {
 292     struct topology *topology = impl_from_IMFTopology(iface);
 293
 294     TRACE("%p, %s, %p, %p.\n", iface, debugstr_guid(key), value, result);
 295
 296     return IMFAttributes_CompareItem(topology->attributes, key, value, result);
 297 }
 298
 299 static HRESULT WINAPI topology_Compare(IMFTopology *iface, IMFAttributes *theirs, MF_ATTRIBUTES_MATCH_TYPE type,
 300         BOOL *result)
 301 {
 302     struct topology *topology = impl_from_IMFTopology(iface);
 303
 304     TRACE("%p, %p, %d, %p.\n", iface, theirs, type, result);
 305
 306     return IMFAttributes_Compare(topology->attributes, theirs, type, result);
 307 }
 308
 309 static HRESULT WINAPI topology_GetUINT32(IMFTopology *iface, REFGUID key, UINT32 *value)
 310 {
 311     struct topology *topology = impl_from_IMFTopology(iface);
 312
 313     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
 314
 315     return IMFAttributes_GetUINT32(topology->attributes, key, value);
 316 }
 317
 318 static HRESULT WINAPI topology_GetUINT64(IMFTopology *iface, REFGUID key, UINT64 *value)
 319 {
 320     struct topology *topology = impl_from_IMFTopology(iface);
 321
 322     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
 323
 324     return IMFAttributes_GetUINT64(topology->attributes, key, value);
 325 }
 326
 327 static HRESULT WINAPI topology_GetDouble(IMFTopology *iface, REFGUID key, double *value)
 328 {
 329     struct topology *topology = impl_from_IMFTopology(iface);
 330
 331     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
 332
 333     return IMFAttributes_GetDouble(topology->attributes, key, value);
 334 }
 335
 336 static HRESULT WINAPI topology_GetGUID(IMFTopology *iface, REFGUID key, GUID *value)
 337 {
 338     struct topology *topology = impl_from_IMFTopology(iface);
 339
 340     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
 341
 342     return IMFAttributes_GetGUID(topology->attributes, key, value);
 343 }
 344
 345 static HRESULT WINAPI topology_GetStringLength(IMFTopology *iface, REFGUID key, UINT32 *length)
 346 {
 347     struct topology *topology = impl_from_IMFTopology(iface);
 348
 349     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), length);
 350
 351     return IMFAttributes_GetStringLength(topology->attributes, key, length);
 352 }
 353
 354 static HRESULT WINAPI topology_GetString(IMFTopology *iface, REFGUID key, WCHAR *value,
 355         UINT32 size, UINT32 *length)
 356 {
 357     struct topology *topology = impl_from_IMFTopology(iface);
 358
 359     TRACE("%p, %s, %p, %d, %p.\n", iface, debugstr_guid(key), value, size, length);
 360
 361     return IMFAttributes_GetString(topology->attributes, key, value, size, length);
 362 }
 363
 364 static HRESULT WINAPI topology_GetAllocatedString(IMFTopology *iface, REFGUID key,
 365         WCHAR **value, UINT32 *length)
 366 {
 367     struct topology *topology = impl_from_IMFTopology(iface);
 368
 369     TRACE("%p, %s, %p, %p.\n", iface, debugstr_guid(key), value, length);
 370
 371     return IMFAttributes_GetAllocatedString(topology->attributes, key, value, length);
 372 }
 373
 374 static HRESULT WINAPI topology_GetBlobSize(IMFTopology *iface, REFGUID key, UINT32 *size)
 375 {
 376     struct topology *topology = impl_from_IMFTopology(iface);
 377
 378     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), size);
 379
 380     return IMFAttributes_GetBlobSize(topology->attributes, key, size);
 381 }
 382
 383 static HRESULT WINAPI topology_GetBlob(IMFTopology *iface, REFGUID key, UINT8 *buf,
 384         UINT32 bufsize, UINT32 *blobsize)
 385 {
 386     struct topology *topology = impl_from_IMFTopology(iface);
 387
 388     TRACE("%p, %s, %p, %d, %p.\n", iface, debugstr_guid(key), buf, bufsize, blobsize);
 389
 390     return IMFAttributes_GetBlob(topology->attributes, key, buf, bufsize, blobsize);
 391 }
 392
 393 static HRESULT WINAPI topology_GetAllocatedBlob(IMFTopology *iface, REFGUID key, UINT8 **buf, UINT32 *size)
 394 {
 395     struct topology *topology = impl_from_IMFTopology(iface);
 396
 397     TRACE("%p, %s, %p, %p.\n", iface, debugstr_guid(key), buf, size);
 398
 399     return IMFAttributes_GetAllocatedBlob(topology->attributes, key, buf, size);
 400 }
 401
 402 static HRESULT WINAPI topology_GetUnknown(IMFTopology *iface, REFGUID key, REFIID riid, void **ppv)
 403 {
 404     struct topology *topology = impl_from_IMFTopology(iface);
 405
 406     TRACE("%p, %s, %s, %p.\n", iface, debugstr_guid(key), debugstr_guid(riid), ppv);
 407
 408     return IMFAttributes_GetUnknown(topology->attributes, key, riid, ppv);
 409 }
 410
 411 static HRESULT WINAPI topology_SetItem(IMFTopology *iface, REFGUID key, REFPROPVARIANT value)
 412 {
 413     struct topology *topology = impl_from_IMFTopology(iface);
 414
 415     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
 416
 417     return IMFAttributes_SetItem(topology->attributes, key, value);
 418 }
 419
 420 static HRESULT WINAPI topology_DeleteItem(IMFTopology *iface, REFGUID key)
 421 {
 422     struct topology *topology = impl_from_IMFTopology(iface);
 423
 424     TRACE("%p, %s.\n", topology, debugstr_guid(key));
 425
 426     return IMFAttributes_DeleteItem(topology->attributes, key);
 427 }
 428
 429 static HRESULT WINAPI topology_DeleteAllItems(IMFTopology *iface)
 430 {
 431     struct topology *topology = impl_from_IMFTopology(iface);
 432
 433     TRACE("%p.\n", iface);
 434
 435     return IMFAttributes_DeleteAllItems(topology->attributes);
 436 }
 437
 438 static HRESULT WINAPI topology_SetUINT32(IMFTopology *iface, REFGUID key, UINT32 value)
 439 {
 440     struct topology *topology = impl_from_IMFTopology(iface);
 441
 442     TRACE("%p, %s, %d.\n", iface, debugstr_guid(key), value);
 443
 444     return IMFAttributes_SetUINT32(topology->attributes, key, value);
 445 }
 446
 447 static HRESULT WINAPI topology_SetUINT64(IMFTopology *iface, REFGUID key, UINT64 value)
 448 {
 449     struct topology *topology = impl_from_IMFTopology(iface);
 450
 451     TRACE("%p, %s, %s.\n", iface, debugstr_guid(key), wine_dbgstr_longlong(value));
 452
 453     return IMFAttributes_SetUINT64(topology->attributes, key, value);
 454 }
 455
 456 static HRESULT WINAPI topology_SetDouble(IMFTopology *iface, REFGUID key, double value)
 457 {
 458     struct topology *topology = impl_from_IMFTopology(iface);
 459
 460     TRACE("%p, %s, %f.\n", iface, debugstr_guid(key), value);
 461
 462     return IMFAttributes_SetDouble(topology->attributes, key, value);
 463 }
 464
 465 static HRESULT WINAPI topology_SetGUID(IMFTopology *iface, REFGUID key, REFGUID value)
 466 {
 467     struct topology *topology = impl_from_IMFTopology(iface);
 468
 469     TRACE("%p, %s, %s.\n", iface, debugstr_guid(key), debugstr_guid(value));
 470
 471     return IMFAttributes_SetGUID(topology->attributes, key, value);
 472 }
 473
 474 static HRESULT WINAPI topology_SetString(IMFTopology *iface, REFGUID key, const WCHAR *value)
 475 {
 476     struct topology *topology = impl_from_IMFTopology(iface);
 477
 478     TRACE("%p, %s, %s.\n", iface, debugstr_guid(key), debugstr_w(value));
 479
 480     return IMFAttributes_SetString(topology->attributes, key, value);
 481 }
 482
 483 static HRESULT WINAPI topology_SetBlob(IMFTopology *iface, REFGUID key, const UINT8 *buf, UINT32 size)
 484 {
 485     struct topology *topology = impl_from_IMFTopology(iface);
 486
 487     TRACE("%p, %s, %p, %d.\n", iface, debugstr_guid(key), buf, size);
 488
 489     return IMFAttributes_SetBlob(topology->attributes, key, buf, size);
 490 }
 491
 492 static HRESULT WINAPI topology_SetUnknown(IMFTopology *iface, REFGUID key, IUnknown *unknown)
 493 {
 494     struct topology *topology = impl_from_IMFTopology(iface);
 495
 496     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), unknown);
 497
 498     return IMFAttributes_SetUnknown(topology->attributes, key, unknown);
 499 }
 500
 501 static HRESULT WINAPI topology_LockStore(IMFTopology *iface)
 502 {
 503     struct topology *topology = impl_from_IMFTopology(iface);
 504
 505     TRACE("%p.\n", iface);
 506
 507     return IMFAttributes_LockStore(topology->attributes);
 508 }
 509
 510 static HRESULT WINAPI topology_UnlockStore(IMFTopology *iface)
 511 {
 512     struct topology *topology = impl_from_IMFTopology(iface);
 513
 514     TRACE("%p.\n", iface);
 515
 516     return IMFAttributes_UnlockStore(topology->attributes);
 517 }
 518
 519 static HRESULT WINAPI topology_GetCount(IMFTopology *iface, UINT32 *count)
 520 {
 521     struct topology *topology = impl_from_IMFTopology(iface);
 522
 523     TRACE("%p, %p.\n", iface, count);
 524
 525     return IMFAttributes_GetCount(topology->attributes, count);
 526 }
 527
 528 static HRESULT WINAPI topology_GetItemByIndex(IMFTopology *iface, UINT32 index, GUID *key, PROPVARIANT *value)
 529 {
 530     struct topology *topology = impl_from_IMFTopology(iface);
 531
 532     TRACE("%p, %u, %p, %p.\n", iface, index, key, value);
 533
 534     return IMFAttributes_GetItemByIndex(topology->attributes, index, key, value);
 535 }
 536
 537 static HRESULT WINAPI topology_CopyAllItems(IMFTopology *iface, IMFAttributes *dest)
 538 {
 539     struct topology *topology = impl_from_IMFTopology(iface);
 540
 541     TRACE("%p, %p.\n", iface, dest);
 542
 543     return IMFAttributes_CopyAllItems(topology->attributes, dest);
 544 }
 545
 546 static HRESULT WINAPI topology_GetTopologyID(IMFTopology *iface, TOPOID *id)
 547 {
 548     struct topology *topology = impl_from_IMFTopology(iface);
 549
 550     TRACE("%p, %p.\n", iface, id);
 551
 552     if (!id)
 553         return E_POINTER;
 554
 555     *id = topology->id;
 556
 557     return S_OK;
 558 }
 559
 560 static HRESULT topology_get_node_by_id(const struct topology *topology, TOPOID id, struct topology_node **node)
 561 {
 562     size_t i = 0;
 563
 564     for (i = 0; i < topology->nodes.count; ++i)
 565     {
 566         if (topology->nodes.nodes[i]->id == id)
 567         {
 568             *node = topology->nodes.nodes[i];
 569             return S_OK;
 570         }
 571     }
 572
 573     return MF_E_NOT_FOUND;
 574 }
 575
 576 static HRESULT topology_add_node(struct topology *topology, struct topology_node *node)
 577 {
 578     struct topology_node *match;
 579
 580     if (!node)
 581         return E_POINTER;
 582
 583     if (SUCCEEDED(topology_get_node_by_id(topology, node->id, &match)))
 584         return E_INVALIDARG;
 585
 586     if (!mf_array_reserve((void **)&topology->nodes.nodes, &topology->nodes.size, topology->nodes.count + 1,
 587             sizeof(*topology->nodes.nodes)))
 588     {
 589         return E_OUTOFMEMORY;
 590     }
 591
 592     topology->nodes.nodes[topology->nodes.count++] = node;
 593     IMFTopologyNode_AddRef(&node->IMFTopologyNode_iface);
 594
 595     return S_OK;
 596 }
 597
 598 static HRESULT WINAPI topology_AddNode(IMFTopology *iface, IMFTopologyNode *node_iface)
 599 {
 600     struct topology *topology = impl_from_IMFTopology(iface);
 601     struct topology_node *node = unsafe_impl_from_IMFTopologyNode(node_iface);
 602
 603     TRACE("%p, %p.\n", iface, node_iface);
 604
 605     return topology_add_node(topology, node);
 606 }
 607
 608 static HRESULT WINAPI topology_RemoveNode(IMFTopology *iface, IMFTopologyNode *node)
 609 {
 610     struct topology *topology = impl_from_IMFTopology(iface);
 611     size_t i, count;
 612
 613     TRACE("%p, %p.\n", iface, node);
 614
 615     for (i = 0; i < topology->nodes.count; ++i)
 616     {
 617         if (&topology->nodes.nodes[i]->IMFTopologyNode_iface == node)
 618         {
 619             topology_node_disconnect(topology->nodes.nodes[i]);
 620             IMFTopologyNode_Release(&topology->nodes.nodes[i]->IMFTopologyNode_iface);
 621             count = topology->nodes.count - i - 1;
 622             if (count)
 623             {
 624                 memmove(&topology->nodes.nodes[i], &topology->nodes.nodes[i + 1],
 625                         count * sizeof(*topology->nodes.nodes));
 626             }
 627             topology->nodes.count--;
 628             return S_OK;
 629         }
 630     }
 631
 632     return E_INVALIDARG;
 633 }
 634
 635 static HRESULT WINAPI topology_GetNodeCount(IMFTopology *iface, WORD *count)
 636 {
 637     struct topology *topology = impl_from_IMFTopology(iface);
 638
 639     TRACE("%p, %p.\n", iface, count);
 640
 641     if (!count)
 642         return E_POINTER;
 643
 644     *count = topology->nodes.count;
 645
 646     return S_OK;
 647 }
 648
 649 static HRESULT WINAPI topology_GetNode(IMFTopology *iface, WORD index, IMFTopologyNode **node)
 650 {
 651     struct topology *topology = impl_from_IMFTopology(iface);
 652
 653     TRACE("%p, %u, %p.\n", iface, index, node);
 654
 655     if (!node)
 656         return E_POINTER;
 657
 658     if (index >= topology->nodes.count)
 659         return MF_E_INVALIDINDEX;
 660
 661     *node = &topology->nodes.nodes[index]->IMFTopologyNode_iface;
 662     IMFTopologyNode_AddRef(*node);
 663
 664     return S_OK;
 665 }
 666
 667 static HRESULT WINAPI topology_Clear(IMFTopology *iface)
 668 {
 669     struct topology *topology = impl_from_IMFTopology(iface);
 670
 671     TRACE("%p.\n", iface);
 672
 673     topology_clear(topology);
 674     return S_OK;
 675 }
 676
 677 static HRESULT WINAPI topology_CloneFrom(IMFTopology *iface, IMFTopology *src)
 678 {
 679     struct topology *topology = impl_from_IMFTopology(iface);
 680     struct topology *src_topology = unsafe_impl_from_IMFTopology(src);
 681     struct topology_node *node;
 682     size_t i, j;
 683     HRESULT hr;
 684
 685     TRACE("%p, %p.\n", iface, src);
 686
 687     topology_clear(topology);
 688
 689     /* Clone nodes. */
 690     for (i = 0; i < src_topology->nodes.count; ++i)
 691     {
 692         if (FAILED(hr = create_topology_node(src_topology->nodes.nodes[i]->node_type, &node)))
 693         {
 694             WARN("Failed to create a node, hr %#lx.\n", hr);
 695             break;
 696         }
 697
 698         if (SUCCEEDED(hr = IMFTopologyNode_CloneFrom(&node->IMFTopologyNode_iface,
 699                 &src_topology->nodes.nodes[i]->IMFTopologyNode_iface)))
 700         {
 701             topology_add_node(topology, node);
 702         }
 703
 704         IMFTopologyNode_Release(&node->IMFTopologyNode_iface);
 705     }
 706
 707     /* Clone connections. */
 708     for (i = 0; i < src_topology->nodes.count; ++i)
 709     {
 710         const struct node_streams *outputs = &src_topology->nodes.nodes[i]->outputs;
 711
 712         for (j = 0; j < outputs->count; ++j)
 713         {
 714             DWORD input_index = outputs->streams[j].connection_stream;
 715             TOPOID id;
 716
 717             if (!outputs->streams[j].connection)
 718                 continue;
 719
 720             id = outputs->streams[j].connection->id;
 721
 722             /* Skip node lookup in destination topology, assuming same node order. */
 723             if (SUCCEEDED(hr = topology_get_node_by_id(topology, id, &node)))
 724                 topology_node_connect_output(topology->nodes.nodes[i], j, node, input_index);
 725         }
 726     }
 727
 728     /* Copy attributes and id. */
 729     hr = IMFTopology_CopyAllItems(src, (IMFAttributes *)&topology->IMFTopology_iface);
 730     if (SUCCEEDED(hr))
 731         topology->id = src_topology->id;
 732
 733     return S_OK;
 734 }
 735
 736 static HRESULT WINAPI topology_GetNodeByID(IMFTopology *iface, TOPOID id, IMFTopologyNode **ret)
 737 {
 738     struct topology *topology = impl_from_IMFTopology(iface);
 739     struct topology_node *node;
 740     HRESULT hr;
 741
 742     TRACE("%p, %p.\n", iface, ret);
 743
 744     if (SUCCEEDED(hr = topology_get_node_by_id(topology, id, &node)))
 745     {
 746         *ret = &node->IMFTopologyNode_iface;
 747         IMFTopologyNode_AddRef(*ret);
 748     }
 749     else
 750         *ret = NULL;
 751
 752     return hr;
 753 }
 754
 755 static HRESULT topology_get_node_collection(const struct topology *topology, MF_TOPOLOGY_TYPE node_type,
 756         IMFCollection **collection)
 757 {
 758     HRESULT hr;
 759     size_t i;
 760
 761     if (!collection)
 762         return E_POINTER;
 763
 764     if (FAILED(hr = MFCreateCollection(collection)))
 765         return hr;
 766
 767     for (i = 0; i < topology->nodes.count; ++i)
 768     {
 769         if (topology->nodes.nodes[i]->node_type == node_type)
 770         {
 771             if (FAILED(hr = IMFCollection_AddElement(*collection,
 772                     (IUnknown *)&topology->nodes.nodes[i]->IMFTopologyNode_iface)))
 773             {
 774                 IMFCollection_Release(*collection);
 775                 *collection = NULL;
 776                 break;
 777             }
 778         }
 779     }
 780
 781     return hr;
 782 }
 783
 784 static HRESULT WINAPI topology_GetSourceNodeCollection(IMFTopology *iface, IMFCollection **collection)
 785 {
 786     struct topology *topology = impl_from_IMFTopology(iface);
 787
 788     TRACE("%p, %p.\n", iface, collection);
 789
 790     return topology_get_node_collection(topology, MF_TOPOLOGY_SOURCESTREAM_NODE, collection);
 791 }
 792
 793 static HRESULT WINAPI topology_GetOutputNodeCollection(IMFTopology *iface, IMFCollection **collection)
 794 {
 795     struct topology *topology = impl_from_IMFTopology(iface);
 796
 797     TRACE("%p, %p.\n", iface, collection);
 798
 799     return topology_get_node_collection(topology, MF_TOPOLOGY_OUTPUT_NODE, collection);
 800 }
 801
 802 static const IMFTopologyVtbl topologyvtbl =
 803 {
 804     topology_QueryInterface,
 805     topology_AddRef,
 806     topology_Release,
 807     topology_GetItem,
 808     topology_GetItemType,
 809     topology_CompareItem,
 810     topology_Compare,
 811     topology_GetUINT32,
 812     topology_GetUINT64,
 813     topology_GetDouble,
 814     topology_GetGUID,
 815     topology_GetStringLength,
 816     topology_GetString,
 817     topology_GetAllocatedString,
 818     topology_GetBlobSize,
 819     topology_GetBlob,
 820     topology_GetAllocatedBlob,
 821     topology_GetUnknown,
 822     topology_SetItem,
 823     topology_DeleteItem,
 824     topology_DeleteAllItems,
 825     topology_SetUINT32,
 826     topology_SetUINT64,
 827     topology_SetDouble,
 828     topology_SetGUID,
 829     topology_SetString,
 830     topology_SetBlob,
 831     topology_SetUnknown,
 832     topology_LockStore,
 833     topology_UnlockStore,
 834     topology_GetCount,
 835     topology_GetItemByIndex,
 836     topology_CopyAllItems,
 837     topology_GetTopologyID,
 838     topology_AddNode,
 839     topology_RemoveNode,
 840     topology_GetNodeCount,
 841     topology_GetNode,
 842     topology_Clear,
 843     topology_CloneFrom,
 844     topology_GetNodeByID,
 845     topology_GetSourceNodeCollection,
 846     topology_GetOutputNodeCollection,
 847 };
 848
 849 static struct topology *unsafe_impl_from_IMFTopology(IMFTopology *iface)
 850 {
 851     if (!iface || iface->lpVtbl != &topologyvtbl)
 852         return NULL;
 853     return impl_from_IMFTopology(iface);
 854 }
 855
 856 static TOPOID topology_generate_id(void)
 857 {
 858     TOPOID old;
 859
 860     do
 861     {
 862         old = next_topology_id;
 863     }
 864     while (InterlockedCompareExchange64((LONG64 *)&next_topology_id, old + 1, old) != old);
 865
 866     return next_topology_id;
 867 }
 868
 869 HRESULT create_topology(TOPOID id, IMFTopology **topology)
 870 {
 871     struct topology *object;
 872     HRESULT hr;
 873
 874     if (!(object = calloc(1, sizeof(*object))))
 875         return E_OUTOFMEMORY;
 876
 877     object->IMFTopology_iface.lpVtbl = &topologyvtbl;
 878     object->refcount = 1;
 879
 880     hr = MFCreateAttributes(&object->attributes, 0);
 881     if (FAILED(hr))
 882     {
 883         IMFTopology_Release(&object->IMFTopology_iface);
 884         return hr;
 885     }
 886
 887     object->id = id;
 888
 889     *topology = &object->IMFTopology_iface;
 890
 891     return S_OK;
 892 }
 893
 894 /***********************************************************************
 895  *      MFCreateTopology (mf.@)
 896  */
 897 HRESULT WINAPI MFCreateTopology(IMFTopology **topology)
 898 {
 899     TRACE("%p.\n", topology);
 900
 901     if (!topology)
 902         return E_POINTER;
 903
 904     return create_topology(topology_generate_id(), topology);
 905 }
 906
 907 static HRESULT WINAPI topology_node_QueryInterface(IMFTopologyNode *iface, REFIID riid, void **out)
 908 {
 909     struct topology_node *node = impl_from_IMFTopologyNode(iface);
 910
 911     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), out);
 912
 913     if (IsEqualIID(riid, &IID_IMFTopologyNode) ||
 914             IsEqualIID(riid, &IID_IMFAttributes) ||
 915             IsEqualIID(riid, &IID_IUnknown))
 916     {
 917         *out = &node->IMFTopologyNode_iface;
 918         IMFTopologyNode_AddRef(iface);
 919         return S_OK;
 920     }
 921
 922     WARN("Unsupported interface %s.\n", debugstr_guid(riid));
 923     *out = NULL;
 924
 925     return E_NOINTERFACE;
 926 }
 927
 928 static ULONG WINAPI topology_node_AddRef(IMFTopologyNode *iface)
 929 {
 930     struct topology_node *node = impl_from_IMFTopologyNode(iface);
 931     ULONG refcount = InterlockedIncrement(&node->refcount);
 932
 933     TRACE("%p, refcount %lu.\n", iface, refcount);
 934
 935     return refcount;
 936 }
 937
 938 static ULONG WINAPI topology_node_Release(IMFTopologyNode *iface)
 939 {
 940     struct topology_node *node = impl_from_IMFTopologyNode(iface);
 941     ULONG refcount = InterlockedDecrement(&node->refcount);
 942     unsigned int i;
 943
 944     TRACE("%p, refcount %lu.\n", iface, refcount);
 945
 946     if (!refcount)
 947     {
 948         if (node->object)
 949             IUnknown_Release(node->object);
 950         if (node->input_type)
 951             IMFMediaType_Release(node->input_type);
 952         for (i = 0; i < node->inputs.count; ++i)
 953         {
 954             if (node->inputs.streams[i].preferred_type)
 955                 IMFMediaType_Release(node->inputs.streams[i].preferred_type);
 956         }
 957         for (i = 0; i < node->outputs.count; ++i)
 958         {
 959             if (node->outputs.streams[i].preferred_type)
 960                 IMFMediaType_Release(node->outputs.streams[i].preferred_type);
 961         }
 962         free(node->inputs.streams);
 963         free(node->outputs.streams);
 964         IMFAttributes_Release(node->attributes);
 965         DeleteCriticalSection(&node->cs);
 966         free(node);
 967     }
 968
 969     return refcount;
 970 }
 971
 972 static HRESULT WINAPI topology_node_GetItem(IMFTopologyNode *iface, REFGUID key, PROPVARIANT *value)
 973 {
 974     struct topology_node *node = impl_from_IMFTopologyNode(iface);
 975
 976     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
 977
 978     return IMFAttributes_GetItem(node->attributes, key, value);
 979 }
 980
 981 static HRESULT WINAPI topology_node_GetItemType(IMFTopologyNode *iface, REFGUID key, MF_ATTRIBUTE_TYPE *type)
 982 {
 983     struct topology_node *node = impl_from_IMFTopologyNode(iface);
 984
 985     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), type);
 986
 987     return IMFAttributes_GetItemType(node->attributes, key, type);
 988 }
 989
 990 static HRESULT WINAPI topology_node_CompareItem(IMFTopologyNode *iface, REFGUID key, REFPROPVARIANT value, BOOL *result)
 991 {
 992     struct topology_node *node = impl_from_IMFTopologyNode(iface);
 993
 994     TRACE("%p, %s, %p, %p.\n", iface, debugstr_guid(key), value, result);
 995
 996     return IMFAttributes_CompareItem(node->attributes, key, value, result);
 997 }
 998
 999 static HRESULT WINAPI topology_node_Compare(IMFTopologyNode *iface, IMFAttributes *theirs,
1000         MF_ATTRIBUTES_MATCH_TYPE type, BOOL *result)
1001 {
1002     struct topology_node *node = impl_from_IMFTopologyNode(iface);
1003
1004     TRACE("%p, %p, %d, %p.\n", iface, theirs, type, result);
1005
1006     return IMFAttributes_Compare(node->attributes, theirs, type, result);
1007 }
1008
1009 static HRESULT WINAPI topology_node_GetUINT32(IMFTopologyNode *iface, REFGUID key, UINT32 *value)
1010 {
1011     struct topology_node *node = impl_from_IMFTopologyNode(iface);
1012
1013     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
1014
1015     return IMFAttributes_GetUINT32(node->attributes, key, value);
1016 }
1017
1018 static HRESULT WINAPI topology_node_GetUINT64(IMFTopologyNode *iface, REFGUID key, UINT64 *value)
1019 {
1020     struct topology_node *node = impl_from_IMFTopologyNode(iface);
1021
1022     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
1023
1024     return IMFAttributes_GetUINT64(node->attributes, key, value);
1025 }
1026
1027 static HRESULT WINAPI topology_node_GetDouble(IMFTopologyNode *iface, REFGUID key, double *value)
1028 {
1029     struct topology_node *node = impl_from_IMFTopologyNode(iface);
1030
1031     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
1032
1033     return IMFAttributes_GetDouble(node->attributes, key, value);
1034 }
1035
1036 static HRESULT WINAPI topology_node_GetGUID(IMFTopologyNode *iface, REFGUID key, GUID *value)
1037 {
1038     struct topology_node *node = impl_from_IMFTopologyNode(iface);
1039
1040     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
1041
1042     return IMFAttributes_GetGUID(node->attributes, key, value);
1043 }
1044
1045 static HRESULT WINAPI topology_node_GetStringLength(IMFTopologyNode *iface, REFGUID key, UINT32 *length)
1046 {
1047     struct topology_node *node = impl_from_IMFTopologyNode(iface);
1048
1049     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), length);
1050
1051     return IMFAttributes_GetStringLength(node->attributes, key, length);
1052 }
1053
1054 static HRESULT WINAPI topology_node_GetString(IMFTopologyNode *iface, REFGUID key, WCHAR *value,
1055         UINT32 size, UINT32 *length)
1056 {
1057     struct topology_node *node = impl_from_IMFTopologyNode(iface);
1058
1059     TRACE("%p, %s, %p, %d, %p.\n", iface, debugstr_guid(key), value, size, length);
1060
1061     return IMFAttributes_GetString(node->attributes, key, value, size, length);
1062 }
1063
1064 static HRESULT WINAPI topology_node_GetAllocatedString(IMFTopologyNode *iface, REFGUID key,
1065         WCHAR **value, UINT32 *length)
1066 {
1067     struct topology_node *node = impl_from_IMFTopologyNode(iface);
1068
1069     TRACE("%p, %s, %p, %p.\n", iface, debugstr_guid(key), value, length);
1070
1071     return IMFAttributes_GetAllocatedString(node->attributes, key, value, length);
1072 }
1073
1074 static HRESULT WINAPI topology_node_GetBlobSize(IMFTopologyNode *iface, REFGUID key, UINT32 *size)
1075 {
1076     struct topology_node *node = impl_from_IMFTopologyNode(iface);
1077
1078     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), size);
1079
1080     return IMFAttributes_GetBlobSize(node->attributes, key, size);
1081 }
1082
1083 static HRESULT WINAPI topology_node_GetBlob(IMFTopologyNode *iface, REFGUID key, UINT8 *buf,
1084         UINT32 bufsize, UINT32 *blobsize)
1085 {
1086     struct topology_node *node = impl_from_IMFTopologyNode(iface);
1087
1088     TRACE("%p, %s, %p, %d, %p.\n", iface, debugstr_guid(key), buf, bufsize, blobsize);
1089
1090     return IMFAttributes_GetBlob(node->attributes, key, buf, bufsize, blobsize);
1091 }
1092
1093 static HRESULT WINAPI topology_node_GetAllocatedBlob(IMFTopologyNode *iface, REFGUID key, UINT8 **buf, UINT32 *size)
1094 {
1095     struct topology_node *node = impl_from_IMFTopologyNode(iface);
1096
1097     TRACE("%p, %s, %p, %p.\n", iface, debugstr_guid(key), buf, size);
1098
1099     return IMFAttributes_GetAllocatedBlob(node->attributes, key, buf, size);
1100 }
1101
1102 static HRESULT WINAPI topology_node_GetUnknown(IMFTopologyNode *iface, REFGUID key, REFIID riid, void **ppv)
1103 {
1104     struct topology_node *node = impl_from_IMFTopologyNode(iface);
1105
1106     TRACE("%p, %s, %s, %p.\n", iface, debugstr_guid(key), debugstr_guid(riid), ppv);
1107
1108     return IMFAttributes_GetUnknown(node->attributes, key, riid, ppv);
1109 }
1110
1111 static HRESULT WINAPI topology_node_SetItem(IMFTopologyNode *iface, REFGUID key, REFPROPVARIANT value)
1112 {
1113     struct topology_node *node = impl_from_IMFTopologyNode(iface);
1114
1115     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), value);
1116
1117     return IMFAttributes_SetItem(node->attributes, key, value);
1118 }
1119
1120 static HRESULT WINAPI topology_node_DeleteItem(IMFTopologyNode *iface, REFGUID key)
1121 {
1122     struct topology_node *node = impl_from_IMFTopologyNode(iface);
1123
1124     TRACE("%p, %s.\n", iface, debugstr_guid(key));
1125
1126     return IMFAttributes_DeleteItem(node->attributes, key);
1127 }
1128
1129 static HRESULT WINAPI topology_node_DeleteAllItems(IMFTopologyNode *iface)
1130 {
1131     struct topology_node *node = impl_from_IMFTopologyNode(iface);
1132
1133     TRACE("%p.\n", iface);
1134
1135     return IMFAttributes_DeleteAllItems(node->attributes);
1136 }
1137
1138 static HRESULT WINAPI topology_node_SetUINT32(IMFTopologyNode *iface, REFGUID key, UINT32 value)
1139 {
1140     struct topology_node *node = impl_from_IMFTopologyNode(iface);
1141
1142     TRACE("%p, %s, %d.\n", iface, debugstr_guid(key), value);
1143
1144     return IMFAttributes_SetUINT32(node->attributes, key, value);
1145 }
1146
1147 static HRESULT WINAPI topology_node_SetUINT64(IMFTopologyNode *iface, REFGUID key, UINT64 value)
1148 {
1149     struct topology_node *node = impl_from_IMFTopologyNode(iface);
1150
1151     TRACE("%p, %s, %s.\n", iface, debugstr_guid(key), wine_dbgstr_longlong(value));
1152
1153     return IMFAttributes_SetUINT64(node->attributes, key, value);
1154 }
1155
1156 static HRESULT WINAPI topology_node_SetDouble(IMFTopologyNode *iface, REFGUID key, double value)
1157 {
1158     struct topology_node *node = impl_from_IMFTopologyNode(iface);
1159
1160     TRACE("%p, %s, %f.\n", iface, debugstr_guid(key), value);
1161
1162     return IMFAttributes_SetDouble(node->attributes, key, value);
1163 }
1164
1165 static HRESULT WINAPI topology_node_SetGUID(IMFTopologyNode *iface, REFGUID key, REFGUID value)
1166 {
1167     struct topology_node *node = impl_from_IMFTopologyNode(iface);
1168
1169     TRACE("%p, %s, %s.\n", iface, debugstr_guid(key), debugstr_guid(value));
1170
1171     return IMFAttributes_SetGUID(node->attributes, key, value);
1172 }
1173
1174 static HRESULT WINAPI topology_node_SetString(IMFTopologyNode *iface, REFGUID key, const WCHAR *value)
1175 {
1176     struct topology_node *node = impl_from_IMFTopologyNode(iface);
1177
1178     TRACE("%p, %s, %s.\n", iface, debugstr_guid(key), debugstr_w(value));
1179
1180     return IMFAttributes_SetString(node->attributes, key, value);
1181 }
1182
1183 static HRESULT WINAPI topology_node_SetBlob(IMFTopologyNode *iface, REFGUID key, const UINT8 *buf, UINT32 size)
1184 {
1185     struct topology_node *node = impl_from_IMFTopologyNode(iface);
1186
1187     TRACE("%p, %s, %p, %d.\n", iface, debugstr_guid(key), buf, size);
1188
1189     return IMFAttributes_SetBlob(node->attributes, key, buf, size);
1190 }
1191
1192 static HRESULT WINAPI topology_node_SetUnknown(IMFTopologyNode *iface, REFGUID key, IUnknown *unknown)
1193 {
1194     struct topology_node *node = impl_from_IMFTopologyNode(iface);
1195
1196     TRACE("%p, %s, %p.\n", iface, debugstr_guid(key), unknown);
1197
1198     return IMFAttributes_SetUnknown(node->attributes, key, unknown);
1199 }
1200
1201 static HRESULT WINAPI topology_node_LockStore(IMFTopologyNode *iface)
1202 {
1203     struct topology_node *node = impl_from_IMFTopologyNode(iface);
1204
1205     TRACE("%p.\n", iface);
1206
1207     return IMFAttributes_LockStore(node->attributes);
1208 }
1209
1210 static HRESULT WINAPI topology_node_UnlockStore(IMFTopologyNode *iface)
1211 {
1212     struct topology_node *node = impl_from_IMFTopologyNode(iface);
1213
1214     TRACE("%p.\n", iface);
1215
1216     return IMFAttributes_UnlockStore(node->attributes);
1217 }
1218
1219 static HRESULT WINAPI topology_node_GetCount(IMFTopologyNode *iface, UINT32 *count)
1220 {
1221     struct topology_node *node = impl_from_IMFTopologyNode(iface);
1222
1223     TRACE("%p, %p.\n", iface, count);
1224
1225     return IMFAttributes_GetCount(node->attributes, count);
1226 }
1227
1228 static HRESULT WINAPI topology_node_GetItemByIndex(IMFTopologyNode *iface, UINT32 index, GUID *key, PROPVARIANT *value)
1229 {
1230     struct topology_node *node = impl_from_IMFTopologyNode(iface);
1231
1232     TRACE("%p, %u, %p, %p.\n", iface, index, key, value);
1233
1234     return IMFAttributes_GetItemByIndex(node->attributes, index, key, value);
1235 }
1236
1237 static HRESULT WINAPI topology_node_CopyAllItems(IMFTopologyNode *iface, IMFAttributes *dest)
1238 {
1239     struct topology_node *node = impl_from_IMFTopologyNode(iface);
1240
1241     TRACE("%p, %p.\n", iface, dest);
1242
1243     return IMFAttributes_CopyAllItems(node->attributes, dest);
1244 }
1245
1246 static HRESULT topology_node_set_object(struct topology_node *node, IUnknown *object)
1247 {
1248     static const GUID *iids[3] = { &IID_IPersist, &IID_IPersistStorage, &IID_IPersistPropertyBag };
1249     IPersist *persist = NULL;
1250     BOOL has_object_id;
1251     GUID object_id;
1252     unsigned int i;
1253     HRESULT hr;
1254
1255     has_object_id = IMFAttributes_GetGUID(node->attributes, &MF_TOPONODE_TRANSFORM_OBJECTID, &object_id) == S_OK;
1256
1257     if (object && !has_object_id)
1258     {
1259         for (i = 0; i < ARRAY_SIZE(iids); ++i)
1260         {
1261             persist = NULL;
1262             if (SUCCEEDED(hr = IUnknown_QueryInterface(object, iids[i], (void **)&persist)))
1263                 break;
1264         }
1265
1266         if (persist)
1267         {
1268             if (FAILED(hr = IPersist_GetClassID(persist, &object_id)))
1269             {
1270                 IPersist_Release(persist);
1271                 persist = NULL;
1272             }
1273         }
1274     }
1275
1276     EnterCriticalSection(&node->cs);
1277
1278     if (node->object)
1279         IUnknown_Release(node->object);
1280     node->object = object;
1281     if (node->object)
1282         IUnknown_AddRef(node->object);
1283
1284     if (persist)
1285         IMFAttributes_SetGUID(node->attributes, &MF_TOPONODE_TRANSFORM_OBJECTID, &object_id);
1286
1287     LeaveCriticalSection(&node->cs);
1288
1289     if (persist)
1290         IPersist_Release(persist);
1291
1292     return S_OK;
1293 }
1294
1295 static HRESULT WINAPI topology_node_SetObject(IMFTopologyNode *iface, IUnknown *object)
1296 {
1297     struct topology_node *node = impl_from_IMFTopologyNode(iface);
1298
1299     TRACE("%p, %p.\n", iface, object);
1300
1301     return topology_node_set_object(node, object);
1302 }
1303
1304 static HRESULT WINAPI topology_node_GetObject(IMFTopologyNode *iface, IUnknown **object)
1305 {
1306     struct topology_node *node = impl_from_IMFTopologyNode(iface);
1307
1308     TRACE("%p, %p.\n", iface, object);
1309
1310     if (!object)
1311         return E_POINTER;
1312
1313     EnterCriticalSection(&node->cs);
1314
1315     *object = node->object;
1316     if (*object)
1317         IUnknown_AddRef(*object);
1318
1319     LeaveCriticalSection(&node->cs);
1320
1321     return *object ? S_OK : E_FAIL;
1322 }
1323
1324 static HRESULT WINAPI topology_node_GetNodeType(IMFTopologyNode *iface, MF_TOPOLOGY_TYPE *node_type)
1325 {
1326     struct topology_node *node = impl_from_IMFTopologyNode(iface);
1327
1328     TRACE("%p, %p.\n", iface, node_type);
1329
1330     *node_type = node->node_type;
1331
1332     return S_OK;
1333 }
1334
1335 static HRESULT WINAPI topology_node_GetTopoNodeID(IMFTopologyNode *iface, TOPOID *id)
1336 {
1337     struct topology_node *node = impl_from_IMFTopologyNode(iface);
1338
1339     TRACE("%p, %p.\n", iface, id);
1340
1341     *id = node->id;
1342
1343     return S_OK;
1344 }
1345
1346 static HRESULT WINAPI topology_node_SetTopoNodeID(IMFTopologyNode *iface, TOPOID id)
1347 {
1348     struct topology_node *node = impl_from_IMFTopologyNode(iface);
1349
1350     TRACE("%p, %s.\n", iface, wine_dbgstr_longlong(id));
1351
1352     node->id = id;
1353
1354     return S_OK;
1355 }
1356
1357 static HRESULT WINAPI topology_node_GetInputCount(IMFTopologyNode *iface, DWORD *count)
1358 {
1359     struct topology_node *node = impl_from_IMFTopologyNode(iface);
1360
1361     TRACE("%p, %p.\n", iface, count);
1362
1363     *count = node->inputs.count;
1364
1365     return S_OK;
1366 }
1367
1368 static HRESULT WINAPI topology_node_GetOutputCount(IMFTopologyNode *iface, DWORD *count)
1369 {
1370     struct topology_node *node = impl_from_IMFTopologyNode(iface);
1371
1372     TRACE("%p, %p.\n", iface, count);
1373
1374     *count = node->outputs.count;
1375
1376     return S_OK;
1377 }
1378
1379 static void topology_node_set_stream_type(struct node_stream *stream, IMFMediaType *mediatype)
1380 {
1381     if (stream->preferred_type)
1382         IMFMediaType_Release(stream->preferred_type);
1383     stream->preferred_type = mediatype;
1384     if (stream->preferred_type)
1385         IMFMediaType_AddRef(stream->preferred_type);
1386 }
1387
1388 static HRESULT topology_node_connect_output(struct topology_node *node, DWORD output_index,
1389         struct topology_node *connection, DWORD input_index)
1390 {
1391     struct node_stream *stream;
1392     HRESULT hr;
1393
1394     if (node->node_type == MF_TOPOLOGY_OUTPUT_NODE || connection->node_type == MF_TOPOLOGY_SOURCESTREAM_NODE)
1395          return E_FAIL;
1396
1397     EnterCriticalSection(&node->cs);
1398     EnterCriticalSection(&connection->cs);
1399
1400     topology_node_disconnect_output(node, output_index);
1401     if (input_index < connection->inputs.count)
1402     {
1403         stream = &connection->inputs.streams[input_index];
1404         if (stream->connection)
1405             topology_node_disconnect_output(stream->connection, stream->connection_stream);
1406     }
1407
1408     hr = topology_node_reserve_streams(&node->outputs, output_index);
1409     if (SUCCEEDED(hr))
1410     {
1411         size_t old_count = connection->inputs.count;
1412         hr = topology_node_reserve_streams(&connection->inputs, input_index);
1413         if (SUCCEEDED(hr) && !old_count && connection->input_type)
1414         {
1415             topology_node_set_stream_type(connection->inputs.streams, connection->input_type);
1416             IMFMediaType_Release(connection->input_type);
1417             connection->input_type = NULL;
1418         }
1419     }
1420
1421     if (SUCCEEDED(hr))
1422     {
1423         node->outputs.streams[output_index].connection = connection;
1424         IMFTopologyNode_AddRef(&node->outputs.streams[output_index].connection->IMFTopologyNode_iface);
1425         node->outputs.streams[output_index].connection_stream = input_index;
1426         connection->inputs.streams[input_index].connection = node;
1427         IMFTopologyNode_AddRef(&connection->inputs.streams[input_index].connection->IMFTopologyNode_iface);
1428         connection->inputs.streams[input_index].connection_stream = output_index;
1429     }
1430
1431     LeaveCriticalSection(&connection->cs);
1432     LeaveCriticalSection(&node->cs);
1433
1434     return hr;
1435 }
1436
1437 static HRESULT WINAPI topology_node_ConnectOutput(IMFTopologyNode *iface, DWORD output_index,
1438         IMFTopologyNode *peer, DWORD input_index)
1439 {
1440     struct topology_node *node = impl_from_IMFTopologyNode(iface);
1441     struct topology_node *connection = unsafe_impl_from_IMFTopologyNode(peer);
1442
1443     TRACE("%p, %lu, %p, %lu.\n", iface, output_index, peer, input_index);
1444
1445     if (!connection)
1446     {
1447         WARN("External node implementations are not supported.\n");
1448         return E_UNEXPECTED;
1449     }
1450
1451     return topology_node_connect_output(node, output_index, connection, input_index);
1452 }
1453
1454 static HRESULT WINAPI topology_node_DisconnectOutput(IMFTopologyNode *iface, DWORD output_index)
1455 {
1456     struct topology_node *node = impl_from_IMFTopologyNode(iface);
1457
1458     TRACE("%p, %lu.\n", iface, output_index);
1459
1460     return topology_node_disconnect_output(node, output_index);
1461 }
1462
1463 static HRESULT WINAPI topology_node_GetInput(IMFTopologyNode *iface, DWORD input_index, IMFTopologyNode **ret,
1464         DWORD *output_index)
1465 {
1466     struct topology_node *node = impl_from_IMFTopologyNode(iface);
1467     HRESULT hr = S_OK;
1468
1469     TRACE("%p, %lu, %p, %p.\n", iface, input_index, ret, output_index);
1470
1471     EnterCriticalSection(&node->cs);
1472
1473     if (input_index < node->inputs.count)
1474     {
1475         const struct node_stream *stream = &node->inputs.streams[input_index];
1476
1477         if (stream->connection)
1478         {
1479             *ret = &stream->connection->IMFTopologyNode_iface;
1480             IMFTopologyNode_AddRef(*ret);
1481             *output_index = stream->connection_stream;
1482         }
1483         else
1484             hr = MF_E_NOT_FOUND;
1485     }
1486     else
1487         hr = E_INVALIDARG;
1488
1489     LeaveCriticalSection(&node->cs);
1490
1491     return hr;
1492 }
1493
1494 static HRESULT WINAPI topology_node_GetOutput(IMFTopologyNode *iface, DWORD output_index, IMFTopologyNode **ret,
1495         DWORD *input_index)
1496 {
1497     struct topology_node *node = impl_from_IMFTopologyNode(iface);
1498     HRESULT hr = S_OK;
1499
1500     TRACE("%p, %lu, %p, %p.\n", iface, output_index, ret, input_index);
1501
1502     EnterCriticalSection(&node->cs);
1503
1504     if (output_index < node->outputs.count)
1505     {
1506         const struct node_stream *stream = &node->outputs.streams[output_index];
1507
1508         if (stream->connection)
1509         {
1510             *ret = &stream->connection->IMFTopologyNode_iface;
1511             IMFTopologyNode_AddRef(*ret);
1512             *input_index = stream->connection_stream;
1513         }
1514         else
1515             hr = MF_E_NOT_FOUND;
1516     }
1517     else
1518         hr = E_INVALIDARG;
1519
1520     LeaveCriticalSection(&node->cs);
1521
1522     return hr;
1523 }
1524
1525 static HRESULT WINAPI topology_node_SetOutputPrefType(IMFTopologyNode *iface, DWORD index, IMFMediaType *mediatype)
1526 {
1527     struct topology_node *node = impl_from_IMFTopologyNode(iface);
1528     HRESULT hr = S_OK;
1529
1530     TRACE("%p, %lu, %p.\n", iface, index, mediatype);
1531
1532     EnterCriticalSection(&node->cs);
1533
1534     if (node->node_type != MF_TOPOLOGY_OUTPUT_NODE)
1535     {
1536         if (SUCCEEDED(hr = topology_node_reserve_streams(&node->outputs, index)))
1537             topology_node_set_stream_type(&node->outputs.streams[index], mediatype);
1538     }
1539     else
1540         hr = E_NOTIMPL;
1541
1542     LeaveCriticalSection(&node->cs);
1543
1544     return hr;
1545 }
1546
1547 static HRESULT topology_node_get_pref_type(struct node_streams *streams, unsigned int index, IMFMediaType **mediatype)
1548 {
1549     *mediatype = streams->streams[index].preferred_type;
1550     if (*mediatype)
1551     {
1552         IMFMediaType_AddRef(*mediatype);
1553         return S_OK;
1554     }
1555
1556     return E_FAIL;
1557 }
1558
1559 static HRESULT WINAPI topology_node_GetOutputPrefType(IMFTopologyNode *iface, DWORD index, IMFMediaType **mediatype)
1560 {
1561     struct topology_node *node = impl_from_IMFTopologyNode(iface);
1562     HRESULT hr = S_OK;
1563
1564     TRACE("%p, %lu, %p.\n", iface, index, mediatype);
1565
1566     EnterCriticalSection(&node->cs);
1567
1568     if (index < node->outputs.count)
1569         hr = topology_node_get_pref_type(&node->outputs, index, mediatype);
1570     else
1571         hr = E_INVALIDARG;
1572
1573     LeaveCriticalSection(&node->cs);
1574
1575     return hr;
1576 }
1577
1578 static HRESULT WINAPI topology_node_SetInputPrefType(IMFTopologyNode *iface, DWORD index, IMFMediaType *mediatype)
1579 {
1580     struct topology_node *node = impl_from_IMFTopologyNode(iface);
1581     HRESULT hr = S_OK;
1582
1583     TRACE("%p, %lu, %p.\n", iface, index, mediatype);
1584
1585     EnterCriticalSection(&node->cs);
1586
1587     switch (node->node_type)
1588     {
1589         case MF_TOPOLOGY_TEE_NODE:
1590             if (index)
1591             {
1592                 hr = MF_E_INVALIDTYPE;
1593                 break;
1594             }
1595             if (node->inputs.count)
1596                 topology_node_set_stream_type(&node->inputs.streams[index], mediatype);
1597             else
1598             {
1599                 if (node->input_type)
1600                     IMFMediaType_Release(node->input_type);
1601                 node->input_type = mediatype;
1602                 if (node->input_type)
1603                     IMFMediaType_AddRef(node->input_type);
1604             }
1605             break;
1606         case MF_TOPOLOGY_SOURCESTREAM_NODE:
1607             hr = E_NOTIMPL;
1608             break;
1609         default:
1610             if (SUCCEEDED(hr = topology_node_reserve_streams(&node->inputs, index)))
1611                 topology_node_set_stream_type(&node->inputs.streams[index], mediatype);
1612     }
1613
1614     LeaveCriticalSection(&node->cs);
1615
1616     return hr;
1617 }
1618
1619 static HRESULT WINAPI topology_node_GetInputPrefType(IMFTopologyNode *iface, DWORD index, IMFMediaType **mediatype)
1620 {
1621     struct topology_node *node = impl_from_IMFTopologyNode(iface);
1622     HRESULT hr = S_OK;
1623
1624     TRACE("%p, %lu, %p.\n", iface, index, mediatype);
1625
1626     EnterCriticalSection(&node->cs);
1627
1628     if (index < node->inputs.count)
1629     {
1630         hr = topology_node_get_pref_type(&node->inputs, index, mediatype);
1631     }
1632     else if (node->node_type == MF_TOPOLOGY_TEE_NODE && node->input_type)
1633     {
1634         *mediatype = node->input_type;
1635         IMFMediaType_AddRef(*mediatype);
1636     }
1637     else
1638         hr = E_INVALIDARG;
1639
1640     LeaveCriticalSection(&node->cs);
1641
1642     return hr;
1643 }
1644
1645 static HRESULT WINAPI topology_node_CloneFrom(IMFTopologyNode *iface, IMFTopologyNode *src_node)
1646 {
1647     struct topology_node *node = impl_from_IMFTopologyNode(iface);
1648     MF_TOPOLOGY_TYPE node_type;
1649     IMFMediaType *mediatype;
1650     IUnknown *object;
1651     DWORD count, i;
1652     TOPOID topoid;
1653     HRESULT hr;
1654
1655     TRACE("%p, %p.\n", iface, src_node);
1656
1657     if (FAILED(hr = IMFTopologyNode_GetNodeType(src_node, &node_type)))
1658         return hr;
1659
1660     if (node->node_type != node_type)
1661         return MF_E_INVALIDREQUEST;
1662
1663     if (FAILED(hr = IMFTopologyNode_GetTopoNodeID(src_node, &topoid)))
1664         return hr;
1665
1666     object = NULL;
1667     IMFTopologyNode_GetObject(src_node, &object);
1668
1669     EnterCriticalSection(&node->cs);
1670
1671     hr = IMFTopologyNode_CopyAllItems(src_node, node->attributes);
1672
1673     if (SUCCEEDED(hr))
1674         hr = topology_node_set_object(node, object);
1675
1676     if (SUCCEEDED(hr))
1677         node->id = topoid;
1678
1679     if (SUCCEEDED(IMFTopologyNode_GetInputCount(src_node, &count)))
1680     {
1681         for (i = 0; i < count; ++i)
1682         {
1683             if (SUCCEEDED(IMFTopologyNode_GetInputPrefType(src_node, i, &mediatype)))
1684             {
1685                 IMFTopologyNode_SetInputPrefType(iface, i, mediatype);
1686                 IMFMediaType_Release(mediatype);
1687             }
1688         }
1689     }
1690
1691     if (SUCCEEDED(IMFTopologyNode_GetOutputCount(src_node, &count)))
1692     {
1693         for (i = 0; i < count; ++i)
1694         {
1695             if (SUCCEEDED(IMFTopologyNode_GetOutputPrefType(src_node, i, &mediatype)))
1696             {
1697                 IMFTopologyNode_SetOutputPrefType(iface, i, mediatype);
1698                 IMFMediaType_Release(mediatype);
1699             }
1700         }
1701     }
1702
1703     LeaveCriticalSection(&node->cs);
1704
1705     if (object)
1706         IUnknown_Release(object);
1707
1708     return hr;
1709 }
1710
1711 static const IMFTopologyNodeVtbl topologynodevtbl =
1712 {
1713     topology_node_QueryInterface,
1714     topology_node_AddRef,
1715     topology_node_Release,
1716     topology_node_GetItem,
1717     topology_node_GetItemType,
1718     topology_node_CompareItem,
1719     topology_node_Compare,
1720     topology_node_GetUINT32,
1721     topology_node_GetUINT64,
1722     topology_node_GetDouble,
1723     topology_node_GetGUID,
1724     topology_node_GetStringLength,
1725     topology_node_GetString,
1726     topology_node_GetAllocatedString,
1727     topology_node_GetBlobSize,
1728     topology_node_GetBlob,
1729     topology_node_GetAllocatedBlob,
1730     topology_node_GetUnknown,
1731     topology_node_SetItem,
1732     topology_node_DeleteItem,
1733     topology_node_DeleteAllItems,
1734     topology_node_SetUINT32,
1735     topology_node_SetUINT64,
1736     topology_node_SetDouble,
1737     topology_node_SetGUID,
1738     topology_node_SetString,
1739     topology_node_SetBlob,
1740     topology_node_SetUnknown,
1741     topology_node_LockStore,
1742     topology_node_UnlockStore,
1743     topology_node_GetCount,
1744     topology_node_GetItemByIndex,
1745     topology_node_CopyAllItems,
1746     topology_node_SetObject,
1747     topology_node_GetObject,
1748     topology_node_GetNodeType,
1749     topology_node_GetTopoNodeID,
1750     topology_node_SetTopoNodeID,
1751     topology_node_GetInputCount,
1752     topology_node_GetOutputCount,
1753     topology_node_ConnectOutput,
1754     topology_node_DisconnectOutput,
1755     topology_node_GetInput,
1756     topology_node_GetOutput,
1757     topology_node_SetOutputPrefType,
1758     topology_node_GetOutputPrefType,
1759     topology_node_SetInputPrefType,
1760     topology_node_GetInputPrefType,
1761     topology_node_CloneFrom,
1762 };
1763
1764 static HRESULT create_topology_node(MF_TOPOLOGY_TYPE node_type, struct topology_node **node)
1765 {
1766     HRESULT hr;
1767
1768     if (!(*node = calloc(1, sizeof(**node))))
1769         return E_OUTOFMEMORY;
1770
1771     (*node)->IMFTopologyNode_iface.lpVtbl = &topologynodevtbl;
1772     (*node)->refcount = 1;
1773     (*node)->node_type = node_type;
1774     hr = MFCreateAttributes(&(*node)->attributes, 0);
1775     if (FAILED(hr))
1776     {
1777         free(*node);
1778         return hr;
1779     }
1780     (*node)->id = ((TOPOID)GetCurrentProcessId() << 32) | InterlockedIncrement(&next_node_id);
1781     InitializeCriticalSection(&(*node)->cs);
1782
1783     return S_OK;
1784 }
1785
1786 HRESULT topology_node_get_object(IMFTopologyNode *node, REFIID riid, void **obj)
1787 {
1788     IUnknown *unk;
1789     HRESULT hr;
1790
1791     *obj = NULL;
1792
1793     if (SUCCEEDED(hr = IMFTopologyNode_GetObject(node, &unk)))
1794     {
1795         hr = IUnknown_QueryInterface(unk, riid, obj);
1796         IUnknown_Release(unk);
1797     }
1798
1799     return hr;
1800 }
1801
1802 /***********************************************************************
1803  *      MFCreateTopologyNode (mf.@)
1804  */
1805 HRESULT WINAPI MFCreateTopologyNode(MF_TOPOLOGY_TYPE node_type, IMFTopologyNode **node)
1806 {
1807     struct topology_node *object;
1808     HRESULT hr;
1809
1810     TRACE("%d, %p.\n", node_type, node);
1811
1812     if (!node)
1813         return E_POINTER;
1814
1815     hr = create_topology_node(node_type, &object);
1816     if (SUCCEEDED(hr))
1817         *node = &object->IMFTopologyNode_iface;
1818
1819     return hr;
1820 }
1821
1822 /* private helper for node types without an actual IMFMediaTypeHandler */
1823 struct type_handler
1824 {
1825     IMFMediaTypeHandler IMFMediaTypeHandler_iface;
1826     LONG refcount;
1827
1828     IMFTopologyNode *node;
1829     DWORD stream;
1830     BOOL output;
1831
1832     IMFTransform *transform;
1833 };
1834
1835 static struct type_handler *impl_from_IMFMediaTypeHandler(IMFMediaTypeHandler *iface)
1836 {
1837     return CONTAINING_RECORD(iface, struct type_handler, IMFMediaTypeHandler_iface);
1838 }
1839
1840 static HRESULT WINAPI type_handler_QueryInterface(IMFMediaTypeHandler *iface, REFIID riid, void **obj)
1841 {
1842     if (IsEqualIID(riid, &IID_IMFMediaTypeHandler)
1843             || IsEqualIID(riid, &IID_IUnknown))
1844     {
1845         IMFMediaTypeHandler_AddRef((*obj = iface));
1846         return S_OK;
1847     }
1848
1849     *obj = NULL;
1850     return E_NOINTERFACE;
1851 }
1852
1853 static ULONG WINAPI type_handler_AddRef(IMFMediaTypeHandler *iface)
1854 {
1855     struct type_handler *handler = impl_from_IMFMediaTypeHandler(iface);
1856     ULONG refcount = InterlockedIncrement(&handler->refcount);
1857     return refcount;
1858 }
1859
1860 static ULONG WINAPI type_handler_Release(IMFMediaTypeHandler *iface)
1861 {
1862     struct type_handler *handler = impl_from_IMFMediaTypeHandler(iface);
1863     ULONG refcount = InterlockedDecrement(&handler->refcount);
1864
1865     if (!refcount)
1866     {
1867         if (handler->transform)
1868             IMFTransform_Release(handler->transform);
1869         IMFTopologyNode_Release(handler->node);
1870         free(handler);
1871     }
1872
1873     return refcount;
1874 }
1875
1876 static HRESULT WINAPI type_handler_IsMediaTypeSupported(IMFMediaTypeHandler *iface, IMFMediaType *in_type,
1877         IMFMediaType **out_type)
1878 {
1879     struct type_handler *handler = impl_from_IMFMediaTypeHandler(iface);
1880     IMFMediaType *type;
1881     DWORD flags;
1882     HRESULT hr;
1883
1884     if (out_type)
1885         *out_type = NULL;
1886
1887     if (handler->transform)
1888     {
1889         if (handler->output)
1890             return IMFTransform_SetOutputType(handler->transform, handler->stream, in_type, MFT_SET_TYPE_TEST_ONLY);
1891         else
1892             return IMFTransform_SetInputType(handler->transform, handler->stream, in_type, MFT_SET_TYPE_TEST_ONLY);
1893     }
1894
1895     if (FAILED(hr = IMFMediaTypeHandler_GetCurrentMediaType(iface, &type)))
1896         return hr;
1897
1898     hr = IMFMediaType_IsEqual(type, in_type, &flags);
1899     IMFMediaType_Release(type);
1900     return hr;
1901 }
1902
1903 static HRESULT WINAPI type_handler_GetMediaTypeCount(IMFMediaTypeHandler *iface, DWORD *count)
1904 {
1905     return E_NOTIMPL;
1906 }
1907
1908 static HRESULT WINAPI type_handler_GetMediaTypeByIndex(IMFMediaTypeHandler *iface, DWORD index,
1909         IMFMediaType **type)
1910 {
1911     struct type_handler *handler = impl_from_IMFMediaTypeHandler(iface);
1912
1913     if (handler->transform)
1914     {
1915         if (handler->output)
1916             return IMFTransform_GetOutputAvailableType(handler->transform, handler->stream, index, type);
1917         else
1918             return IMFTransform_GetInputAvailableType(handler->transform, handler->stream, index, type);
1919     }
1920
1921     if (index)
1922         return MF_E_NO_MORE_TYPES;
1923
1924     return IMFMediaTypeHandler_GetCurrentMediaType(iface, type);
1925 }
1926
1927 static HRESULT WINAPI type_handler_SetCurrentMediaType(IMFMediaTypeHandler *iface, IMFMediaType *type)
1928 {
1929     struct type_handler *handler = impl_from_IMFMediaTypeHandler(iface);
1930
1931     if (handler->transform)
1932     {
1933         if (handler->output)
1934             return IMFTransform_SetOutputType(handler->transform, handler->stream, type, 0);
1935         else
1936             return IMFTransform_SetInputType(handler->transform, handler->stream, type, 0);
1937     }
1938
1939     return IMFTopologyNode_SetInputPrefType(handler->node, handler->stream, type);
1940 }
1941
1942 static HRESULT WINAPI type_handler_GetCurrentMediaType(IMFMediaTypeHandler *iface, IMFMediaType **type)
1943 {
1944     struct type_handler *handler = impl_from_IMFMediaTypeHandler(iface);
1945     UINT32 output;
1946
1947     if (handler->transform)
1948     {
1949         if (handler->output)
1950             return IMFTransform_GetOutputCurrentType(handler->transform, handler->stream, type);
1951         else
1952             return IMFTransform_GetInputCurrentType(handler->transform, handler->stream, type);
1953     }
1954
1955     if (SUCCEEDED(IMFTopologyNode_GetInputPrefType(handler->node, 0, type)))
1956         return S_OK;
1957
1958     if (FAILED(IMFTopologyNode_GetUINT32(handler->node, &MF_TOPONODE_PRIMARYOUTPUT, &output)))
1959         output = 0;
1960
1961     return IMFTopologyNode_GetOutputPrefType(handler->node, output, type);
1962 }
1963
1964 static HRESULT WINAPI type_handler_GetMajorType(IMFMediaTypeHandler *iface, GUID *type)
1965 {
1966     IMFMediaType *media_type;
1967     HRESULT hr;
1968
1969     if (FAILED(hr = IMFMediaTypeHandler_GetCurrentMediaType(iface, &media_type)))
1970         return hr;
1971
1972     hr = IMFMediaType_GetMajorType(media_type, type);
1973     IMFMediaType_Release(media_type);
1974     return hr;
1975 }
1976
1977 static const IMFMediaTypeHandlerVtbl type_handler_vtbl =
1978 {
1979     type_handler_QueryInterface,
1980     type_handler_AddRef,
1981     type_handler_Release,
1982     type_handler_IsMediaTypeSupported,
1983     type_handler_GetMediaTypeCount,
1984     type_handler_GetMediaTypeByIndex,
1985     type_handler_SetCurrentMediaType,
1986     type_handler_GetCurrentMediaType,
1987     type_handler_GetMajorType,
1988 };
1989
1990 static HRESULT type_handler_create(IMFTopologyNode *node, DWORD stream, BOOL output, IMFTransform *transform, IMFMediaTypeHandler **out)
1991 {
1992     struct type_handler *handler;
1993
1994     if (!(handler = calloc(1, sizeof(*handler)))) return E_OUTOFMEMORY;
1995     handler->IMFMediaTypeHandler_iface.lpVtbl = &type_handler_vtbl;
1996     handler->refcount = 1;
1997     handler->stream = stream;
1998     handler->output = output;
1999     IMFTopologyNode_AddRef((handler->node = node));
2000     if (transform)
2001         IMFTransform_AddRef((handler->transform = transform));
2002
2003     *out = &handler->IMFMediaTypeHandler_iface;
2004     return S_OK;
2005 }
2006
2007 HRESULT topology_node_get_type_handler(IMFTopologyNode *node, DWORD stream,
2008         BOOL output, IMFMediaTypeHandler **handler)
2009 {
2010     MF_TOPOLOGY_TYPE node_type;
2011     IMFStreamSink *stream_sink;
2012     IMFStreamDescriptor *sd;
2013     IMFTransform *transform;
2014     HRESULT hr;
2015
2016     if (FAILED(hr = IMFTopologyNode_GetNodeType(node, &node_type)))
2017         return hr;
2018
2019     switch (node_type)
2020     {
2021         case MF_TOPOLOGY_OUTPUT_NODE:
2022             if (output || stream)
2023                 return MF_E_INVALIDSTREAMNUMBER;
2024
2025             if (SUCCEEDED(hr = topology_node_get_object(node, &IID_IMFStreamSink, (void **)&stream_sink)))
2026             {
2027                 hr = IMFStreamSink_GetMediaTypeHandler(stream_sink, handler);
2028                 IMFStreamSink_Release(stream_sink);
2029             }
2030             break;
2031         case MF_TOPOLOGY_SOURCESTREAM_NODE:
2032             if (!output || stream)
2033                 return MF_E_INVALIDSTREAMNUMBER;
2034
2035             if (SUCCEEDED(hr = IMFTopologyNode_GetUnknown(node, &MF_TOPONODE_STREAM_DESCRIPTOR,
2036                     &IID_IMFStreamDescriptor, (void **)&sd)))
2037             {
2038                 hr = IMFStreamDescriptor_GetMediaTypeHandler(sd, handler);
2039                 IMFStreamDescriptor_Release(sd);
2040             }
2041             break;
2042         case MF_TOPOLOGY_TRANSFORM_NODE:
2043             if (SUCCEEDED(hr = topology_node_get_object(node, &IID_IMFTransform, (void **)&transform)))
2044             {
2045                 hr = type_handler_create(node, stream, output, transform, handler);
2046                 IMFTransform_Release(transform);
2047             }
2048             break;
2049         case MF_TOPOLOGY_TEE_NODE:
2050             hr = type_handler_create(node, stream, output, NULL, handler);
2051             break;
2052         default:
2053             WARN("Unexpected node type %u.\n", node_type);
2054             return MF_E_UNEXPECTED;
2055     }
2056
2057     return hr;
2058 }
2059
2060 /***********************************************************************
2061  *      MFGetTopoNodeCurrentType (mf.@)
2062  */
2063 HRESULT WINAPI MFGetTopoNodeCurrentType(IMFTopologyNode *node, DWORD stream, BOOL output, IMFMediaType **type)
2064 {
2065     IMFMediaTypeHandler *handler;
2066     HRESULT hr;
2067
2068     TRACE("%p, %lu, %d, %p.\n", node, stream, output, type);
2069
2070     if (FAILED(hr = topology_node_get_type_handler(node, stream, output, &handler)))
2071         return hr;
2072
2073     hr = IMFMediaTypeHandler_GetCurrentMediaType(handler, type);
2074     IMFMediaTypeHandler_Release(handler);
2075     return hr;
2076 }
2077
2078 static HRESULT WINAPI seq_source_QueryInterface(IMFSequencerSource *iface, REFIID riid, void **out)
2079 {
2080     struct seq_source *seq_source = impl_from_IMFSequencerSource(iface);
2081
2082     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), out);
2083
2084     *out = NULL;
2085
2086     if (IsEqualIID(riid, &IID_IMFSequencerSource) ||
2087             IsEqualIID(riid, &IID_IUnknown))
2088     {
2089         *out = &seq_source->IMFSequencerSource_iface;
2090     }
2091     else if (IsEqualIID(riid, &IID_IMFMediaSourceTopologyProvider))
2092     {
2093         *out = &seq_source->IMFMediaSourceTopologyProvider_iface;
2094     }
2095     else
2096     {
2097         WARN("Unimplemented %s.\n", debugstr_guid(riid));
2098         return E_NOINTERFACE;
2099     }
2100
2101     if (*out)
2102         IUnknown_AddRef((IUnknown *)*out);
2103
2104     return S_OK;
2105 }
2106
2107 static ULONG WINAPI seq_source_AddRef(IMFSequencerSource *iface)
2108 {
2109     struct seq_source *seq_source = impl_from_IMFSequencerSource(iface);
2110     ULONG refcount = InterlockedIncrement(&seq_source->refcount);
2111
2112     TRACE("%p, refcount %lu.\n", iface, refcount);
2113
2114     return refcount;
2115 }
2116
2117 static ULONG WINAPI seq_source_Release(IMFSequencerSource *iface)
2118 {
2119     struct seq_source *seq_source = impl_from_IMFSequencerSource(iface);
2120     ULONG refcount = InterlockedDecrement(&seq_source->refcount);
2121
2122     TRACE("%p, refcount %lu.\n", iface, refcount);
2123
2124     if (!refcount)
2125         free(seq_source);
2126
2127     return refcount;
2128 }
2129
2130 static HRESULT WINAPI seq_source_AppendTopology(IMFSequencerSource *iface, IMFTopology *topology,
2131         DWORD flags, MFSequencerElementId *id)
2132 {
2133     FIXME("%p, %p, %lx, %p.\n", iface, topology, flags, id);
2134
2135     return E_NOTIMPL;
2136 }
2137
2138 static HRESULT WINAPI seq_source_DeleteTopology(IMFSequencerSource *iface, MFSequencerElementId id)
2139 {
2140     FIXME("%p, %#lx.\n", iface, id);
2141
2142     return E_NOTIMPL;
2143 }
2144
2145 static HRESULT WINAPI seq_source_GetPresentationContext(IMFSequencerSource *iface,
2146         IMFPresentationDescriptor *descriptor, MFSequencerElementId *id, IMFTopology **topology)
2147 {
2148     FIXME("%p, %p, %p, %p.\n", iface, descriptor, id, topology);
2149
2150     return E_NOTIMPL;
2151 }
2152
2153 static HRESULT WINAPI seq_source_UpdateTopology(IMFSequencerSource *iface, MFSequencerElementId id,
2154         IMFTopology *topology)
2155 {
2156     FIXME("%p, %#lx, %p.\n", iface, id, topology);
2157
2158     return E_NOTIMPL;
2159 }
2160
2161 static HRESULT WINAPI seq_source_UpdateTopologyFlags(IMFSequencerSource *iface, MFSequencerElementId id, DWORD flags)
2162 {
2163     FIXME("%p, %#lx, %#lx.\n", iface, id, flags);
2164
2165     return E_NOTIMPL;
2166 }
2167
2168 static HRESULT WINAPI seq_source_topology_provider_QueryInterface(IMFMediaSourceTopologyProvider *iface, REFIID riid,
2169         void **obj)
2170 {
2171     struct seq_source *seq_source = impl_from_IMFMediaSourceTopologyProvider(iface);
2172     return IMFSequencerSource_QueryInterface(&seq_source->IMFSequencerSource_iface, riid, obj);
2173 }
2174
2175 static ULONG WINAPI seq_source_topology_provider_AddRef(IMFMediaSourceTopologyProvider *iface)
2176 {
2177     struct seq_source *seq_source = impl_from_IMFMediaSourceTopologyProvider(iface);
2178     return IMFSequencerSource_AddRef(&seq_source->IMFSequencerSource_iface);
2179 }
2180
2181 static ULONG WINAPI seq_source_topology_provider_Release(IMFMediaSourceTopologyProvider *iface)
2182 {
2183     struct seq_source *seq_source = impl_from_IMFMediaSourceTopologyProvider(iface);
2184     return IMFSequencerSource_Release(&seq_source->IMFSequencerSource_iface);
2185 }
2186
2187 static HRESULT WINAPI seq_source_topology_provider_GetMediaSourceTopology(IMFMediaSourceTopologyProvider *iface,
2188         IMFPresentationDescriptor *pd, IMFTopology **topology)
2189 {
2190     FIXME("%p, %p, %p.\n", iface, pd, topology);
2191
2192     return E_NOTIMPL;
2193 }
2194
2195 static const IMFMediaSourceTopologyProviderVtbl seq_source_topology_provider_vtbl =
2196 {
2197     seq_source_topology_provider_QueryInterface,
2198     seq_source_topology_provider_AddRef,
2199     seq_source_topology_provider_Release,
2200     seq_source_topology_provider_GetMediaSourceTopology,
2201 };
2202
2203 static const IMFSequencerSourceVtbl seqsourcevtbl =
2204 {
2205     seq_source_QueryInterface,
2206     seq_source_AddRef,
2207     seq_source_Release,
2208     seq_source_AppendTopology,
2209     seq_source_DeleteTopology,
2210     seq_source_GetPresentationContext,
2211     seq_source_UpdateTopology,
2212     seq_source_UpdateTopologyFlags,
2213 };
2214
2215 /***********************************************************************
2216  *      MFCreateSequencerSource (mf.@)
2217  */
2218 HRESULT WINAPI MFCreateSequencerSource(IUnknown *reserved, IMFSequencerSource **seq_source)
2219 {
2220     struct seq_source *object;
2221
2222     TRACE("%p, %p.\n", reserved, seq_source);
2223
2224     if (!seq_source)
2225         return E_POINTER;
2226
2227     if (!(object = calloc(1, sizeof(*object))))
2228         return E_OUTOFMEMORY;
2229
2230     object->IMFSequencerSource_iface.lpVtbl = &seqsourcevtbl;
2231     object->IMFMediaSourceTopologyProvider_iface.lpVtbl = &seq_source_topology_provider_vtbl;
2232     object->refcount = 1;
2233
2234     *seq_source = &object->IMFSequencerSource_iface;
2235
2236     return S_OK;
2237 }
2238
2239 struct segment_offset
2240 {
2241     IUnknown IUnknown_iface;
2242     LONG refcount;
2243     MFSequencerElementId id;
2244     MFTIME timeoffset;
2245 };
2246
2247 static inline struct segment_offset *impl_offset_from_IUnknown(IUnknown *iface)
2248 {
2249     return CONTAINING_RECORD(iface, struct segment_offset, IUnknown_iface);
2250 }
2251
2252 static HRESULT WINAPI segment_offset_QueryInterface(IUnknown *iface, REFIID riid, void **obj)
2253 {
2254     if (IsEqualIID(riid, &IID_IUnknown))
2255     {
2256         *obj = iface;
2257         IUnknown_AddRef(iface);
2258         return S_OK;
2259     }
2260
2261     *obj = NULL;
2262     return E_NOINTERFACE;
2263 }
2264
2265 static ULONG WINAPI segment_offset_AddRef(IUnknown *iface)
2266 {
2267     struct segment_offset *offset = impl_offset_from_IUnknown(iface);
2268     return InterlockedIncrement(&offset->refcount);
2269 }
2270
2271 static ULONG WINAPI segment_offset_Release(IUnknown *iface)
2272 {
2273     struct segment_offset *offset = impl_offset_from_IUnknown(iface);
2274     ULONG refcount = InterlockedDecrement(&offset->refcount);
2275
2276     if (!refcount)
2277         free(offset);
2278
2279     return refcount;
2280 }
2281
2282 static const IUnknownVtbl segment_offset_vtbl =
2283 {
2284     segment_offset_QueryInterface,
2285     segment_offset_AddRef,
2286     segment_offset_Release,
2287 };
2288
2289 /***********************************************************************
2290  *      MFCreateSequencerSegmentOffset (mf.@)
2291  */
2292 HRESULT WINAPI MFCreateSequencerSegmentOffset(MFSequencerElementId id, MFTIME timeoffset, PROPVARIANT *ret)
2293 {
2294     struct segment_offset *offset;
2295
2296     TRACE("%#lx, %s, %p.\n", id, debugstr_time(timeoffset), ret);
2297
2298     if (!ret)
2299         return E_POINTER;
2300
2301     if (!(offset = calloc(1, sizeof(*offset))))
2302         return E_OUTOFMEMORY;
2303
2304     offset->IUnknown_iface.lpVtbl = &segment_offset_vtbl;
2305     offset->refcount = 1;
2306     offset->id = id;
2307     offset->timeoffset = timeoffset;
2308
2309     V_VT(ret) = VT_UNKNOWN;
2310     V_UNKNOWN(ret) = &offset->IUnknown_iface;
2311
2312     return S_OK;
2313 }