dlls/mfreadwrite/writer.c

   1 /*
   2  * Copyright 2020 Nikolay Sivov for CodeWeavers
   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 #include <assert.h>
  20
  21 #define COBJMACROS
  22 #include "mfapi.h"
  23 #include "mfidl.h"
  24 #include "mfreadwrite.h"
  25 #include "pathcch.h"
  26 #include "wine/mfinternal.h"
  27 #include "mf_private.h"
  28
  29 #include "wine/debug.h"
  30 #include "wine/list.h"
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(mfplat);
  33
  34 enum writer_state
  35 {
  36     SINK_WRITER_STATE_INITIAL = 0,
  37     SINK_WRITER_STATE_WRITING,
  38 };
  39
  40 struct marker_context
  41 {
  42     IUnknown IUnknown_iface;
  43     LONG refcount;
  44
  45     unsigned int marker_type;
  46     void *user_context;
  47 };
  48
  49 struct pending_item
  50 {
  51     struct list entry;
  52     unsigned int marker_type;
  53     IMFSample *sample;
  54     LONGLONG timestamp;
  55     void *user_context;
  56 };
  57
  58 struct stream
  59 {
  60     IMFStreamSink *stream_sink;
  61     IMFTransform *encoder;
  62     MF_SINK_WRITER_STATISTICS stats;
  63     struct list queue;
  64 };
  65
  66 struct sink_writer
  67 {
  68     IMFSinkWriter IMFSinkWriter_iface;
  69     IMFAsyncCallback events_callback;
  70     LONG refcount;
  71
  72     struct
  73     {
  74         struct stream *items;
  75         size_t count;
  76         size_t capacity;
  77         DWORD next_id;
  78     } streams;
  79
  80     IMFPresentationClock *clock;
  81     IMFMediaSink *sink;
  82     enum writer_state state;
  83     HRESULT status;
  84     MF_SINK_WRITER_STATISTICS stats;
  85
  86     IMFSinkWriterCallback *callback;
  87
  88     CRITICAL_SECTION cs;
  89 };
  90
  91 static struct sink_writer *impl_from_IMFSinkWriter(IMFSinkWriter *iface)
  92 {
  93     return CONTAINING_RECORD(iface, struct sink_writer, IMFSinkWriter_iface);
  94 }
  95
  96 static struct sink_writer *impl_from_events_callback_IMFAsyncCallback(IMFAsyncCallback *iface)
  97 {
  98     return CONTAINING_RECORD(iface, struct sink_writer, events_callback);
  99 }
 100
 101 static struct marker_context *impl_from_marker_context_IUnknown(IUnknown *iface)
 102 {
 103     return CONTAINING_RECORD(iface, struct marker_context, IUnknown_iface);
 104 }
 105
 106 static HRESULT WINAPI marker_context_QueryInterface(IUnknown *iface, REFIID riid, void **out)
 107 {
 108     if (IsEqualIID(riid, &IID_IUnknown))
 109     {
 110         *out = iface;
 111         IUnknown_AddRef(iface);
 112         return S_OK;
 113     }
 114
 115     *out = NULL;
 116     return E_NOINTERFACE;
 117 }
 118
 119 static ULONG WINAPI marker_context_AddRef(IUnknown *iface)
 120 {
 121     struct marker_context *context = impl_from_marker_context_IUnknown(iface);
 122     return InterlockedIncrement(&context->refcount);
 123 }
 124
 125 static ULONG WINAPI marker_context_Release(IUnknown *iface)
 126 {
 127     struct marker_context *context = impl_from_marker_context_IUnknown(iface);
 128     LONG refcount = InterlockedDecrement(&context->refcount);
 129
 130     if (!refcount)
 131         free(context);
 132
 133     return refcount;
 134 }
 135
 136 static const IUnknownVtbl marker_context_vtbl =
 137 {
 138     marker_context_QueryInterface,
 139     marker_context_AddRef,
 140     marker_context_Release,
 141 };
 142
 143 static struct marker_context *unsafe_impl_from_marker_context_IUnknown(IUnknown *iface)
 144 {
 145     if (!iface)
 146         return NULL;
 147     assert(iface->lpVtbl == &marker_context_vtbl);
 148     return CONTAINING_RECORD(iface, struct marker_context, IUnknown_iface);
 149 }
 150
 151 static HRESULT create_marker_context(unsigned int marker_type, void *user_context,
 152         IUnknown **ret)
 153 {
 154     struct marker_context *object;
 155
 156     if (!(object = calloc(1, sizeof(*object))))
 157         return E_OUTOFMEMORY;
 158
 159     object->IUnknown_iface.lpVtbl = &marker_context_vtbl;
 160     object->refcount = 1;
 161     object->marker_type = marker_type;
 162     object->user_context = user_context;
 163
 164     *ret = &object->IUnknown_iface;
 165
 166     return S_OK;
 167 }
 168
 169 static void sink_writer_release_pending_item(struct pending_item *item)
 170 {
 171     list_remove(&item->entry);
 172     if (item->sample)
 173         IMFSample_Release(item->sample);
 174     free(item);
 175 }
 176
 177 static HRESULT WINAPI sink_writer_QueryInterface(IMFSinkWriter *iface, REFIID riid, void **out)
 178 {
 179     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), out);
 180
 181     if (IsEqualIID(riid, &IID_IMFSinkWriter) ||
 182             IsEqualIID(riid, &IID_IUnknown))
 183     {
 184         *out = iface;
 185         IMFSinkWriter_AddRef(iface);
 186         return S_OK;
 187     }
 188
 189     WARN("Unsupported %s.\n", debugstr_guid(riid));
 190     *out = NULL;
 191     return E_NOINTERFACE;
 192 }
 193
 194 static ULONG WINAPI sink_writer_AddRef(IMFSinkWriter *iface)
 195 {
 196     struct sink_writer *writer = impl_from_IMFSinkWriter(iface);
 197     ULONG refcount = InterlockedIncrement(&writer->refcount);
 198
 199     TRACE("%p, %lu.\n", iface, refcount);
 200
 201     return refcount;
 202 }
 203
 204 static void sink_writer_drop_pending_items(struct stream *stream)
 205 {
 206     struct pending_item *item, *next;
 207
 208     LIST_FOR_EACH_ENTRY_SAFE(item, next, &stream->queue, struct pending_item, entry)
 209     {
 210         sink_writer_release_pending_item(item);
 211     }
 212 }
 213
 214 static ULONG WINAPI sink_writer_Release(IMFSinkWriter *iface)
 215 {
 216     struct sink_writer *writer = impl_from_IMFSinkWriter(iface);
 217     ULONG refcount = InterlockedDecrement(&writer->refcount);
 218     unsigned int i;
 219
 220     TRACE("%p, %lu.\n", iface, refcount);
 221
 222     if (!refcount)
 223     {
 224         if (writer->clock)
 225             IMFPresentationClock_Release(writer->clock);
 226         if (writer->sink)
 227             IMFMediaSink_Release(writer->sink);
 228         if (writer->callback)
 229             IMFSinkWriterCallback_Release(writer->callback);
 230         for (i = 0; i < writer->streams.count; ++i)
 231         {
 232             struct stream *stream = &writer->streams.items[i];
 233
 234             if (stream->stream_sink)
 235                 IMFStreamSink_Release(stream->stream_sink);
 236             if (stream->encoder)
 237                 IMFTransform_Release(stream->encoder);
 238             sink_writer_drop_pending_items(stream);
 239         }
 240         DeleteCriticalSection(&writer->cs);
 241         free(writer);
 242     }
 243
 244     return refcount;
 245 }
 246
 247 static HRESULT sink_writer_add_stream(struct sink_writer *writer, IMFStreamSink *stream_sink, DWORD *index)
 248 {
 249     struct stream *stream;
 250     DWORD id = 0;
 251     HRESULT hr;
 252
 253     if (!mf_array_reserve((void **)&writer->streams.items, &writer->streams.capacity, writer->streams.count + 1,
 254             sizeof(*writer->streams.items)))
 255     {
 256         return E_OUTOFMEMORY;
 257     }
 258
 259     if (FAILED(hr = IMFStreamSink_GetIdentifier(stream_sink, &id))) return hr;
 260
 261     *index = writer->streams.count++;
 262
 263     stream = &writer->streams.items[*index];
 264     memset(stream, 0, sizeof(*stream));
 265     stream->stream_sink = stream_sink;
 266     IMFStreamSink_AddRef(stream_sink);
 267     stream->stats.cb = sizeof(stream->stats);
 268     list_init(&stream->queue);
 269
 270     writer->streams.next_id = max(writer->streams.next_id, id);
 271
 272     return hr;
 273 }
 274
 275 static HRESULT WINAPI sink_writer_AddStream(IMFSinkWriter *iface, IMFMediaType *media_type, DWORD *index)
 276 {
 277     struct sink_writer *writer = impl_from_IMFSinkWriter(iface);
 278     HRESULT hr = MF_E_INVALIDREQUEST;
 279     IMFStreamSink *stream_sink;
 280     DWORD id;
 281
 282     TRACE("%p, %p, %p.\n", iface, media_type, index);
 283
 284     if (!media_type)
 285         return E_INVALIDARG;
 286
 287     if (!index)
 288         return E_POINTER;
 289
 290     EnterCriticalSection(&writer->cs);
 291
 292     if (writer->state == SINK_WRITER_STATE_INITIAL)
 293     {
 294         id = writer->streams.next_id + 1;
 295         if (SUCCEEDED(hr = IMFMediaSink_AddStreamSink(writer->sink, id, media_type, &stream_sink)))
 296         {
 297             if (FAILED(hr = sink_writer_add_stream(writer, stream_sink, index)))
 298                 IMFMediaSink_RemoveStreamSink(writer->sink, id);
 299         }
 300     }
 301
 302     LeaveCriticalSection(&writer->cs);
 303
 304     return hr;
 305 }
 306
 307 static HRESULT WINAPI sink_writer_SetInputMediaType(IMFSinkWriter *iface, DWORD index, IMFMediaType *type,
 308         IMFAttributes *parameters)
 309 {
 310     FIXME("%p, %lu, %p, %p.\n", iface, index, type, parameters);
 311
 312     return E_NOTIMPL;
 313 }
 314
 315 static HRESULT sink_writer_set_presentation_clock(struct sink_writer *writer)
 316 {
 317     IMFPresentationTimeSource *time_source = NULL;
 318     HRESULT hr;
 319
 320     if (FAILED(hr = MFCreatePresentationClock(&writer->clock))) return hr;
 321
 322     if (FAILED(IMFMediaSink_QueryInterface(writer->sink, &IID_IMFPresentationTimeSource, (void **)&time_source)))
 323         hr = MFCreateSystemTimeSource(&time_source);
 324
 325     if (SUCCEEDED(hr = IMFPresentationClock_SetTimeSource(writer->clock, time_source)))
 326         hr = IMFMediaSink_SetPresentationClock(writer->sink, writer->clock);
 327
 328     if (time_source)
 329         IMFPresentationTimeSource_Release(time_source);
 330
 331     return hr;
 332 }
 333
 334 static HRESULT WINAPI sink_writer_BeginWriting(IMFSinkWriter *iface)
 335 {
 336     struct sink_writer *writer = impl_from_IMFSinkWriter(iface);
 337     HRESULT hr = S_OK;
 338     unsigned int i;
 339
 340     TRACE("%p.\n", iface);
 341
 342     EnterCriticalSection(&writer->cs);
 343
 344     if (!writer->streams.count)
 345         hr = MF_E_INVALIDREQUEST;
 346     else if (writer->state != SINK_WRITER_STATE_INITIAL)
 347         hr = MF_E_INVALIDREQUEST;
 348     else if (SUCCEEDED(hr = sink_writer_set_presentation_clock(writer)))
 349     {
 350         for (i = 0; i < writer->streams.count; ++i)
 351         {
 352             struct stream *stream = &writer->streams.items[i];
 353
 354             if (FAILED(hr = IMFStreamSink_BeginGetEvent(stream->stream_sink, &writer->events_callback,
 355                     (IUnknown *)stream->stream_sink)))
 356             {
 357                 WARN("Failed to subscribe to events for steam %u, hr %#lx.\n", i, hr);
 358             }
 359
 360             if (stream->encoder)
 361                 IMFTransform_ProcessMessage(stream->encoder, MFT_MESSAGE_NOTIFY_BEGIN_STREAMING, 0);
 362         }
 363
 364         if (SUCCEEDED(hr))
 365             hr = IMFPresentationClock_Start(writer->clock, 0);
 366
 367         writer->state = SINK_WRITER_STATE_WRITING;
 368     }
 369
 370     LeaveCriticalSection(&writer->cs);
 371
 372     return hr;
 373 }
 374
 375 static struct stream * sink_writer_get_stream(const struct sink_writer *writer, DWORD index)
 376 {
 377     if (index >= writer->streams.count) return NULL;
 378     return &writer->streams.items[index];
 379 }
 380
 381 static HRESULT sink_writer_get_buffer_length(IMFSample *sample, LONGLONG *timestamp, DWORD *length)
 382 {
 383     IMFMediaBuffer *buffer;
 384     HRESULT hr;
 385
 386     *timestamp = 0;
 387     *length = 0;
 388
 389     if (FAILED(hr = IMFSample_ConvertToContiguousBuffer(sample, &buffer))) return hr;
 390     hr = IMFMediaBuffer_GetCurrentLength(buffer, length);
 391     IMFMediaBuffer_Release(buffer);
 392     if (FAILED(hr)) return hr;
 393     if (!*length) return E_INVALIDARG;
 394     IMFSample_GetSampleTime(sample, timestamp);
 395
 396     return hr;
 397 }
 398
 399 static HRESULT sink_writer_place_marker(struct sink_writer *writer, struct stream *stream, unsigned int marker_type,
 400         LONGLONG timestamp, void *user_context)
 401 {
 402     PROPVARIANT value, context;
 403     IUnknown *context_obj;
 404     HRESULT hr;
 405
 406     if (FAILED(hr = create_marker_context(marker_type, user_context, &context_obj))) return hr;
 407
 408     context.vt = VT_UNKNOWN;
 409     context.punkVal = context_obj;
 410     value.vt = VT_I8;
 411     value.hVal.QuadPart = timestamp;
 412     hr = IMFStreamSink_PlaceMarker(stream->stream_sink, marker_type, marker_type == MFSTREAMSINK_MARKER_TICK ? &value : NULL,
 413             &context);
 414     IUnknown_Release(context_obj);
 415     return hr;
 416 }
 417
 418 static HRESULT sink_writer_queue_marker(struct sink_writer *writer, struct stream *stream, unsigned int marker_type,
 419         LONGLONG timestamp, void *user_context)
 420 {
 421     struct pending_item *item;
 422
 423     if (list_empty(&stream->queue))
 424         return sink_writer_place_marker(writer, stream, marker_type, timestamp, user_context);
 425
 426     if (!(item = calloc(1, sizeof(*item))))
 427         return E_OUTOFMEMORY;
 428
 429     item->marker_type = marker_type;
 430     item->timestamp = timestamp;
 431     list_add_tail(&stream->queue, &item->entry);
 432
 433     return S_OK;
 434 }
 435
 436 static HRESULT sink_writer_send_stream_tick(struct sink_writer *writer, unsigned int index, LONGLONG timestamp)
 437 {
 438     struct stream *stream;
 439
 440     if (!(stream = sink_writer_get_stream(writer, index))) return MF_E_INVALIDSTREAMNUMBER;
 441
 442     writer->stats.llLastStreamTickReceived = timestamp;
 443     writer->stats.qwNumStreamTicksReceived++;
 444     stream->stats.llLastStreamTickReceived = timestamp;
 445     stream->stats.qwNumStreamTicksReceived++;
 446
 447     return sink_writer_queue_marker(writer, stream, MFSTREAMSINK_MARKER_TICK, timestamp, NULL);
 448 }
 449
 450 static HRESULT sink_writer_notify_end_of_segment(struct sink_writer *writer, unsigned int index)
 451 {
 452     struct stream *stream;
 453
 454     if (!(stream = sink_writer_get_stream(writer, index))) return MF_E_INVALIDSTREAMNUMBER;
 455
 456     return sink_writer_queue_marker(writer, stream, MFSTREAMSINK_MARKER_ENDOFSEGMENT, 0, NULL);
 457 }
 458
 459 static HRESULT sink_writer_flush(struct sink_writer *writer, unsigned int index)
 460 {
 461     struct stream *stream;
 462
 463     if (!(stream = sink_writer_get_stream(writer, index))) return MF_E_INVALIDSTREAMNUMBER;
 464
 465     sink_writer_drop_pending_items(stream);
 466
 467     IMFStreamSink_Flush(stream->stream_sink);
 468
 469     if (stream->encoder)
 470         IMFTransform_ProcessMessage(stream->encoder, MFT_MESSAGE_COMMAND_FLUSH, 0);
 471
 472     return sink_writer_place_marker(writer, stream, MFSTREAMSINK_MARKER_ENDOFSEGMENT, 0, NULL);
 473 }
 474
 475 static HRESULT sink_writer_process_sample(struct sink_writer *writer, struct stream *stream)
 476 {
 477     struct pending_item *item, *next;
 478     LONGLONG timestamp;
 479     IMFSample *sample;
 480     HRESULT hr;
 481
 482     if (list_empty(&stream->queue)) return S_OK;
 483     item = LIST_ENTRY(list_head(&stream->queue), struct pending_item, entry);
 484     if (!item->sample) return S_OK;
 485
 486     IMFSample_AddRef((sample = item->sample));
 487     sink_writer_release_pending_item(item);
 488
 489     writer->stats.dwNumOutstandingSinkSampleRequests--;
 490     stream->stats.dwNumOutstandingSinkSampleRequests--;
 491
 492     if (FAILED(hr = IMFSample_GetSampleTime(sample, &timestamp)))
 493     {
 494         IMFSample_Release(sample);
 495         writer->status = hr;
 496         return S_OK;
 497     }
 498
 499     writer->stats.llLastTimestampProcessed = timestamp;
 500     stream->stats.llLastTimestampProcessed = timestamp;
 501
 502     hr = IMFStreamSink_ProcessSample(stream->stream_sink, sample);
 503     IMFSample_Release(sample);
 504     if (FAILED(hr)) return hr;
 505
 506     LIST_FOR_EACH_ENTRY_SAFE(item, next, &stream->queue, struct pending_item, entry)
 507     {
 508         if (item->sample) break;
 509         sink_writer_place_marker(writer, stream, item->marker_type, item->timestamp, item->user_context);
 510         sink_writer_release_pending_item(item);
 511     }
 512
 513     return hr;
 514 }
 515
 516 static HRESULT sink_writer_encode_sample(struct sink_writer *writer, struct stream *stream, IMFSample *sample)
 517 {
 518     struct pending_item *item;
 519
 520     /* FIXME: call the encoder, queue its output */
 521
 522     if (!(item = calloc(1, sizeof(*item))))
 523         return E_OUTOFMEMORY;
 524
 525     item->sample = sample;
 526     IMFSample_AddRef(item->sample);
 527     list_add_tail(&stream->queue, &item->entry);
 528
 529     return S_OK;
 530 }
 531
 532 static HRESULT sink_writer_write_sample(struct sink_writer *writer, struct stream *stream, IMFSample *sample)
 533 {
 534     LONGLONG timestamp;
 535     DWORD length;
 536     HRESULT hr;
 537
 538     if (FAILED(hr = sink_writer_get_buffer_length(sample, &timestamp, &length))) return hr;
 539
 540     stream->stats.llLastTimestampReceived = timestamp;
 541     stream->stats.qwNumSamplesReceived++;
 542     stream->stats.dwByteCountQueued += length;
 543
 544     writer->stats.llLastTimestampReceived = timestamp;
 545     writer->stats.qwNumSamplesReceived++;
 546     writer->stats.dwByteCountQueued += length;
 547
 548     if (FAILED(hr = sink_writer_encode_sample(writer, stream, sample))) return hr;
 549
 550     if (stream->stats.dwNumOutstandingSinkSampleRequests)
 551         hr = sink_writer_process_sample(writer, stream);
 552
 553     return hr;
 554 }
 555
 556 static HRESULT WINAPI sink_writer_WriteSample(IMFSinkWriter *iface, DWORD index, IMFSample *sample)
 557 {
 558     struct sink_writer *writer = impl_from_IMFSinkWriter(iface);
 559     struct stream *stream;
 560     LONGLONG timestamp;
 561     DWORD length;
 562     HRESULT hr;
 563
 564     TRACE("%p, %lu, %p.\n", iface, index, sample);
 565
 566     if (!sample)
 567         return E_INVALIDARG;
 568
 569     EnterCriticalSection(&writer->cs);
 570
 571     if (writer->state != SINK_WRITER_STATE_WRITING)
 572         hr = MF_E_INVALIDREQUEST;
 573     else if (!(stream = sink_writer_get_stream(writer, index)))
 574     {
 575         hr = MF_E_INVALIDSTREAMNUMBER;
 576     }
 577     else if (SUCCEEDED(hr = sink_writer_get_buffer_length(sample, &timestamp, &length)))
 578     {
 579         stream->stats.llLastTimestampReceived = timestamp;
 580         stream->stats.qwNumSamplesReceived++;
 581         stream->stats.dwByteCountQueued += length;
 582
 583         writer->stats.llLastTimestampReceived = timestamp;
 584         writer->stats.qwNumSamplesReceived++;
 585         writer->stats.dwByteCountQueued += length;
 586
 587         hr = sink_writer_write_sample(writer, stream, sample);
 588     }
 589
 590     LeaveCriticalSection(&writer->cs);
 591
 592     return hr;
 593 }
 594
 595 static HRESULT WINAPI sink_writer_SendStreamTick(IMFSinkWriter *iface, DWORD index, LONGLONG timestamp)
 596 {
 597     struct sink_writer *writer = impl_from_IMFSinkWriter(iface);
 598     HRESULT hr;
 599
 600     TRACE("%p, %lu, %s.\n", iface, index, wine_dbgstr_longlong(timestamp));
 601
 602     EnterCriticalSection(&writer->cs);
 603
 604     if (writer->state != SINK_WRITER_STATE_WRITING)
 605         hr = MF_E_INVALIDREQUEST;
 606     else
 607         hr = sink_writer_send_stream_tick(writer, index, timestamp);
 608
 609     LeaveCriticalSection(&writer->cs);
 610
 611     return hr;
 612 }
 613
 614 static HRESULT WINAPI sink_writer_PlaceMarker(IMFSinkWriter *iface, DWORD index, void *user_context)
 615 {
 616     struct sink_writer *writer = impl_from_IMFSinkWriter(iface);
 617     struct stream *stream;
 618     HRESULT hr;
 619
 620     TRACE("%p, %lu, %p.\n", iface, index, user_context);
 621
 622     EnterCriticalSection(&writer->cs);
 623
 624     if (!writer->callback)
 625         hr = MF_E_INVALIDREQUEST;
 626     else if (writer->state != SINK_WRITER_STATE_WRITING)
 627         hr = MF_E_INVALIDREQUEST;
 628     else if (!(stream = sink_writer_get_stream(writer, index)))
 629         hr = MF_E_INVALIDSTREAMNUMBER;
 630     else
 631         hr = sink_writer_queue_marker(writer, stream, MFSTREAMSINK_MARKER_DEFAULT, 0, user_context);
 632
 633     LeaveCriticalSection(&writer->cs);
 634
 635     return hr;
 636 }
 637
 638 static HRESULT WINAPI sink_writer_NotifyEndOfSegment(IMFSinkWriter *iface, DWORD index)
 639 {
 640     struct sink_writer *writer = impl_from_IMFSinkWriter(iface);
 641     HRESULT hr = S_OK;
 642     unsigned int i;
 643
 644     TRACE("%p, %lu.\n", iface, index);
 645
 646     EnterCriticalSection(&writer->cs);
 647
 648     if (writer->state != SINK_WRITER_STATE_WRITING)
 649         hr = MF_E_INVALIDREQUEST;
 650     else if (index == MF_SINK_WRITER_ALL_STREAMS)
 651     {
 652         for (i = 0; i < writer->streams.count; ++i)
 653         {
 654             if (FAILED(hr = sink_writer_notify_end_of_segment(writer, index)))
 655             {
 656                 WARN("Failed to place a marker for stream %u.\n", i);
 657                 break;
 658             }
 659         }
 660     }
 661     else
 662         hr = sink_writer_notify_end_of_segment(writer, index);
 663
 664     LeaveCriticalSection(&writer->cs);
 665
 666     return hr;
 667 }
 668
 669 static HRESULT WINAPI sink_writer_Flush(IMFSinkWriter *iface, DWORD index)
 670 {
 671     struct sink_writer *writer = impl_from_IMFSinkWriter(iface);
 672     HRESULT hr = S_OK;
 673     unsigned int i;
 674
 675     TRACE("%p, %lu.\n", iface, index);
 676
 677     EnterCriticalSection(&writer->cs);
 678
 679     if (writer->state != SINK_WRITER_STATE_WRITING)
 680         hr = MF_E_INVALIDREQUEST;
 681     else if (index == MF_SINK_WRITER_ALL_STREAMS)
 682     {
 683         for (i = 0; i < writer->streams.count; ++i)
 684         {
 685             if (FAILED(hr = sink_writer_flush(writer, i)))
 686             {
 687                 WARN("Failed to flush stream %u.\n", i);
 688                 break;
 689             }
 690         }
 691     }
 692     else
 693         hr = sink_writer_flush(writer, index);
 694
 695     LeaveCriticalSection(&writer->cs);
 696
 697     return hr;
 698 }
 699
 700 static HRESULT WINAPI sink_writer_Finalize(IMFSinkWriter *iface)
 701 {
 702     FIXME("%p.\n", iface);
 703
 704     return E_NOTIMPL;
 705 }
 706
 707 static HRESULT sink_writer_get_service(void *object, REFGUID service, REFIID riid, void **ret)
 708 {
 709     IUnknown *iface = object;
 710     IMFGetService *gs;
 711     HRESULT hr;
 712
 713     if (!iface) return MF_E_UNSUPPORTED_SERVICE;
 714
 715     if (IsEqualGUID(service, &GUID_NULL))
 716         return IUnknown_QueryInterface(iface, riid, ret);
 717
 718     if (FAILED(hr = IUnknown_QueryInterface(iface, &IID_IMFGetService, (void **)&gs)))
 719         return hr;
 720
 721     hr = IMFGetService_GetService(gs, service, riid, ret);
 722     IMFGetService_Release(gs);
 723     return hr;
 724 }
 725
 726 static HRESULT WINAPI sink_writer_GetServiceForStream(IMFSinkWriter *iface, DWORD index, REFGUID service,
 727         REFIID riid, void **object)
 728 {
 729     struct sink_writer *writer = impl_from_IMFSinkWriter(iface);
 730     HRESULT hr = E_UNEXPECTED;
 731     struct stream *stream;
 732
 733     TRACE("%p, %lu, %s, %s, %p.\n", iface, index, debugstr_guid(service), debugstr_guid(riid), object);
 734
 735     EnterCriticalSection(&writer->cs);
 736
 737     if (index == MF_SINK_WRITER_MEDIASINK)
 738         hr = sink_writer_get_service(writer->sink, service, riid, object);
 739     else if ((stream = sink_writer_get_stream(writer, index)))
 740     {
 741         if (stream->encoder)
 742             hr = sink_writer_get_service(stream->encoder, service, riid, object);
 743         if (FAILED(hr))
 744             hr = sink_writer_get_service(stream->stream_sink, service, riid, object);
 745     }
 746     else
 747         hr = MF_E_INVALIDSTREAMNUMBER;
 748
 749     LeaveCriticalSection(&writer->cs);
 750
 751     return hr;
 752 }
 753
 754 static HRESULT WINAPI sink_writer_GetStatistics(IMFSinkWriter *iface, DWORD index, MF_SINK_WRITER_STATISTICS *stats)
 755 {
 756     struct sink_writer *writer = impl_from_IMFSinkWriter(iface);
 757     struct stream *stream;
 758     HRESULT hr = S_OK;
 759
 760     TRACE("%p, %lu, %p.\n", iface, index, stats);
 761
 762     if (!stats)
 763         return E_POINTER;
 764
 765     if (stats->cb != sizeof(*stats))
 766         return E_INVALIDARG;
 767
 768     EnterCriticalSection(&writer->cs);
 769
 770     if (FAILED(writer->status))
 771         hr = writer->status;
 772     else if (index == MF_SINK_WRITER_ALL_STREAMS)
 773         *stats = writer->stats;
 774     else if ((stream = sink_writer_get_stream(writer, index)))
 775         *stats = stream->stats;
 776     else
 777         hr = MF_E_INVALIDSTREAMNUMBER;
 778
 779     LeaveCriticalSection(&writer->cs);
 780
 781     return hr;
 782 }
 783
 784 static const IMFSinkWriterVtbl sink_writer_vtbl =
 785 {
 786     sink_writer_QueryInterface,
 787     sink_writer_AddRef,
 788     sink_writer_Release,
 789     sink_writer_AddStream,
 790     sink_writer_SetInputMediaType,
 791     sink_writer_BeginWriting,
 792     sink_writer_WriteSample,
 793     sink_writer_SendStreamTick,
 794     sink_writer_PlaceMarker,
 795     sink_writer_NotifyEndOfSegment,
 796     sink_writer_Flush,
 797     sink_writer_Finalize,
 798     sink_writer_GetServiceForStream,
 799     sink_writer_GetStatistics,
 800 };
 801
 802 static HRESULT WINAPI sink_writer_callback_QueryInterface(IMFAsyncCallback *iface,
 803         REFIID riid, void **out)
 804 {
 805     if (IsEqualIID(riid, &IID_IMFAsyncCallback) ||
 806             IsEqualIID(riid, &IID_IUnknown))
 807     {
 808         *out = iface;
 809         IMFAsyncCallback_AddRef(iface);
 810         return S_OK;
 811     }
 812
 813     WARN("Unsupported %s.\n", debugstr_guid(riid));
 814     *out = NULL;
 815     return E_NOINTERFACE;
 816 }
 817
 818 static ULONG WINAPI sink_writer_events_callback_AddRef(IMFAsyncCallback *iface)
 819 {
 820     struct sink_writer *writer = impl_from_events_callback_IMFAsyncCallback(iface);
 821     return IMFSinkWriter_AddRef(&writer->IMFSinkWriter_iface);
 822 }
 823
 824 static ULONG WINAPI sink_writer_events_callback_Release(IMFAsyncCallback *iface)
 825 {
 826     struct sink_writer *writer = impl_from_events_callback_IMFAsyncCallback(iface);
 827     return IMFSinkWriter_Release(&writer->IMFSinkWriter_iface);
 828 }
 829
 830 static HRESULT WINAPI sink_writer_callback_GetParameters(IMFAsyncCallback *iface,
 831         DWORD *flags, DWORD *queue)
 832 {
 833     return E_NOTIMPL;
 834 }
 835
 836 static struct stream *sink_writer_get_stream_for_stream_sink(struct sink_writer *writer,
 837         IMFStreamSink *stream_sink, DWORD *index)
 838 {
 839     unsigned int i;
 840
 841     for (i = 0; i < writer->streams.count; ++i)
 842     {
 843         if (writer->streams.items[i].stream_sink == stream_sink)
 844         {
 845             *index = i;
 846             return &writer->streams.items[i];
 847         }
 848     }
 849
 850     return NULL;
 851 }
 852
 853 static HRESULT WINAPI sink_writer_events_callback_Invoke(IMFAsyncCallback *iface, IMFAsyncResult *result)
 854 {
 855     struct sink_writer *writer = impl_from_events_callback_IMFAsyncCallback(iface);
 856     struct marker_context *context;
 857     IMFStreamSink *stream_sink;
 858     MediaEventType event_type;
 859     struct stream *stream;
 860     IMFMediaEvent *event;
 861     LONGLONG timestamp;
 862     HRESULT status, hr;
 863     PROPVARIANT value;
 864     DWORD index;
 865
 866     TRACE("%p, %p.\n", iface, result);
 867
 868     stream_sink = (IMFStreamSink *)IMFAsyncResult_GetStateNoAddRef(result);
 869
 870     if (FAILED(hr = IMFStreamSink_EndGetEvent(stream_sink, result, &event)))
 871         return hr;
 872
 873     IMFMediaEvent_GetType(event, &event_type);
 874     IMFMediaEvent_GetStatus(event, &status);
 875
 876     TRACE("Got event %lu.\n", event_type);
 877
 878     PropVariantInit(&value);
 879
 880     EnterCriticalSection(&writer->cs);
 881
 882     if (writer->status == S_OK && FAILED(status))
 883         writer->status = status;
 884
 885     if (writer->status == S_OK && (stream = sink_writer_get_stream_for_stream_sink(writer, stream_sink, &index)))
 886     {
 887         switch (event_type)
 888         {
 889             case MEStreamSinkRequestSample:
 890
 891                 timestamp = MFGetSystemTime();
 892
 893                 writer->stats.llLastSinkSampleRequest = timestamp;
 894                 writer->stats.dwNumOutstandingSinkSampleRequests++;
 895                 stream->stats.llLastSinkSampleRequest = timestamp;
 896                 stream->stats.dwNumOutstandingSinkSampleRequests++;
 897
 898                 sink_writer_process_sample(writer, stream);
 899
 900                 break;
 901
 902             case MEStreamSinkMarker:
 903                 if (FAILED(hr = IMFMediaEvent_GetValue(event, &value))) break;
 904                 if (value.vt != VT_UNKNOWN || !(context = unsafe_impl_from_marker_context_IUnknown(value.punkVal))) break;
 905
 906                 /* This relies on the fact that default marker type is only used for PlaceMarker(). */
 907                 if (context->marker_type == MFSTREAMSINK_MARKER_DEFAULT)
 908                     IMFSinkWriterCallback_OnMarker(writer->callback, index, context->user_context);
 909
 910                 break;
 911
 912             default:
 913                 ;
 914         }
 915     }
 916
 917     LeaveCriticalSection(&writer->cs);
 918
 919     PropVariantClear(&value);
 920
 921     IMFMediaEvent_Release(event);
 922
 923     IMFStreamSink_BeginGetEvent(stream_sink, iface, (IUnknown *)stream_sink);
 924
 925     return S_OK;
 926 }
 927
 928 static const IMFAsyncCallbackVtbl sink_writer_events_callback_vtbl =
 929 {
 930     sink_writer_callback_QueryInterface,
 931     sink_writer_events_callback_AddRef,
 932     sink_writer_events_callback_Release,
 933     sink_writer_callback_GetParameters,
 934     sink_writer_events_callback_Invoke,
 935 };
 936
 937 static HRESULT sink_writer_initialize_existing_streams(struct sink_writer *writer, IMFMediaSink *sink)
 938 {
 939     IMFStreamSink *stream_sink;
 940     DWORD count = 0, i, index;
 941     HRESULT hr;
 942
 943     if (FAILED(hr = IMFMediaSink_GetStreamSinkCount(sink, &count))) return hr;
 944     if (!count) return S_OK;
 945
 946     for (i = 0; i < count; ++i)
 947     {
 948         if (FAILED(hr = IMFMediaSink_GetStreamSinkByIndex(sink, i, &stream_sink))) break;
 949         hr = sink_writer_add_stream(writer, stream_sink, &index);
 950         IMFStreamSink_Release(stream_sink);
 951         if (FAILED(hr)) break;
 952     }
 953
 954     return hr;
 955 }
 956
 957 HRESULT create_sink_writer_from_sink(IMFMediaSink *sink, IMFAttributes *attributes,
 958         REFIID riid, void **out)
 959 {
 960     struct sink_writer *object;
 961     HRESULT hr;
 962
 963     *out = NULL;
 964
 965     if (!sink)
 966         return E_INVALIDARG;
 967
 968     if (!(object = calloc(1, sizeof(*object))))
 969         return E_OUTOFMEMORY;
 970
 971     object->IMFSinkWriter_iface.lpVtbl = &sink_writer_vtbl;
 972     object->events_callback.lpVtbl = &sink_writer_events_callback_vtbl;
 973     object->refcount = 1;
 974     object->sink = sink;
 975     IMFMediaSink_AddRef(sink);
 976     object->stats.cb = sizeof(object->stats);
 977     InitializeCriticalSection(&object->cs);
 978
 979     if (attributes)
 980     {
 981         IMFAttributes_GetUnknown(attributes, &MF_SINK_WRITER_ASYNC_CALLBACK,
 982                 &IID_IMFSinkWriterCallback, (void **)&object->callback);
 983     }
 984
 985     if (FAILED(hr = sink_writer_initialize_existing_streams(object, sink)))
 986     {
 987         IMFSinkWriter_Release(&object->IMFSinkWriter_iface);
 988         return hr;
 989     }
 990
 991     hr = IMFSinkWriter_QueryInterface(&object->IMFSinkWriter_iface, riid, out);
 992     IMFSinkWriter_Release(&object->IMFSinkWriter_iface);
 993     return hr;
 994 }
 995
 996 /***********************************************************************
 997  *      MFCreateSinkWriterFromMediaSink (mfreadwrite.@)
 998  */
 999 HRESULT WINAPI MFCreateSinkWriterFromMediaSink(IMFMediaSink *sink, IMFAttributes *attributes, IMFSinkWriter **writer)
