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