dlls/winegstreamer/wm_asyncreader.c

   1 /*
   2  * Copyright 2012 Austin English
   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 "gst_private.h"
  20
  21 #include "wine/list.h"
  22
  23 WINE_DEFAULT_DEBUG_CHANNEL(wmvcore);
  24
  25 union async_op_data
  26 {
  27     struct
  28     {
  29         QWORD start;
  30         QWORD duration;
  31         void *context;
  32     } start;
  33 };
  34
  35 struct async_op
  36 {
  37     enum async_op_type
  38     {
  39         ASYNC_OP_START,
  40         ASYNC_OP_STOP,
  41         ASYNC_OP_CLOSE,
  42     } type;
  43     union async_op_data u;
  44     struct list entry;
  45 };
  46
  47 struct sample
  48 {
  49     INSSBuffer *buffer;
  50     QWORD pts, duration;
  51     DWORD flags;
  52     WORD stream;
  53 };
  54
  55 struct async_reader
  56 {
  57     struct wm_reader reader;
  58
  59     IWMReader IWMReader_iface;
  60     IWMReaderAdvanced6 IWMReaderAdvanced6_iface;
  61     IWMReaderAccelerator IWMReaderAccelerator_iface;
  62     IWMReaderNetworkConfig2 IWMReaderNetworkConfig2_iface;
  63     IWMReaderStreamClock IWMReaderStreamClock_iface;
  64     IWMReaderTypeNegotiation IWMReaderTypeNegotiation_iface;
  65     IReferenceClock IReferenceClock_iface;
  66
  67     IWMReaderCallbackAdvanced *callback_advanced;
  68     IWMReaderCallback *callback;
  69     void *context;
  70
  71     REFERENCE_TIME clock_start;
  72     LARGE_INTEGER clock_frequency;
  73
  74     HANDLE callback_thread;
  75     CRITICAL_SECTION callback_cs;
  76     CONDITION_VARIABLE callback_cv;
  77
  78     bool running;
  79     struct list async_ops;
  80
  81     bool user_clock;
  82     QWORD user_time;
  83 };
  84
  85 static REFERENCE_TIME get_current_time(const struct async_reader *reader)
  86 {
  87     LARGE_INTEGER time;
  88
  89     QueryPerformanceCounter(&time);
  90     return (time.QuadPart * 1000) / reader->clock_frequency.QuadPart * 10000;
  91 }
  92
  93 static DWORD async_reader_get_wait_timeout(struct async_reader *reader, QWORD pts)
  94 {
  95     REFERENCE_TIME current_time = reader->user_time;
  96     DWORD timeout = INFINITE;
  97
  98     if (!reader->user_clock)
  99     {
 100         current_time = get_current_time(reader) - reader->clock_start;
 101         timeout = (pts - current_time) / 10000;
 102     }
 103
 104     return pts > current_time ? timeout : 0;
 105 }
 106
 107 static bool async_reader_wait_pts(struct async_reader *reader, QWORD pts)
 108 {
 109     IWMReaderCallbackAdvanced *callback_advanced = reader->callback_advanced;
 110     DWORD timeout;
 111
 112     TRACE("reader %p, pts %I64d.\n", reader, pts);
 113
 114     if (reader->user_clock && pts > reader->user_time && callback_advanced)
 115     {
 116         QWORD user_time = reader->user_time;
 117         LeaveCriticalSection(&reader->callback_cs);
 118         IWMReaderCallbackAdvanced_OnTime(callback_advanced, user_time, reader->context);
 119         EnterCriticalSection(&reader->callback_cs);
 120     }
 121
 122     while (reader->running && list_empty(&reader->async_ops))
 123     {
 124         if (!(timeout = async_reader_get_wait_timeout(reader, pts)))
 125             return true;
 126         SleepConditionVariableCS(&reader->callback_cv, &reader->callback_cs, timeout);
 127     }
 128
 129     return false;
 130 }
 131
 132 static void async_reader_deliver_sample(struct async_reader *reader, struct sample *sample)
 133 {
 134     IWMReaderCallbackAdvanced *callback_advanced = reader->callback_advanced;
 135     IWMReaderCallback *callback = reader->callback;
 136     struct wm_stream *stream;
 137     BOOL read_compressed;
 138     HRESULT hr;
 139
 140     TRACE("reader %p, stream %u, pts %s, duration %s, flags %#lx, buffer %p.\n",
 141             reader, sample->stream, debugstr_time(sample->pts), debugstr_time(sample->duration),
 142             sample->flags, sample->buffer);
 143
 144     stream = wm_reader_get_stream_by_stream_number(&reader->reader, sample->stream);
 145     read_compressed = stream->read_compressed;
 146
 147     LeaveCriticalSection(&reader->callback_cs);
 148     if (read_compressed)
 149         hr = IWMReaderCallbackAdvanced_OnStreamSample(callback_advanced, sample->stream,
 150                 sample->pts, sample->duration, sample->flags, sample->buffer, reader->context);
 151     else
 152         hr = IWMReaderCallback_OnSample(callback, sample->stream - 1, sample->pts, sample->duration,
 153                 sample->flags, sample->buffer, reader->context);
 154     EnterCriticalSection(&reader->callback_cs);
 155
 156     TRACE("Callback returned %#lx.\n", hr);
 157
 158     INSSBuffer_Release(sample->buffer);
 159 }
 160
 161 static void callback_thread_run(struct async_reader *reader)
 162 {
 163     IWMReaderCallbackAdvanced *callback_advanced = reader->callback_advanced;
 164     IWMReaderCallback *callback = reader->callback;
 165     static const DWORD zero;
 166     HRESULT hr = S_OK;
 167
 168     while (reader->running && list_empty(&reader->async_ops))
 169     {
 170         struct sample sample;
 171
 172         LeaveCriticalSection(&reader->callback_cs);
 173         hr = wm_reader_get_stream_sample(&reader->reader, callback_advanced, 0, &sample.buffer,
 174                 &sample.pts, &sample.duration, &sample.flags, &sample.stream);
 175         EnterCriticalSection(&reader->callback_cs);
 176         if (hr != S_OK)
 177             break;
 178
 179         if (async_reader_wait_pts(reader, sample.pts))
 180             async_reader_deliver_sample(reader, &sample);
 181         else
 182             INSSBuffer_Release(sample.buffer);
 183     }
 184
 185     if (hr == NS_E_NO_MORE_SAMPLES)
 186     {
 187         BOOL user_clock = reader->user_clock;
 188         QWORD user_time = reader->user_time;
 189
 190         LeaveCriticalSection(&reader->callback_cs);
 191
 192         IWMReaderCallback_OnStatus(callback, WMT_END_OF_STREAMING, S_OK,
 193                 WMT_TYPE_DWORD, (BYTE *)&zero, reader->context);
 194         IWMReaderCallback_OnStatus(callback, WMT_EOF, S_OK,
 195                 WMT_TYPE_DWORD, (BYTE *)&zero, reader->context);
 196
 197         if (user_clock && callback_advanced)
 198         {
 199             /* We can only get here if user_time is greater than the PTS
 200              * of all samples, in which case we cannot have sent this
 201              * notification already. */
 202             IWMReaderCallbackAdvanced_OnTime(callback_advanced,
 203                     user_time, reader->context);
 204         }
 205
 206         EnterCriticalSection(&reader->callback_cs);
 207
 208         TRACE("Reached end of stream; exiting.\n");
 209     }
 210     else if (hr != S_OK)
 211     {
 212         ERR("Failed to get sample, hr %#lx.\n", hr);
 213     }
 214 }
 215
 216 static DWORD WINAPI async_reader_callback_thread(void *arg)
 217 {
 218     struct async_reader *reader = arg;
 219     static const DWORD zero;
 220     struct list *entry;
 221     HRESULT hr = S_OK;
 222
 223     IWMReaderCallback_OnStatus(reader->callback, WMT_OPENED, S_OK,
 224             WMT_TYPE_DWORD, (BYTE *)&zero, reader->context);
 225
 226     EnterCriticalSection(&reader->callback_cs);
 227
 228     while (reader->running)
 229     {
 230         if ((entry = list_head(&reader->async_ops)))
 231         {
 232             struct async_op *op = LIST_ENTRY(entry, struct async_op, entry);
 233             list_remove(&op->entry);
 234
 235             hr = list_empty(&reader->async_ops) ? S_OK : E_ABORT;
 236             switch (op->type)
 237             {
 238                 case ASYNC_OP_START:
 239                 {
 240                     reader->context = op->u.start.context;
 241                     if (SUCCEEDED(hr))
 242                     {
 243                         wm_reader_seek(&reader->reader, op->u.start.start, op->u.start.duration);
 244                         reader->clock_start = get_current_time(reader);
 245                     }
 246
 247                     LeaveCriticalSection(&reader->callback_cs);
 248                     IWMReaderCallback_OnStatus(reader->callback, WMT_STARTED, hr,
 249                             WMT_TYPE_DWORD, (BYTE *)&zero, reader->context);
 250                     EnterCriticalSection(&reader->callback_cs);
 251
 252                     if (SUCCEEDED(hr))
 253                         callback_thread_run(reader);
 254                     break;
 255                 }
 256
 257                 case ASYNC_OP_STOP:
 258                     LeaveCriticalSection(&reader->callback_cs);
 259                     IWMReaderCallback_OnStatus(reader->callback, WMT_STOPPED, hr,
 260                             WMT_TYPE_DWORD, (BYTE *)&zero, reader->context);
 261                     EnterCriticalSection(&reader->callback_cs);
 262                     break;
 263
 264                 case ASYNC_OP_CLOSE:
 265                     LeaveCriticalSection(&reader->callback_cs);
 266                     IWMReaderCallback_OnStatus(reader->callback, WMT_CLOSED, hr,
 267                             WMT_TYPE_DWORD, (BYTE *)&zero, reader->context);
 268                     EnterCriticalSection(&reader->callback_cs);
 269
 270                     if (SUCCEEDED(hr))
 271                         reader->running = false;
 272                     break;
 273             }
 274
 275             free(op);
 276         }
 277
 278         if (reader->running && list_empty(&reader->async_ops))
 279             SleepConditionVariableCS(&reader->callback_cv, &reader->callback_cs, INFINITE);
 280     }
 281
 282     LeaveCriticalSection(&reader->callback_cs);
 283
 284     TRACE("Reader is stopping; exiting.\n");
 285     return 0;
 286 }
 287
 288 static void async_reader_close(struct async_reader *reader)
 289 {
 290     struct async_op *op, *next;
 291
 292     if (reader->callback_thread)
 293     {
 294         WaitForSingleObject(reader->callback_thread, INFINITE);
 295         CloseHandle(reader->callback_thread);
 296         reader->callback_thread = NULL;
 297     }
 298
 299     LIST_FOR_EACH_ENTRY_SAFE(op, next, &reader->async_ops, struct async_op, entry)
 300     {
 301         list_remove(&op->entry);
 302         free(op);
 303     }
 304
 305     if (reader->callback_advanced)
 306         IWMReaderCallbackAdvanced_Release(reader->callback_advanced);
 307     reader->callback_advanced = NULL;
 308
 309     if (reader->callback)
 310         IWMReaderCallback_Release(reader->callback);
 311     reader->callback = NULL;
 312     reader->context = NULL;
 313 }
 314
 315 static HRESULT async_reader_open(struct async_reader *reader, IWMReaderCallback *callback, void *context)
 316 {
 317     HRESULT hr = E_OUTOFMEMORY;
 318
 319     IWMReaderCallback_AddRef((reader->callback = callback));
 320     reader->context = context;
 321
 322     if (FAILED(hr = IWMReaderCallback_QueryInterface(callback, &IID_IWMReaderCallbackAdvanced,
 323             (void **)&reader->callback_advanced)))
 324     {
 325         WARN("Failed to retrieve IWMReaderCallbackAdvanced interface, hr %#lx\n", hr);
 326         reader->callback_advanced = NULL;
 327     }
 328
 329     reader->running = true;
 330     if (!(reader->callback_thread = CreateThread(NULL, 0, async_reader_callback_thread, reader, 0, NULL)))
 331         goto error;
 332
 333     return S_OK;
 334
 335 error:
 336     async_reader_close(reader);
 337     return hr;
 338 }
 339
 340 static HRESULT async_reader_queue_op(struct async_reader *reader, enum async_op_type type, union async_op_data *data)
 341 {
 342     struct async_op *op;
 343
 344     if (!(op = calloc(1, sizeof(*op))))
 345         return E_OUTOFMEMORY;
 346     op->type = type;
 347     if (data)
 348         op->u = *data;
 349
 350     EnterCriticalSection(&reader->callback_cs);
 351     list_add_tail(&reader->async_ops, &op->entry);
 352     LeaveCriticalSection(&reader->callback_cs);
 353     WakeConditionVariable(&reader->callback_cv);
 354
 355     return S_OK;
 356 }
 357
 358 static struct async_reader *impl_from_IWMReader(IWMReader *iface)
 359 {
 360     return CONTAINING_RECORD(iface, struct async_reader, IWMReader_iface);
 361 }
 362
 363 static HRESULT WINAPI WMReader_QueryInterface(IWMReader *iface, REFIID iid, void **out)
 364 {
 365     struct async_reader *reader = impl_from_IWMReader(iface);
 366
 367     return IWMProfile3_QueryInterface(&reader->reader.IWMProfile3_iface, iid, out);
 368 }
 369
 370 static ULONG WINAPI WMReader_AddRef(IWMReader *iface)
 371 {
 372     struct async_reader *reader = impl_from_IWMReader(iface);
 373
 374     return IWMProfile3_AddRef(&reader->reader.IWMProfile3_iface);
 375 }
 376
 377 static ULONG WINAPI WMReader_Release(IWMReader *iface)
 378 {
 379     struct async_reader *reader = impl_from_IWMReader(iface);
 380
 381     return IWMProfile3_Release(&reader->reader.IWMProfile3_iface);
 382 }
 383
 384 static HRESULT WINAPI WMReader_Open(IWMReader *iface, const WCHAR *url,
 385         IWMReaderCallback *callback, void *context)
 386 {
 387     struct async_reader *reader = impl_from_IWMReader(iface);
 388     HRESULT hr;
 389
 390     TRACE("reader %p, url %s, callback %p, context %p.\n",
 391             reader, debugstr_w(url), callback, context);
 392
 393     EnterCriticalSection(&reader->reader.cs);
 394
 395     if (reader->reader.wg_parser)
 396     {
 397         LeaveCriticalSection(&reader->reader.cs);
 398         WARN("Stream is already open; returning E_UNEXPECTED.\n");
 399         return E_UNEXPECTED;
 400     }
 401
 402     if (SUCCEEDED(hr = wm_reader_open_file(&reader->reader, url))
 403             && FAILED(hr = async_reader_open(reader, callback, context)))
 404         wm_reader_close(&reader->reader);
 405
 406     LeaveCriticalSection(&reader->reader.cs);
 407     return hr;
 408 }
 409
 410 static HRESULT WINAPI WMReader_Close(IWMReader *iface)
 411 {
 412     struct async_reader *reader = impl_from_IWMReader(iface);
 413     HRESULT hr;
 414
 415     TRACE("reader %p.\n", reader);
 416
 417     EnterCriticalSection(&reader->reader.cs);
 418
 419     if (SUCCEEDED(hr = async_reader_queue_op(reader, ASYNC_OP_CLOSE, NULL)))
 420     {
 421         async_reader_close(reader);
 422         hr = wm_reader_close(&reader->reader);
 423     }
 424
 425     LeaveCriticalSection(&reader->reader.cs);
 426
 427     return hr;
 428 }
 429
 430 static HRESULT WINAPI WMReader_GetOutputCount(IWMReader *iface, DWORD *count)
 431 {
 432     struct async_reader *reader = impl_from_IWMReader(iface);
 433
 434     TRACE("reader %p, count %p.\n", reader, count);
 435
 436     EnterCriticalSection(&reader->reader.cs);
 437     *count = reader->reader.stream_count;
 438     LeaveCriticalSection(&reader->reader.cs);
 439     return S_OK;
 440 }
 441
 442 static HRESULT WINAPI WMReader_GetOutputProps(IWMReader *iface, DWORD output, IWMOutputMediaProps **props)
 443 {
 444     struct async_reader *reader = impl_from_IWMReader(iface);
 445
 446     TRACE("reader %p, output %lu, props %p.\n", reader, output, props);
 447
 448     return wm_reader_get_output_props(&reader->reader, output, props);
 449 }
 450
 451 static HRESULT WINAPI WMReader_SetOutputProps(IWMReader *iface, DWORD output, IWMOutputMediaProps *props)
 452 {
 453     struct async_reader *reader = impl_from_IWMReader(iface);
 454
 455     TRACE("reader %p, output %lu, props %p.\n", reader, output, props);
 456
 457     return wm_reader_set_output_props(&reader->reader, output, props);
 458 }
 459
 460 static HRESULT WINAPI WMReader_GetOutputFormatCount(IWMReader *iface, DWORD output, DWORD *count)
 461 {
 462     struct async_reader *reader = impl_from_IWMReader(iface);
 463
 464     TRACE("reader %p, output %lu, count %p.\n", reader, output, count);
 465
 466     return wm_reader_get_output_format_count(&reader->reader, output, count);
 467 }
 468
 469 static HRESULT WINAPI WMReader_GetOutputFormat(IWMReader *iface, DWORD output,
 470         DWORD index, IWMOutputMediaProps **props)
 471 {
 472     struct async_reader *reader = impl_from_IWMReader(iface);
 473
 474     TRACE("reader %p, output %lu, index %lu, props %p.\n", reader, output, index, props);
 475
 476     return wm_reader_get_output_format(&reader->reader, output, index, props);
 477 }
 478
 479 static HRESULT WINAPI WMReader_Start(IWMReader *iface,
 480         QWORD start, QWORD duration, float rate, void *context)
 481 {
 482     union async_op_data data = {.start = {.start = start, .duration = duration, .context = context}};
 483     struct async_reader *reader = impl_from_IWMReader(iface);
 484     HRESULT hr;
 485
 486     TRACE("reader %p, start %s, duration %s, rate %.8e, context %p.\n",
 487             reader, debugstr_time(start), debugstr_time(duration), rate, context);
 488
 489     if (rate != 1.0f)
 490         FIXME("Ignoring rate %.8e.\n", rate);
 491
 492     EnterCriticalSection(&reader->reader.cs);
 493
 494     if (!reader->callback_thread)
 495         hr = NS_E_INVALID_REQUEST;
 496     else
 497         hr = async_reader_queue_op(reader, ASYNC_OP_START, &data);
 498
 499     LeaveCriticalSection(&reader->reader.cs);
 500
 501     return hr;
 502 }
 503
 504 static HRESULT WINAPI WMReader_Stop(IWMReader *iface)
 505 {
 506     struct async_reader *reader = impl_from_IWMReader(iface);
 507     HRESULT hr;
 508
 509     TRACE("reader %p.\n", reader);
 510
 511     EnterCriticalSection(&reader->reader.cs);
 512
 513     if (!reader->callback_thread)
 514         hr = E_UNEXPECTED;
 515     else
 516         hr = async_reader_queue_op(reader, ASYNC_OP_STOP, NULL);
 517
 518     LeaveCriticalSection(&reader->reader.cs);
 519
 520     return hr;
 521 }
 522
 523 static HRESULT WINAPI WMReader_Pause(IWMReader *iface)
 524 {
 525     struct async_reader *This = impl_from_IWMReader(iface);
 526     FIXME("(%p)\n", This);
 527     return E_NOTIMPL;
 528 }
 529
 530 static HRESULT WINAPI WMReader_Resume(IWMReader *iface)
 531 {
 532     struct async_reader *This = impl_from_IWMReader(iface);
 533     FIXME("(%p)\n", This);
 534     return E_NOTIMPL;
 535 }
 536
 537 static const IWMReaderVtbl WMReaderVtbl = {
 538     WMReader_QueryInterface,
 539     WMReader_AddRef,
 540     WMReader_Release,
 541     WMReader_Open,
 542     WMReader_Close,
 543     WMReader_GetOutputCount,
 544     WMReader_GetOutputProps,
 545     WMReader_SetOutputProps,
 546     WMReader_GetOutputFormatCount,
 547     WMReader_GetOutputFormat,
 548     WMReader_Start,
 549     WMReader_Stop,
 550     WMReader_Pause,
 551     WMReader_Resume
 552 };
 553
 554 static struct async_reader *impl_from_IWMReaderAdvanced6(IWMReaderAdvanced6 *iface)
 555 {
 556     return CONTAINING_RECORD(iface, struct async_reader, IWMReaderAdvanced6_iface);
 557 }
 558
 559 static HRESULT WINAPI WMReaderAdvanced_QueryInterface(IWMReaderAdvanced6 *iface, REFIID riid, void **ppv)
 560 {
 561     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 562     return IWMReader_QueryInterface(&This->IWMReader_iface, riid, ppv);
 563 }
 564
 565 static ULONG WINAPI WMReaderAdvanced_AddRef(IWMReaderAdvanced6 *iface)
 566 {
 567     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 568     return IWMReader_AddRef(&This->IWMReader_iface);
 569 }
 570
 571 static ULONG WINAPI WMReaderAdvanced_Release(IWMReaderAdvanced6 *iface)
 572 {
 573     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 574     return IWMReader_Release(&This->IWMReader_iface);
 575 }
 576
 577 static HRESULT WINAPI WMReaderAdvanced_SetUserProvidedClock(IWMReaderAdvanced6 *iface, BOOL user_clock)
 578 {
 579     struct async_reader *reader = impl_from_IWMReaderAdvanced6(iface);
 580
 581     TRACE("reader %p, user_clock %d.\n", reader, user_clock);
 582
 583     EnterCriticalSection(&reader->callback_cs);
 584     reader->user_clock = !!user_clock;
 585     LeaveCriticalSection(&reader->callback_cs);
 586     WakeConditionVariable(&reader->callback_cv);
 587     return S_OK;
 588 }
 589
 590 static HRESULT WINAPI WMReaderAdvanced_GetUserProvidedClock(IWMReaderAdvanced6 *iface, BOOL *user_clock)
 591 {
 592     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 593     FIXME("(%p)->(%p)\n", This, user_clock);
 594     return E_NOTIMPL;
 595 }
 596
 597 static HRESULT WINAPI WMReaderAdvanced_DeliverTime(IWMReaderAdvanced6 *iface, QWORD time)
 598 {
 599     struct async_reader *reader = impl_from_IWMReaderAdvanced6(iface);
 600
 601     TRACE("reader %p, time %s.\n", reader, debugstr_time(time));
 602
 603     EnterCriticalSection(&reader->callback_cs);
 604
 605     if (!reader->user_clock)
 606     {
 607         LeaveCriticalSection(&reader->callback_cs);
 608         WARN("Not using a user-provided clock; returning E_UNEXPECTED.\n");
 609         return E_UNEXPECTED;
 610     }
 611
 612     reader->user_time = time;
 613
 614     LeaveCriticalSection(&reader->callback_cs);
 615     WakeConditionVariable(&reader->callback_cv);
 616     return S_OK;
 617 }
 618
 619 static HRESULT WINAPI WMReaderAdvanced_SetManualStreamSelection(IWMReaderAdvanced6 *iface, BOOL selection)
 620 {
 621     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 622     FIXME("(%p)->(%x)\n", This, selection);
 623     return E_NOTIMPL;
 624 }
 625
 626 static HRESULT WINAPI WMReaderAdvanced_GetManualStreamSelection(IWMReaderAdvanced6 *iface, BOOL *selection)
 627 {
 628     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 629     FIXME("(%p)->(%p)\n", This, selection);
 630     return E_NOTIMPL;
 631 }
 632
 633 static HRESULT WINAPI WMReaderAdvanced_SetStreamsSelected(IWMReaderAdvanced6 *iface,
 634         WORD count, WORD *stream_numbers, WMT_STREAM_SELECTION *selections)
 635 {
 636     struct async_reader *reader = impl_from_IWMReaderAdvanced6(iface);
 637
 638     TRACE("reader %p, count %u, stream_numbers %p, selections %p.\n",
 639             reader, count, stream_numbers, selections);
 640
 641     return wm_reader_set_streams_selected(&reader->reader, count, stream_numbers, selections);
 642 }
 643
 644 static HRESULT WINAPI WMReaderAdvanced_GetStreamSelected(IWMReaderAdvanced6 *iface,
 645         WORD stream_number, WMT_STREAM_SELECTION *selection)
 646 {
 647     struct async_reader *reader = impl_from_IWMReaderAdvanced6(iface);
 648
 649     TRACE("reader %p, stream_number %u, selection %p.\n", reader, stream_number, selection);
 650
 651     return wm_reader_get_stream_selection(&reader->reader, stream_number, selection);
 652 }
 653
 654 static HRESULT WINAPI WMReaderAdvanced_SetReceiveSelectionCallbacks(IWMReaderAdvanced6 *iface, BOOL get_callbacks)
 655 {
 656     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 657     FIXME("(%p)->(%x)\n", This, get_callbacks);
 658     return E_NOTIMPL;
 659 }
 660
 661 static HRESULT WINAPI WMReaderAdvanced_GetReceiveSelectionCallbacks(IWMReaderAdvanced6 *iface, BOOL *get_callbacks)
 662 {
 663     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 664     FIXME("(%p)->(%p)\n", This, get_callbacks);
 665     return E_NOTIMPL;
 666 }
 667
 668 static HRESULT WINAPI WMReaderAdvanced_SetReceiveStreamSamples(IWMReaderAdvanced6 *iface,
 669         WORD stream_number, BOOL compressed)
 670 {
 671     struct async_reader *reader = impl_from_IWMReaderAdvanced6(iface);
 672
 673     TRACE("reader %p, stream_number %u, compressed %d.\n", reader, stream_number, compressed);
 674
 675     return wm_reader_set_read_compressed(&reader->reader, stream_number, compressed);
 676 }
 677
 678 static HRESULT WINAPI WMReaderAdvanced_GetReceiveStreamSamples(IWMReaderAdvanced6 *iface, WORD stream_num,
 679         BOOL *receive_stream_samples)
 680 {
 681     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 682     FIXME("(%p)->(%d %p)\n", This, stream_num, receive_stream_samples);
 683     return E_NOTIMPL;
 684 }
 685
 686 static HRESULT WINAPI WMReaderAdvanced_SetAllocateForOutput(IWMReaderAdvanced6 *iface,
 687         DWORD output, BOOL allocate)
 688 {
 689     struct async_reader *reader = impl_from_IWMReaderAdvanced6(iface);
 690
 691     TRACE("reader %p, output %lu, allocate %d.\n", reader, output, allocate);
 692
 693     return wm_reader_set_allocate_for_output(&reader->reader, output, allocate);
 694 }
 695
 696 static HRESULT WINAPI WMReaderAdvanced_GetAllocateForOutput(IWMReaderAdvanced6 *iface, DWORD output_num, BOOL *allocate)
 697 {
 698     struct async_reader *reader = impl_from_IWMReaderAdvanced6(iface);
 699
 700     FIXME("reader %p, output %lu, allocate %p, stub!\n", reader, output_num, allocate);
 701
 702     return E_NOTIMPL;
 703 }
 704
 705 static HRESULT WINAPI WMReaderAdvanced_SetAllocateForStream(IWMReaderAdvanced6 *iface,
 706         WORD stream_number, BOOL allocate)
 707 {
 708     struct async_reader *reader = impl_from_IWMReaderAdvanced6(iface);
 709
 710     TRACE("reader %p, stream_number %u, allocate %d.\n", reader, stream_number, allocate);
 711
 712     return wm_reader_set_allocate_for_stream(&reader->reader, stream_number, allocate);
 713 }
 714
 715 static HRESULT WINAPI WMReaderAdvanced_GetAllocateForStream(IWMReaderAdvanced6 *iface, WORD output_num, BOOL *allocate)
 716 {
 717     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 718     FIXME("(%p)->(%d %p)\n", This, output_num, allocate);
 719     return E_NOTIMPL;
 720 }
 721
 722 static HRESULT WINAPI WMReaderAdvanced_GetStatistics(IWMReaderAdvanced6 *iface, WM_READER_STATISTICS *statistics)
 723 {
 724     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 725     FIXME("(%p)->(%p)\n", This, statistics);
 726     return E_NOTIMPL;
 727 }
 728
 729 static HRESULT WINAPI WMReaderAdvanced_SetClientInfo(IWMReaderAdvanced6 *iface, WM_READER_CLIENTINFO *client_info)
 730 {
 731     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 732     FIXME("(%p)->(%p)\n", This, client_info);
 733     return E_NOTIMPL;
 734 }
 735
 736 static HRESULT WINAPI WMReaderAdvanced_GetMaxOutputSampleSize(IWMReaderAdvanced6 *iface, DWORD output, DWORD *max)
 737 {
 738     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 739     FIXME("(%p)->(%lu %p)\n", This, output, max);
 740     return E_NOTIMPL;
 741 }
 742
 743 static HRESULT WINAPI WMReaderAdvanced_GetMaxStreamSampleSize(IWMReaderAdvanced6 *iface,
 744         WORD stream_number, DWORD *size)
 745 {
 746     struct async_reader *reader = impl_from_IWMReaderAdvanced6(iface);
 747
 748     TRACE("reader %p, stream_number %u, size %p.\n", reader, stream_number, size);
 749
 750     return wm_reader_get_max_stream_size(&reader->reader, stream_number, size);
 751 }
 752
 753 static HRESULT WINAPI WMReaderAdvanced_NotifyLateDelivery(IWMReaderAdvanced6 *iface, QWORD lateness)
 754 {
 755     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 756     FIXME("(%p)->(%s)\n", This, wine_dbgstr_longlong(lateness));
 757     return E_NOTIMPL;
 758 }
 759
 760 static HRESULT WINAPI WMReaderAdvanced2_SetPlayMode(IWMReaderAdvanced6 *iface, WMT_PLAY_MODE mode)
 761 {
 762     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 763     FIXME("(%p)->(%d)\n", This, mode);
 764     return E_NOTIMPL;
 765 }
 766
 767 static HRESULT WINAPI WMReaderAdvanced2_GetPlayMode(IWMReaderAdvanced6 *iface, WMT_PLAY_MODE *mode)
 768 {
 769     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 770     FIXME("(%p)->(%p)\n", This, mode);
 771     return E_NOTIMPL;
 772 }
 773
 774 static HRESULT WINAPI WMReaderAdvanced2_GetBufferProgress(IWMReaderAdvanced6 *iface, DWORD *percent, QWORD *buffering)
 775 {
 776     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 777     FIXME("(%p)->(%p %p)\n", This, percent, buffering);
 778     return E_NOTIMPL;
 779 }
 780
 781 static HRESULT WINAPI WMReaderAdvanced2_GetDownloadProgress(IWMReaderAdvanced6 *iface, DWORD *percent,
 782         QWORD *bytes_downloaded, QWORD *download)
 783 {
 784     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 785     FIXME("(%p)->(%p %p %p)\n", This, percent, bytes_downloaded, download);
 786     return E_NOTIMPL;
 787 }
 788
 789 static HRESULT WINAPI WMReaderAdvanced2_GetSaveAsProgress(IWMReaderAdvanced6 *iface, DWORD *percent)
 790 {
 791     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 792     FIXME("(%p)->(%p)\n", This, percent);
 793     return E_NOTIMPL;
 794 }
 795
 796 static HRESULT WINAPI WMReaderAdvanced2_SaveFileAs(IWMReaderAdvanced6 *iface, const WCHAR *filename)
 797 {
 798     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 799     FIXME("(%p)->(%s)\n", This, debugstr_w(filename));
 800     return E_NOTIMPL;
 801 }
 802
 803 static HRESULT WINAPI WMReaderAdvanced2_GetProtocolName(IWMReaderAdvanced6 *iface, WCHAR *protocol, DWORD *protocol_len)
 804 {
 805     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 806     FIXME("(%p)->(%p %p)\n", This, protocol, protocol_len);
 807     return E_NOTIMPL;
 808 }
 809
 810 static HRESULT WINAPI WMReaderAdvanced2_StartAtMarker(IWMReaderAdvanced6 *iface, WORD marker_index,
 811         QWORD duration, float rate, void *context)
 812 {
 813     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 814     FIXME("(%p)->(%d %s %f %p)\n", This, marker_index, wine_dbgstr_longlong(duration), rate, context);
 815     return E_NOTIMPL;
 816 }
 817
 818 static HRESULT WINAPI WMReaderAdvanced2_GetOutputSetting(IWMReaderAdvanced6 *iface, DWORD output_num,
 819         const WCHAR *name, WMT_ATTR_DATATYPE *type, BYTE *value, WORD *length)
 820 {
 821     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 822     FIXME("(%p)->(%lu %s %p %p %p)\n", This, output_num, debugstr_w(name), type, value, length);
 823     return E_NOTIMPL;
 824 }
 825
 826 static HRESULT WINAPI WMReaderAdvanced2_SetOutputSetting(IWMReaderAdvanced6 *iface, DWORD output_num,
 827         const WCHAR *name, WMT_ATTR_DATATYPE type, const BYTE *value, WORD length)
 828 {
 829     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 830     FIXME("(%p)->(%lu %s %#x %p %u)\n", This, output_num, debugstr_w(name), type, value, length);
 831     return E_NOTIMPL;
 832 }
 833
 834 static HRESULT WINAPI WMReaderAdvanced2_Preroll(IWMReaderAdvanced6 *iface, QWORD start, QWORD duration, float rate)
 835 {
 836     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 837     FIXME("(%p)->(%s %s %f)\n", This, wine_dbgstr_longlong(start), wine_dbgstr_longlong(duration), rate);
 838     return E_NOTIMPL;
 839 }
 840
 841 static HRESULT WINAPI WMReaderAdvanced2_SetLogClientID(IWMReaderAdvanced6 *iface, BOOL log_client_id)
 842 {
 843     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 844     FIXME("(%p)->(%x)\n", This, log_client_id);
 845     return E_NOTIMPL;
 846 }
 847
 848 static HRESULT WINAPI WMReaderAdvanced2_GetLogClientID(IWMReaderAdvanced6 *iface, BOOL *log_client_id)
 849 {
 850     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 851     FIXME("(%p)->(%p)\n", This, log_client_id);
 852     return E_NOTIMPL;
 853 }
 854
 855 static HRESULT WINAPI WMReaderAdvanced2_StopBuffering(IWMReaderAdvanced6 *iface)
 856 {
 857     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 858     FIXME("(%p)\n", This);
 859     return E_NOTIMPL;
 860 }
 861
 862 static HRESULT WINAPI WMReaderAdvanced2_OpenStream(IWMReaderAdvanced6 *iface,
 863         IStream *stream, IWMReaderCallback *callback, void *context)
 864 {
 865     struct async_reader *reader = impl_from_IWMReaderAdvanced6(iface);
 866     HRESULT hr;
 867
 868     TRACE("reader %p, stream %p, callback %p, context %p.\n", reader, stream, callback, context);
 869
 870     EnterCriticalSection(&reader->reader.cs);
 871
 872     if (reader->reader.wg_parser)
 873     {
 874         LeaveCriticalSection(&reader->reader.cs);
 875         WARN("Stream is already open; returning E_UNEXPECTED.\n");
 876         return E_UNEXPECTED;
 877     }
 878
 879     if (SUCCEEDED(hr = wm_reader_open_stream(&reader->reader, stream))
 880             && FAILED(hr = async_reader_open(reader, callback, context)))
 881         wm_reader_close(&reader->reader);
 882
 883     LeaveCriticalSection(&reader->reader.cs);
 884     return hr;
 885 }
 886
 887 static HRESULT WINAPI WMReaderAdvanced3_StopNetStreaming(IWMReaderAdvanced6 *iface)
 888 {
 889     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 890     FIXME("(%p)\n", This);
 891     return E_NOTIMPL;
 892 }
 893
 894 static HRESULT WINAPI WMReaderAdvanced3_StartAtPosition(IWMReaderAdvanced6 *iface, WORD stream_num,
 895         void *offset_start, void *duration, WMT_OFFSET_FORMAT format, float rate, void *context)
 896 {
 897     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 898     FIXME("(%p)->(%d %p %p %d %f %p)\n", This, stream_num, offset_start, duration, format, rate, context);
 899     return E_NOTIMPL;
 900 }
 901
 902 static HRESULT WINAPI WMReaderAdvanced4_GetLanguageCount(IWMReaderAdvanced6 *iface, DWORD output_num, WORD *language_count)
 903 {
 904     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 905     FIXME("(%p)->(%lu %p)\n", This, output_num, language_count);
 906     return E_NOTIMPL;
 907 }
 908
 909 static HRESULT WINAPI WMReaderAdvanced4_GetLanguage(IWMReaderAdvanced6 *iface, DWORD output_num,
 910        WORD language, WCHAR *language_string, WORD *language_string_len)
 911 {
 912     struct async_reader *reader = impl_from_IWMReaderAdvanced6(iface);
 913
 914     FIXME("reader %p, output %lu, language %#x, language_string %p, language_string_len %p, stub!\n",
 915             reader, output_num, language, language_string, language_string_len);
 916
 917     return E_NOTIMPL;
 918 }
 919
 920 static HRESULT WINAPI WMReaderAdvanced4_GetMaxSpeedFactor(IWMReaderAdvanced6 *iface, double *factor)
 921 {
 922     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 923     FIXME("(%p)->(%p)\n", This, factor);
 924     return E_NOTIMPL;
 925 }
 926
 927 static HRESULT WINAPI WMReaderAdvanced4_IsUsingFastCache(IWMReaderAdvanced6 *iface, BOOL *using_fast_cache)
 928 {
 929     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 930     FIXME("(%p)->(%p)\n", This, using_fast_cache);
 931     return E_NOTIMPL;
 932 }
 933
 934 static HRESULT WINAPI WMReaderAdvanced4_AddLogParam(IWMReaderAdvanced6 *iface, const WCHAR *namespace,
 935         const WCHAR *name, const WCHAR *value)
 936 {
 937     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 938     FIXME("(%p)->(%s %s %s)\n", This, debugstr_w(namespace), debugstr_w(name), debugstr_w(value));
 939     return E_NOTIMPL;
 940 }
 941
 942 static HRESULT WINAPI WMReaderAdvanced4_SendLogParams(IWMReaderAdvanced6 *iface)
 943 {
 944     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 945     FIXME("(%p)\n", This);
 946     return E_NOTIMPL;
 947 }
 948
 949 static HRESULT WINAPI WMReaderAdvanced4_CanSaveFileAs(IWMReaderAdvanced6 *iface, BOOL *can_save)
 950 {
 951     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 952     FIXME("(%p)->(%p)\n", This, can_save);
 953     return E_NOTIMPL;
 954 }
 955
 956 static HRESULT WINAPI WMReaderAdvanced4_CancelSaveFileAs(IWMReaderAdvanced6 *iface)
 957 {
 958     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 959     FIXME("(%p)\n", This);
 960     return E_NOTIMPL;
 961 }
 962
 963 static HRESULT WINAPI WMReaderAdvanced4_GetURL(IWMReaderAdvanced6 *iface, WCHAR *url, DWORD *url_len)
 964 {
 965     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 966     FIXME("(%p)->(%p %p)\n", This, url, url_len);
 967     return E_NOTIMPL;
 968 }
 969
 970 static HRESULT WINAPI WMReaderAdvanced5_SetPlayerHook(IWMReaderAdvanced6 *iface, DWORD output_num, IWMPlayerHook *hook)
 971 {
 972     struct async_reader *reader = impl_from_IWMReaderAdvanced6(iface);
 973
 974     FIXME("reader %p, output %lu, hook %p, stub!\n", reader, output_num, hook);
 975
 976     return E_NOTIMPL;
 977 }
 978
 979 static HRESULT WINAPI WMReaderAdvanced6_SetProtectStreamSamples(IWMReaderAdvanced6 *iface, BYTE *cert,
 980         DWORD cert_size, DWORD cert_type, DWORD flags, BYTE *initialization_vector, DWORD *initialization_vector_size)
 981 {
 982     struct async_reader *reader = impl_from_IWMReaderAdvanced6(iface);
 983
 984     FIXME("reader %p, cert %p, cert_size %lu, cert_type %#lx, flags %#lx, vector %p, vector_size %p, stub!\n",
 985             reader, cert, cert_size, cert_type, flags, initialization_vector, initialization_vector_size);
 986
 987     return E_NOTIMPL;
 988 }
 989
 990 static const IWMReaderAdvanced6Vtbl WMReaderAdvanced6Vtbl = {
 991     WMReaderAdvanced_QueryInterface,
 992     WMReaderAdvanced_AddRef,
 993     WMReaderAdvanced_Release,
 994     WMReaderAdvanced_SetUserProvidedClock,
 995     WMReaderAdvanced_GetUserProvidedClock,
 996     WMReaderAdvanced_DeliverTime,
 997     WMReaderAdvanced_SetManualStreamSelection,
 998     WMReaderAdvanced_GetManualStreamSelection,
 999     WMReaderAdvanced_SetStreamsSelected,
1000     WMReaderAdvanced_GetStreamSelected,
1001     WMReaderAdvanced_SetReceiveSelectionCallbacks,
1002     WMReaderAdvanced_GetReceiveSelectionCallbacks,
1003     WMReaderAdvanced_SetReceiveStreamSamples,
1004     WMReaderAdvanced_GetReceiveStreamSamples,
1005     WMReaderAdvanced_SetAllocateForOutput,
1006     WMReaderAdvanced_GetAllocateForOutput,
1007     WMReaderAdvanced_SetAllocateForStream,
1008     WMReaderAdvanced_GetAllocateForStream,
1009     WMReaderAdvanced_GetStatistics,
1010     WMReaderAdvanced_SetClientInfo,
1011     WMReaderAdvanced_GetMaxOutputSampleSize,
1012     WMReaderAdvanced_GetMaxStreamSampleSize,
1013     WMReaderAdvanced_NotifyLateDelivery,
1014     WMReaderAdvanced2_SetPlayMode,
1015     WMReaderAdvanced2_GetPlayMode,
1016     WMReaderAdvanced2_GetBufferProgress,
1017     WMReaderAdvanced2_GetDownloadProgress,
1018     WMReaderAdvanced2_GetSaveAsProgress,
1019     WMReaderAdvanced2_SaveFileAs,
1020     WMReaderAdvanced2_GetProtocolName,
1021     WMReaderAdvanced2_StartAtMarker,
1022     WMReaderAdvanced2_GetOutputSetting,
1023     WMReaderAdvanced2_SetOutputSetting,
1024     WMReaderAdvanced2_Preroll,
1025     WMReaderAdvanced2_SetLogClientID,
1026     WMReaderAdvanced2_GetLogClientID,
1027     WMReaderAdvanced2_StopBuffering,
1028     WMReaderAdvanced2_OpenStream,
1029     WMReaderAdvanced3_StopNetStreaming,
1030     WMReaderAdvanced3_StartAtPosition,
1031     WMReaderAdvanced4_GetLanguageCount,
1032     WMReaderAdvanced4_GetLanguage,
1033     WMReaderAdvanced4_GetMaxSpeedFactor,
1034     WMReaderAdvanced4_IsUsingFastCache,
1035     WMReaderAdvanced4_AddLogParam,
1036     WMReaderAdvanced4_SendLogParams,
1037     WMReaderAdvanced4_CanSaveFileAs,
1038     WMReaderAdvanced4_CancelSaveFileAs,
1039     WMReaderAdvanced4_GetURL,
1040     WMReaderAdvanced5_SetPlayerHook,
1041     WMReaderAdvanced6_SetProtectStreamSamples
1042 };
1043
1044 static struct async_reader *impl_from_IWMReaderAccelerator(IWMReaderAccelerator *iface)
1045 {
1046     return CONTAINING_RECORD(iface, struct async_reader, IWMReaderAccelerator_iface);
1047 }
1048
1049 static HRESULT WINAPI reader_accl_QueryInterface(IWMReaderAccelerator *iface, REFIID riid, void **object)
1050 {
1051     struct async_reader *This = impl_from_IWMReaderAccelerator(iface);
1052     return IWMReader_QueryInterface(&This->IWMReader_iface, riid, object);
1053 }
1054
1055 static ULONG WINAPI reader_accl_AddRef(IWMReaderAccelerator *iface)
1056 {
1057     struct async_reader *This = impl_from_IWMReaderAccelerator(iface);
1058     return IWMReader_AddRef(&This->IWMReader_iface);
1059 }
1060
1061 static ULONG WINAPI reader_accl_Release(IWMReaderAccelerator *iface)
1062 {
1063     struct async_reader *This = impl_from_IWMReaderAccelerator(iface);
1064     return IWMReader_Release(&This->IWMReader_iface);
1065 }
1066
1067 static HRESULT WINAPI reader_accl_GetCodecInterface(IWMReaderAccelerator *iface, DWORD output, REFIID riid, void **codec)
1068 {
1069     struct async_reader *reader = impl_from_IWMReaderAccelerator(iface);
1070
1071     FIXME("reader %p, output %lu, iid %s, codec %p, stub!\n", reader, output, debugstr_guid(riid), codec);
1072
1073     return E_NOTIMPL;
1074 }
1075
1076 static HRESULT WINAPI reader_accl_Notify(IWMReaderAccelerator *iface, DWORD output, WM_MEDIA_TYPE *subtype)
1077 {
1078     struct async_reader *reader = impl_from_IWMReaderAccelerator(iface);
1079
1080     FIXME("reader %p, output %lu, subtype %p, stub!\n", reader, output, subtype);
1081
1082     return E_NOTIMPL;
1083 }
1084
1085 static const IWMReaderAcceleratorVtbl WMReaderAcceleratorVtbl = {
1086     reader_accl_QueryInterface,
1087     reader_accl_AddRef,
1088     reader_accl_Release,
1089     reader_accl_GetCodecInterface,
1090     reader_accl_Notify
1091 };
1092
1093 static struct async_reader *impl_from_IWMReaderNetworkConfig2(IWMReaderNetworkConfig2 *iface)
1094 {
1095     return CONTAINING_RECORD(iface, struct async_reader, IWMReaderNetworkConfig2_iface);
1096 }
1097
1098 static HRESULT WINAPI networkconfig_QueryInterface(IWMReaderNetworkConfig2 *iface, REFIID riid, void **ppv)
1099 {
1100     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
1101     return IWMReader_QueryInterface(&This->IWMReader_iface, riid, ppv);
1102 }
1103
1104 static ULONG WINAPI networkconfig_AddRef(IWMReaderNetworkConfig2 *iface)
1105 {
1106     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
1107     return IWMReader_AddRef(&This->IWMReader_iface);
1108 }
1109
1110 static ULONG WINAPI networkconfig_Release(IWMReaderNetworkConfig2 *iface)
1111 {
1112     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
1113     return IWMReader_Release(&This->IWMReader_iface);
1114 }
1115
1116 static HRESULT WINAPI networkconfig_GetBufferingTime(IWMReaderNetworkConfig2 *iface, QWORD *buffering_time)
1117 {
1118     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
1119     FIXME("%p, %p\n", This, buffering_time);
1120     return E_NOTIMPL;
1121 }
1122
1123 static HRESULT WINAPI networkconfig_SetBufferingTime(IWMReaderNetworkConfig2 *iface, QWORD buffering_time)
1124 {
1125     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
1126     FIXME("%p, %s\n", This, wine_dbgstr_longlong(buffering_time));
1127     return E_NOTIMPL;
1128 }
1129
1130 static HRESULT WINAPI networkconfig_GetUDPPortRanges(IWMReaderNetworkConfig2 *iface, WM_PORT_NUMBER_RANGE *array,
1131         DWORD *ranges)
1132 {
1133     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
1134     FIXME("%p, %p, %p\n", This, array, ranges);
1135     return E_NOTIMPL;
1136 }
1137
1138 static HRESULT WINAPI networkconfig_SetUDPPortRanges(IWMReaderNetworkConfig2 *iface,
1139         WM_PORT_NUMBER_RANGE *ranges, DWORD count)
1140 {
1141     struct async_reader *reader = impl_from_IWMReaderNetworkConfig2(iface);
1142
1143     FIXME("reader %p, ranges %p, count %lu.\n", reader, ranges, count);
1144
1145     return E_NOTIMPL;
1146 }
1147
1148 static HRESULT WINAPI networkconfig_GetProxySettings(IWMReaderNetworkConfig2 *iface, const WCHAR *protocol,
1149         WMT_PROXY_SETTINGS *proxy)
1150 {
1151     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
1152     FIXME("%p, %s, %p\n", This, debugstr_w(protocol), proxy);
1153     return E_NOTIMPL;
1154 }
1155
1156 static HRESULT WINAPI networkconfig_SetProxySettings(IWMReaderNetworkConfig2 *iface, LPCWSTR protocol,
1157         WMT_PROXY_SETTINGS proxy)
1158 {
1159     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
1160     FIXME("%p, %s, %d\n", This, debugstr_w(protocol), proxy);
1161     return E_NOTIMPL;
1162 }
1163
1164 static HRESULT WINAPI networkconfig_GetProxyHostName(IWMReaderNetworkConfig2 *iface, const WCHAR *protocol,
1165         WCHAR *hostname, DWORD *size)
1166 {
1167     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
1168     FIXME("%p, %s, %p, %p\n", This, debugstr_w(protocol), hostname, size);
1169     return E_NOTIMPL;
1170 }
1171
1172 static HRESULT WINAPI networkconfig_SetProxyHostName(IWMReaderNetworkConfig2 *iface, const WCHAR *protocol,
1173         const WCHAR *hostname)
1174 {
1175     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
1176     FIXME("%p, %s, %s\n", This, debugstr_w(protocol), debugstr_w(hostname));
1177     return E_NOTIMPL;
1178 }
1179
1180 static HRESULT WINAPI networkconfig_GetProxyPort(IWMReaderNetworkConfig2 *iface, const WCHAR *protocol,
1181         DWORD *port)
1182 {
1183     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
1184     FIXME("%p, %s, %p\n", This, debugstr_w(protocol), port);
1185     return E_NOTIMPL;
1186 }
1187
1188 static HRESULT WINAPI networkconfig_SetProxyPort(IWMReaderNetworkConfig2 *iface, const WCHAR *protocol,
1189         DWORD port)
1190 {
1191     struct async_reader *reader = impl_from_IWMReaderNetworkConfig2(iface);
1192
1193     FIXME("reader %p, protocol %s, port %lu, stub!\n", reader, debugstr_w(protocol), port);
1194
1195     return E_NOTIMPL;
1196 }
1197
1198 static HRESULT WINAPI networkconfig_GetProxyExceptionList(IWMReaderNetworkConfig2 *iface, const WCHAR *protocol,
1199         WCHAR *exceptions, DWORD *count)
1200 {
1201     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
1202     FIXME("%p, %s, %p, %p\n", This, debugstr_w(protocol), exceptions, count);
1203     return E_NOTIMPL;
1204 }
1205
1206 static HRESULT WINAPI networkconfig_SetProxyExceptionList(IWMReaderNetworkConfig2 *iface, const WCHAR *protocol,
1207         const WCHAR *exceptions)
1208 {
1209     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
1210     FIXME("%p, %s, %s\n", This, debugstr_w(protocol), debugstr_w(exceptions));
1211     return E_NOTIMPL;
1212 }
1213
1214 static HRESULT WINAPI networkconfig_GetProxyBypassForLocal(IWMReaderNetworkConfig2 *iface, const WCHAR *protocol,
1215         BOOL *bypass)
1216 {
1217     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
1218     FIXME("%p, %s, %p\n", This, debugstr_w(protocol), bypass);
1219     return E_NOTIMPL;
1220 }
1221
1222 static HRESULT WINAPI networkconfig_SetProxyBypassForLocal(IWMReaderNetworkConfig2 *iface, const WCHAR *protocol,
1223         BOOL bypass)
1224 {
1225     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
1226     FIXME("%p, %s, %d\n", This, debugstr_w(protocol), bypass);
1227     return E_NOTIMPL;
1228 }
1229
1230 static HRESULT WINAPI networkconfig_GetForceRerunAutoProxyDetection(IWMReaderNetworkConfig2 *iface,
1231         BOOL *detection)
1232 {
1233     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
1234     FIXME("%p, %p\n", This, detection);
1235     return E_NOTIMPL;
1236 }
1237
1238 static HRESULT WINAPI networkconfig_SetForceRerunAutoProxyDetection(IWMReaderNetworkConfig2 *iface,
1239         BOOL detection)
1240 {
1241     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
1242     FIXME("%p, %d\n", This, detection);
1243     return E_NOTIMPL;
1244 }
1245
1246 static HRESULT WINAPI networkconfig_GetEnableMulticast(IWMReaderNetworkConfig2 *iface, BOOL *multicast)
1247 {
1248     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
1249     FIXME("%p, %p\n", This, multicast);
1250     return E_NOTIMPL;
1251 }
1252
1253 static HRESULT WINAPI networkconfig_SetEnableMulticast(IWMReaderNetworkConfig2 *iface, BOOL multicast)
1254 {
1255     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
1256     FIXME("%p, %d\n", This, multicast);
1257     return E_NOTIMPL;
1258 }
1259
1260 static HRESULT WINAPI networkconfig_GetEnableHTTP(IWMReaderNetworkConfig2 *iface, BOOL *enable)
1261 {
1262     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
1263     FIXME("%p, %p\n", This, enable);
1264     return E_NOTIMPL;
1265 }
1266
1267 static HRESULT WINAPI networkconfig_SetEnableHTTP(IWMReaderNetworkConfig2 *iface, BOOL enable)
1268 {
1269     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
1270     FIXME("%p, %d\n", This, enable);
1271     return E_NOTIMPL;
1272 }
1273
1274 static HRESULT WINAPI networkconfig_GetEnableUDP(IWMReaderNetworkConfig2 *iface, BOOL *enable)
1275 {
1276     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
1277     FIXME("%p, %p\n", This, enable);
1278     return E_NOTIMPL;
1279 }
1280
1281 static HRESULT WINAPI networkconfig_SetEnableUDP(IWMReaderNetworkConfig2 *iface, BOOL enable)
1282 {
1283     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
1284     FIXME("%p, %d\n", This, enable);
1285     return E_NOTIMPL;
1286 }
1287
1288 static HRESULT WINAPI networkconfig_GetEnableTCP(IWMReaderNetworkConfig2 *iface, BOOL *enable)
1289 {
1290     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
1291     FIXME("%p, %p\n", This, enable);
1292     return E_NOTIMPL;
1293 }
1294
1295 static HRESULT WINAPI networkconfig_SetEnableTCP(IWMReaderNetworkConfig2 *iface, BOOL enable)
1296 {
1297     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
1298     FIXME("%p, %d\n", This, enable);
1299     return E_NOTIMPL;
1300 }
1301
1302 static HRESULT WINAPI networkconfig_ResetProtocolRollover(IWMReaderNetworkConfig2 *iface)
1303 {
1304     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
1305     FIXME("%p\n", This);
1306     return E_NOTIMPL;
1307 }
1308
1309 static HRESULT WINAPI networkconfig_GetConnectionBandwidth(IWMReaderNetworkConfig2 *iface, DWORD *bandwidth)
1310 {
1311     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
1312     FIXME("%p, %p\n", This, bandwidth);
1313     return E_NOTIMPL;
1314 }
1315
1316 static HRESULT WINAPI networkconfig_SetConnectionBandwidth(IWMReaderNetworkConfig2 *iface, DWORD bandwidth)
1317 {
1318     struct async_reader *reader = impl_from_IWMReaderNetworkConfig2(iface);
1319
1320     FIXME("reader %p, bandwidth %lu, stub!\n", reader, bandwidth);
1321
1322     return E_NOTIMPL;
1323 }
1324
1325 static HRESULT WINAPI networkconfig_GetNumProtocolsSupported(IWMReaderNetworkConfig2 *iface, DWORD *protocols)
1326 {
1327     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
1328     FIXME("%p, %p\n", This, protocols);
1329     return E_NOTIMPL;
1330 }
1331
1332 static HRESULT WINAPI networkconfig_GetSupportedProtocolName(IWMReaderNetworkConfig2 *iface, DWORD protocol_num,
1333         WCHAR *protocol, DWORD *size)
1334 {
1335     struct async_reader *reader = impl_from_IWMReaderNetworkConfig2(iface);
1336
1337     FIXME("reader %p, index %lu, protocol %p, size %p, stub!\n", reader, protocol_num, protocol, size);
1338
1339     return E_NOTIMPL;
1340 }
1341
1342 static HRESULT WINAPI networkconfig_AddLoggingUrl(IWMReaderNetworkConfig2 *iface, const WCHAR *url)
1343 {
1344     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
1345     FIXME("%p, %s\n", This, debugstr_w(url));
1346     return E_NOTIMPL;
1347 }
1348
1349 static HRESULT WINAPI networkconfig_GetLoggingUrl(IWMReaderNetworkConfig2 *iface, DWORD index, WCHAR *url,
1350         DWORD *size)
1351 {
1352     struct async_reader *reader = impl_from_IWMReaderNetworkConfig2(iface);
1353
1354     FIXME("reader %p, index %lu, url %p, size %p, stub!\n", reader, index, url, size);
1355
1356     return E_NOTIMPL;
1357 }
1358
1359 static HRESULT WINAPI networkconfig_GetLoggingUrlCount(IWMReaderNetworkConfig2 *iface, DWORD *count)
1360 {
1361     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
1362     FIXME("%p, %p\n", This, count);
1363     return E_NOTIMPL;
1364 }
1365
1366 static HRESULT WINAPI networkconfig_ResetLoggingUrlList(IWMReaderNetworkConfig2 *iface)
1367 {
1368     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
1369     FIXME("%p\n", This);
1370     return E_NOTIMPL;
1371 }
1372
1373 static HRESULT WINAPI networkconfig_GetEnableContentCaching(IWMReaderNetworkConfig2 *iface, BOOL *enable)
1374 {
1375     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
1376     FIXME("%p, %p\n", This, enable);
1377     return E_NOTIMPL;
1378 }
1379
1380 static HRESULT WINAPI networkconfig_SetEnableContentCaching(IWMReaderNetworkConfig2 *iface, BOOL enable)
1381 {
1382     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
1383     FIXME("%p, %d\n", This, enable);
1384     return E_NOTIMPL;
1385 }
1386
1387 static HRESULT WINAPI networkconfig_GetEnableFastCache(IWMReaderNetworkConfig2 *iface, BOOL *enable)
1388 {
1389     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
1390     FIXME("%p, %p\n", This, enable);
1391     return E_NOTIMPL;
1392 }
1393
1394 static HRESULT WINAPI networkconfig_SetEnableFastCache(IWMReaderNetworkConfig2 *iface, BOOL enable)
1395 {
1396     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
1397     FIXME("%p, %d\n", This, enable);
1398     return E_NOTIMPL;
1399 }
1400
1401 static HRESULT WINAPI networkconfig_GetAcceleratedStreamingDuration(IWMReaderNetworkConfig2 *iface,
1402         QWORD *duration)
1403 {
1404     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
1405     FIXME("%p, %p\n", This, duration);
1406     return E_NOTIMPL;
1407 }
1408
1409 static HRESULT WINAPI networkconfig_SetAcceleratedStreamingDuration(IWMReaderNetworkConfig2 *iface,
1410         QWORD duration)
1411 {
1412     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
1413     FIXME("%p, %s\n", This, wine_dbgstr_longlong(duration));
1414     return E_NOTIMPL;
1415 }
1416
1417 static HRESULT WINAPI networkconfig_GetAutoReconnectLimit(IWMReaderNetworkConfig2 *iface, DWORD *limit)
1418 {
1419     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
1420     FIXME("%p, %p\n", This, limit);
1421     return E_NOTIMPL;
1422 }
1423
1424 static HRESULT WINAPI networkconfig_SetAutoReconnectLimit(IWMReaderNetworkConfig2 *iface, DWORD limit)
1425 {
1426     struct async_reader *reader = impl_from_IWMReaderNetworkConfig2(iface);
1427
1428     FIXME("reader %p, limit %lu, stub!\n", reader, limit);
1429
1430     return E_NOTIMPL;
1431 }
1432
1433 static HRESULT WINAPI networkconfig_GetEnableResends(IWMReaderNetworkConfig2 *iface, BOOL *enable)
1434 {
1435     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
1436     FIXME("%p, %p\n", This, enable);
1437     return E_NOTIMPL;
1438 }
1439
1440 static HRESULT WINAPI networkconfig_SetEnableResends(IWMReaderNetworkConfig2 *iface, BOOL enable)
1441 {
1442     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
1443     FIXME("%p, %u\n", This, enable);
1444     return E_NOTIMPL;
1445 }
1446
1447 static HRESULT WINAPI networkconfig_GetEnableThinning(IWMReaderNetworkConfig2 *iface, BOOL *enable)
1448 {
1449     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
1450     FIXME("%p, %p\n", This, enable);
1451     return E_NOTIMPL;
1452 }
1453
1454 static HRESULT WINAPI networkconfig_SetEnableThinning(IWMReaderNetworkConfig2 *iface, BOOL enable)
1455 {
1456     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
1457     FIXME("%p, %u\n", This, enable);
1458     return E_NOTIMPL;
1459 }
1460
1461 static HRESULT WINAPI networkconfig_GetMaxNetPacketSize(IWMReaderNetworkConfig2 *iface, DWORD *packet_size)
1462 {
1463     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
1464     FIXME("%p, %p\n", This, packet_size);
1465     return E_NOTIMPL;
1466 }
1467
1468 static const IWMReaderNetworkConfig2Vtbl WMReaderNetworkConfig2Vtbl =
1469 {
1470     networkconfig_QueryInterface,
1471     networkconfig_AddRef,
1472     networkconfig_Release,
1473     networkconfig_GetBufferingTime,
1474     networkconfig_SetBufferingTime,
1475     networkconfig_GetUDPPortRanges,
1476     networkconfig_SetUDPPortRanges,
1477     networkconfig_GetProxySettings,
1478     networkconfig_SetProxySettings,
1479     networkconfig_GetProxyHostName,
1480     networkconfig_SetProxyHostName,
1481     networkconfig_GetProxyPort,
1482     networkconfig_SetProxyPort,
1483     networkconfig_GetProxyExceptionList,
1484     networkconfig_SetProxyExceptionList,
1485     networkconfig_GetProxyBypassForLocal,
1486     networkconfig_SetProxyBypassForLocal,
1487     networkconfig_GetForceRerunAutoProxyDetection,
1488     networkconfig_SetForceRerunAutoProxyDetection,
1489     networkconfig_GetEnableMulticast,
1490     networkconfig_SetEnableMulticast,
1491     networkconfig_GetEnableHTTP,
1492     networkconfig_SetEnableHTTP,
1493     networkconfig_GetEnableUDP,
1494     networkconfig_SetEnableUDP,
1495     networkconfig_GetEnableTCP,
1496     networkconfig_SetEnableTCP,
1497     networkconfig_ResetProtocolRollover,
1498     networkconfig_GetConnectionBandwidth,
1499     networkconfig_SetConnectionBandwidth,
1500     networkconfig_GetNumProtocolsSupported,
1501     networkconfig_GetSupportedProtocolName,
1502     networkconfig_AddLoggingUrl,
1503     networkconfig_GetLoggingUrl,
1504     networkconfig_GetLoggingUrlCount,
1505     networkconfig_ResetLoggingUrlList,
1506     networkconfig_GetEnableContentCaching,
1507     networkconfig_SetEnableContentCaching,
1508     networkconfig_GetEnableFastCache,
1509     networkconfig_SetEnableFastCache,
1510     networkconfig_GetAcceleratedStreamingDuration,
1511     networkconfig_SetAcceleratedStreamingDuration,
1512     networkconfig_GetAutoReconnectLimit,
1513     networkconfig_SetAutoReconnectLimit,
1514     networkconfig_GetEnableResends,
1515     networkconfig_SetEnableResends,
1516     networkconfig_GetEnableThinning,
1517     networkconfig_SetEnableThinning,
1518     networkconfig_GetMaxNetPacketSize
1519 };
1520
1521 static struct async_reader *impl_from_IWMReaderStreamClock(IWMReaderStreamClock *iface)
1522 {
1523     return CONTAINING_RECORD(iface, struct async_reader, IWMReaderStreamClock_iface);
1524 }
1525
1526 static HRESULT WINAPI readclock_QueryInterface(IWMReaderStreamClock *iface, REFIID riid, void **ppv)
1527 {
1528     struct async_reader *This = impl_from_IWMReaderStreamClock(iface);
1529     return IWMReader_QueryInterface(&This->IWMReader_iface, riid, ppv);
1530 }
1531
1532 static ULONG WINAPI readclock_AddRef(IWMReaderStreamClock *iface)
1533 {
1534     struct async_reader *This = impl_from_IWMReaderStreamClock(iface);
1535     return IWMReader_AddRef(&This->IWMReader_iface);
1536 }
1537
1538 static ULONG WINAPI readclock_Release(IWMReaderStreamClock *iface)
1539 {
1540     struct async_reader *This = impl_from_IWMReaderStreamClock(iface);
1541     return IWMReader_Release(&This->IWMReader_iface);
1542 }
1543
1544 static HRESULT WINAPI readclock_GetTime(IWMReaderStreamClock *iface, QWORD *now)
1545 {
1546     struct async_reader *This = impl_from_IWMReaderStreamClock(iface);
1547     FIXME("%p, %p\n", This, now);
1548     return E_NOTIMPL;
1549 }
1550
1551 static HRESULT WINAPI readclock_SetTimer(IWMReaderStreamClock *iface, QWORD when, void *param, DWORD *id)
1552 {
1553     struct async_reader *This = impl_from_IWMReaderStreamClock(iface);
1554     FIXME("%p, %s, %p, %p\n", This, wine_dbgstr_longlong(when), param, id);
1555     return E_NOTIMPL;
1556 }
1557
1558 static HRESULT WINAPI readclock_KillTimer(IWMReaderStreamClock *iface, DWORD id)
1559 {
1560     struct async_reader *reader = impl_from_IWMReaderStreamClock(iface);
1561
1562     FIXME("reader %p, id %lu, stub!\n", reader, id);
1563
1564     return E_NOTIMPL;
1565 }
1566
1567 static const IWMReaderStreamClockVtbl WMReaderStreamClockVtbl =
1568 {
1569     readclock_QueryInterface,
1570     readclock_AddRef,
1571     readclock_Release,
1572     readclock_GetTime,
1573     readclock_SetTimer,
1574     readclock_KillTimer
1575 };
1576
1577 static struct async_reader *impl_from_IWMReaderTypeNegotiation(IWMReaderTypeNegotiation *iface)
1578 {
1579     return CONTAINING_RECORD(iface, struct async_reader, IWMReaderTypeNegotiation_iface);
1580 }
1581
1582 static HRESULT WINAPI negotiation_QueryInterface(IWMReaderTypeNegotiation *iface, REFIID riid, void **ppv)
1583 {
1584     struct async_reader *This = impl_from_IWMReaderTypeNegotiation(iface);
1585     return IWMReader_QueryInterface(&This->IWMReader_iface, riid, ppv);
1586 }
1587
1588 static ULONG WINAPI negotiation_AddRef(IWMReaderTypeNegotiation *iface)
1589 {
1590     struct async_reader *This = impl_from_IWMReaderTypeNegotiation(iface);
1591     return IWMReader_AddRef(&This->IWMReader_iface);
1592 }
1593
1594 static ULONG WINAPI negotiation_Release(IWMReaderTypeNegotiation *iface)
1595 {
1596     struct async_reader *This = impl_from_IWMReaderTypeNegotiation(iface);
1597     return IWMReader_Release(&This->IWMReader_iface);
1598 }
1599
1600 static HRESULT WINAPI negotiation_TryOutputProps(IWMReaderTypeNegotiation *iface, DWORD output, IWMOutputMediaProps *props)
1601 {
1602     struct async_reader *reader = impl_from_IWMReaderTypeNegotiation(iface);
1603
1604     FIXME("reader %p, output %lu, props %p, stub!\n", reader, output, props);
1605
1606     return E_NOTIMPL;
1607 }
1608
1609 static const IWMReaderTypeNegotiationVtbl WMReaderTypeNegotiationVtbl =
1610 {
1611     negotiation_QueryInterface,
1612     negotiation_AddRef,
1613     negotiation_Release,
1614     negotiation_TryOutputProps
1615 };
1616
1617 static struct async_reader *impl_from_IReferenceClock(IReferenceClock *iface)
1618 {
1619     return CONTAINING_RECORD(iface, struct async_reader, IReferenceClock_iface);
1620 }
1621
1622 static HRESULT WINAPI refclock_QueryInterface(IReferenceClock *iface, REFIID riid, void **ppv)
1623 {
1624     struct async_reader *This = impl_from_IReferenceClock(iface);
1625     return IWMReader_QueryInterface(&This->IWMReader_iface, riid, ppv);
1626 }
1627
1628 static ULONG WINAPI refclock_AddRef(IReferenceClock *iface)
1629 {
1630     struct async_reader *This = impl_from_IReferenceClock(iface);
1631     return IWMReader_AddRef(&This->IWMReader_iface);
1632 }
1633
1634 static ULONG WINAPI refclock_Release(IReferenceClock *iface)
1635 {
1636     struct async_reader *This = impl_from_IReferenceClock(iface);
1637     return IWMReader_Release(&This->IWMReader_iface);
1638 }
1639
1640 static HRESULT WINAPI refclock_GetTime(IReferenceClock *iface, REFERENCE_TIME *time)
1641 {
1642     struct async_reader *This = impl_from_IReferenceClock(iface);
1643     FIXME("%p, %p\n", This, time);
1644     return E_NOTIMPL;
1645 }
1646
1647 static HRESULT WINAPI refclock_AdviseTime(IReferenceClock *iface, REFERENCE_TIME basetime,
1648         REFERENCE_TIME streamtime, HEVENT event, DWORD_PTR *cookie)
1649 {
1650     struct async_reader *reader = impl_from_IReferenceClock(iface);
1651
1652     FIXME("reader %p, basetime %s, streamtime %s, event %#Ix, cookie %p, stub!\n",
1653             reader, debugstr_time(basetime), debugstr_time(streamtime), event, cookie);
1654
1655     return E_NOTIMPL;
1656 }
1657
1658 static HRESULT WINAPI refclock_AdvisePeriodic(IReferenceClock *iface, REFERENCE_TIME starttime,
1659         REFERENCE_TIME period, HSEMAPHORE semaphore, DWORD_PTR *cookie)
1660 {
1661     struct async_reader *reader = impl_from_IReferenceClock(iface);
1662
1663     FIXME("reader %p, starttime %s, period %s, semaphore %#Ix, cookie %p, stub!\n",
1664             reader, debugstr_time(starttime), debugstr_time(period), semaphore, cookie);
1665
1666     return E_NOTIMPL;
1667 }
1668
1669 static HRESULT WINAPI refclock_Unadvise(IReferenceClock *iface, DWORD_PTR cookie)
1670 {
1671     struct async_reader *reader = impl_from_IReferenceClock(iface);
1672
1673     FIXME("reader %p, cookie %Iu, stub!\n", reader, cookie);
1674
1675     return E_NOTIMPL;
1676 }
1677
1678 static const IReferenceClockVtbl ReferenceClockVtbl =
1679 {
1680     refclock_QueryInterface,
1681     refclock_AddRef,
1682     refclock_Release,
1683     refclock_GetTime,
1684     refclock_AdviseTime,
1685     refclock_AdvisePeriodic,
1686     refclock_Unadvise
1687 };
1688
1689 static struct async_reader *impl_from_wm_reader(struct wm_reader *iface)
1690 {
1691     return CONTAINING_RECORD(iface, struct async_reader, reader);
1692 }
1693
1694 static void *async_reader_query_interface(struct wm_reader *iface, REFIID iid)
1695 {
1696     struct async_reader *reader = impl_from_wm_reader(iface);
1697
1698     TRACE("reader %p, iid %s.\n", reader, debugstr_guid(iid));
1699
1700     if (IsEqualIID(iid, &IID_IReferenceClock))
1701         return &reader->IReferenceClock_iface;
1702
1703     if (IsEqualIID(iid, &IID_IWMReader))
1704         return &reader->IWMReader_iface;
1705
1706     if (IsEqualIID(iid, &IID_IWMReaderAccelerator))
1707         return &reader->IWMReaderAccelerator_iface;
1708
1709     if (IsEqualIID(iid, &IID_IWMReaderAdvanced)
1710             || IsEqualIID(iid, &IID_IWMReaderAdvanced2)
1711             || IsEqualIID(iid, &IID_IWMReaderAdvanced3)
1712             || IsEqualIID(iid, &IID_IWMReaderAdvanced4)
1713             || IsEqualIID(iid, &IID_IWMReaderAdvanced5)
1714             || IsEqualIID(iid, &IID_IWMReaderAdvanced6))
1715         return &reader->IWMReaderAdvanced6_iface;
1716
1717     if (IsEqualIID(iid, &IID_IWMReaderNetworkConfig)
1718             || IsEqualIID(iid, &IID_IWMReaderNetworkConfig2))
1719         return &reader->IWMReaderNetworkConfig2_iface;
1720
1721     if (IsEqualIID(iid, &IID_IWMReaderStreamClock))
1722         return &reader->IWMReaderStreamClock_iface;
1723
1724     if (IsEqualIID(iid, &IID_IWMReaderTypeNegotiation))
1725         return &reader->IWMReaderTypeNegotiation_iface;
1726
1727     return NULL;
1728 }
1729
1730 static void async_reader_destroy(struct wm_reader *iface)
1731 {
1732     struct async_reader *reader = impl_from_wm_reader(iface);
1733
1734     TRACE("reader %p.\n", reader);
1735
1736     EnterCriticalSection(&reader->callback_cs);
1737     reader->running = false;
1738     LeaveCriticalSection(&reader->callback_cs);
1739     WakeConditionVariable(&reader->callback_cv);
1740
1741     async_reader_close(reader);
1742
1743     reader->callback_cs.DebugInfo->Spare[0] = 0;
1744     DeleteCriticalSection(&reader->callback_cs);
1745
1746     wm_reader_close(&reader->reader);
1747
1748     wm_reader_cleanup(&reader->reader);
1749     free(reader);
1750 }
1751
1752 static const struct wm_reader_ops async_reader_ops =
1753 {
1754     .query_interface = async_reader_query_interface,
1755     .destroy = async_reader_destroy,
1756 };
1757
1758 HRESULT WINAPI winegstreamer_create_wm_async_reader(IWMReader **reader)
1759 {
1760     struct async_reader *object;
1761
1762     TRACE("reader %p.\n", reader);
1763
1764     if (!(object = calloc(1, sizeof(*object))))
1765         return E_OUTOFMEMORY;
1766
1767     wm_reader_init(&object->reader, &async_reader_ops);
1768
1769     object->IReferenceClock_iface.lpVtbl = &ReferenceClockVtbl;
1770     object->IWMReader_iface.lpVtbl = &WMReaderVtbl;
1771     object->IWMReaderAdvanced6_iface.lpVtbl = &WMReaderAdvanced6Vtbl;
1772     object->IWMReaderAccelerator_iface.lpVtbl = &WMReaderAcceleratorVtbl;
1773     object->IWMReaderNetworkConfig2_iface.lpVtbl = &WMReaderNetworkConfig2Vtbl;
1774     object->IWMReaderStreamClock_iface.lpVtbl = &WMReaderStreamClockVtbl;
1775     object->IWMReaderTypeNegotiation_iface.lpVtbl = &WMReaderTypeNegotiationVtbl;
1776
1777     InitializeCriticalSection(&object->callback_cs);
1778     object->callback_cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": async_reader.callback_cs");
1779
1780     QueryPerformanceFrequency(&object->clock_frequency);
1781     list_init(&object->async_ops);
1782
1783     TRACE("Created async reader %p.\n", object);
1784     *reader = (IWMReader *)&object->IWMReader_iface;
1785     return S_OK;
1786 }