1000 {
1001     TRACE("%p, %p, %p.\n", sink, attributes, writer);
1002
1003     if (!writer)
1004         return E_INVALIDARG;
1005
1006     return create_sink_writer_from_sink(sink, attributes, &IID_IMFSinkWriter, (void **)writer);
1007 }
1008
1009 static HRESULT sink_writer_get_sink_factory_class(const WCHAR *url, IMFAttributes *attributes, CLSID *clsid)
1010 {
1011     static const struct extension_map
1012     {
1013         const WCHAR *ext;
1014         const GUID *guid;
1015     } ext_map[] =
1016     {
1017         { L".mp4", &MFTranscodeContainerType_MPEG4 },
1018         { L".mp3", &MFTranscodeContainerType_MP3 },
1019         { L".wav", &MFTranscodeContainerType_WAVE },
1020         { L".avi", &MFTranscodeContainerType_AVI },
1021     };
1022     static const struct
1023     {
1024         const GUID *container;
1025         const CLSID *clsid;
1026     } class_map[] =
1027     {
1028         { &MFTranscodeContainerType_MPEG4, &CLSID_MFMPEG4SinkClassFactory },
1029         { &MFTranscodeContainerType_MP3, &CLSID_MFMP3SinkClassFactory },
1030         { &MFTranscodeContainerType_WAVE, &CLSID_MFWAVESinkClassFactory },
1031         { &MFTranscodeContainerType_AVI, &CLSID_MFAVISinkClassFactory },
1032     };
1033     const WCHAR *extension;
1034     GUID container;
1035     unsigned int i;
1036
1037     if (url)
1038     {
1039         if (!attributes || FAILED(IMFAttributes_GetGUID(attributes, &MF_TRANSCODE_CONTAINERTYPE, &container)))
1040         {
1041             const struct extension_map *map = NULL;
1042
1043             if (FAILED(PathCchFindExtension(url, PATHCCH_MAX_CCH, &extension))) return E_INVALIDARG;
1044             if (!extension || !*extension) return E_INVALIDARG;
1045
1046             for (i = 0; i < ARRAY_SIZE(ext_map); ++i)
1047             {
1048                 map = &ext_map[i];
1049
1050                 if (!wcsicmp(map->ext, extension))
1051                     break;
1052             }
1053
1054             if (!map)
1055             {
1056                 WARN("Couldn't find container type for extension %s.\n", debugstr_w(extension));
1057                 return E_INVALIDARG;
1058             }
1059
1060             container = *map->guid;
1061         }
1062     }
1063     else
1064     {
1065         if (!attributes) return E_INVALIDARG;
1066         if (FAILED(IMFAttributes_GetGUID(attributes, &MF_TRANSCODE_CONTAINERTYPE, &container))) return E_INVALIDARG;
1067     }
1068
1069     for (i = 0; i < ARRAY_SIZE(class_map); ++i)
1070     {
1071         if (IsEqualGUID(&container, class_map[i].container))
1072         {
1073             *clsid = *class_map[i].clsid;
1074             return S_OK;
1075         }
1076     }
1077
1078     WARN("Couldn't find factory class for container %s.\n", debugstr_guid(&container));
1079     return E_INVALIDARG;
1080 }
1081
1082 HRESULT create_sink_writer_from_url(const WCHAR *url, IMFByteStream *bytestream, IMFAttributes *attributes,
1083         REFIID riid, void **out)
1084 {
1085     IMFSinkClassFactory *factory;
1086     IMFMediaSink *sink;
1087     CLSID clsid;
1088     HRESULT hr;
1089
1090     *out = NULL;
1091
1092     if (!url && !bytestream)
1093         return E_INVALIDARG;
1094
1095     if (FAILED(hr = sink_writer_get_sink_factory_class(url, attributes, &clsid))) return hr;
1096
1097     if (FAILED(hr = CoCreateInstance(&clsid, NULL, CLSCTX_INPROC_SERVER, &IID_IMFSinkClassFactory, (void **)&factory)))
1098     {
1099         WARN("Failed to create a sink factory, hr %#lx.\n", hr);
1100         return hr;
1101     }
1102
1103     if (bytestream)
1104         IMFByteStream_AddRef(bytestream);
1105     else if (FAILED(hr = MFCreateFile(MF_ACCESSMODE_WRITE, MF_OPENMODE_DELETE_IF_EXIST, 0, url, &bytestream)))
1106     {
1107         WARN("Failed to create output file stream, hr %#lx.\n", hr);
1108         IMFSinkClassFactory_Release(factory);
1109         return hr;
1110     }
1111
1112     hr = IMFSinkClassFactory_CreateMediaSink(factory, bytestream, NULL, NULL, &sink);
1113     IMFSinkClassFactory_Release(factory);
1114     IMFByteStream_Release(bytestream);
1115     if (FAILED(hr))
1116     {
1117         WARN("Failed to create a sink, hr %#lx.\n", hr);
1118         return hr;
1119     }
1120
1121     hr = create_sink_writer_from_sink(sink, attributes, riid, out);
1122     IMFMediaSink_Release(sink);
1123
1124     return hr;
1125 }
1126
1127 /***********************************************************************
1128  *      MFCreateSinkWriterFromURL (mfreadwrite.@)
1129  */
1130 HRESULT WINAPI MFCreateSinkWriterFromURL(const WCHAR *url, IMFByteStream *bytestream, IMFAttributes *attributes,
1131         IMFSinkWriter **writer)
1132 {
1133     TRACE("%s, %p, %p, %p.\n", debugstr_w(url), bytestream, attributes, writer);
1134
1135     if (!writer)
1136         return E_INVALIDARG;
1137
1138     return create_sink_writer_from_url(url, bytestream, attributes, &IID_IMFSinkWriter, (void **)writer);
1139 }