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
  39 static void open_stream(struct async_reader *reader, IWMReaderCallback *callback, void *context)
  40 {
  41     static const DWORD zero;
  42
  43     IWMReaderCallback_AddRef(reader->callback = callback);
  44     reader->context = context;
  45     IWMReaderCallback_OnStatus(callback, WMT_OPENED, S_OK, WMT_TYPE_DWORD, (BYTE *)&zero, context);
  46 }
  47
  48 static struct async_reader *impl_from_IWMReader(IWMReader *iface)
  49 {
  50     return CONTAINING_RECORD(iface, struct async_reader, IWMReader_iface);
  51 }
  52
  53 static HRESULT WINAPI WMReader_QueryInterface(IWMReader *iface, REFIID iid, void **out)
  54 {
  55     struct async_reader *reader = impl_from_IWMReader(iface);
  56
  57     return IWMProfile3_QueryInterface(&reader->reader.IWMProfile3_iface, iid, out);
  58 }
  59
  60 static ULONG WINAPI WMReader_AddRef(IWMReader *iface)
  61 {
  62     struct async_reader *reader = impl_from_IWMReader(iface);
  63
  64     return IWMProfile3_AddRef(&reader->reader.IWMProfile3_iface);
  65 }
  66
  67 static ULONG WINAPI WMReader_Release(IWMReader *iface)
  68 {
  69     struct async_reader *reader = impl_from_IWMReader(iface);
  70
  71     return IWMProfile3_Release(&reader->reader.IWMProfile3_iface);
  72 }
  73
  74 static HRESULT WINAPI WMReader_Open(IWMReader *iface, const WCHAR *url, IWMReaderCallback *callback, void *context)
  75 {
  76     struct async_reader *This = impl_from_IWMReader(iface);
  77     FIXME("(%p)->(%s %p %p)\n", This, debugstr_w(url), callback, context);
  78     return E_NOTIMPL;
  79 }
  80
  81 static HRESULT WINAPI WMReader_Close(IWMReader *iface)
  82 {
  83     struct async_reader *reader = impl_from_IWMReader(iface);
  84     static const DWORD zero;
  85     HRESULT hr;
  86
  87     TRACE("reader %p.\n", reader);
  88
  89     EnterCriticalSection(&reader->reader.cs);
  90
  91     hr = wm_reader_close(&reader->reader);
  92     if (reader->callback)
  93     {
  94         IWMReaderCallback_OnStatus(reader->callback, WMT_CLOSED, S_OK,
  95                 WMT_TYPE_DWORD, (BYTE *)&zero, reader->context);
  96         IWMReaderCallback_Release(reader->callback);
  97     }
  98     reader->callback = NULL;
  99
 100     LeaveCriticalSection(&reader->reader.cs);
 101
 102     return hr;
 103 }
 104
 105 static HRESULT WINAPI WMReader_GetOutputCount(IWMReader *iface, DWORD *count)
 106 {
 107     struct async_reader *reader = impl_from_IWMReader(iface);
 108
 109     TRACE("reader %p, count %p.\n", reader, count);
 110
 111     EnterCriticalSection(&reader->reader.cs);
 112     *count = reader->reader.stream_count;
 113     LeaveCriticalSection(&reader->reader.cs);
 114     return S_OK;
 115 }
 116
 117 static HRESULT WINAPI WMReader_GetOutputProps(IWMReader *iface, DWORD output, IWMOutputMediaProps **props)
 118 {
 119     struct async_reader *reader = impl_from_IWMReader(iface);
 120
 121     TRACE("reader %p, output %u, props %p.\n", reader, output, props);
 122
 123     return wm_reader_get_output_props(&reader->reader, output, props);
 124 }
 125
 126 static HRESULT WINAPI WMReader_SetOutputProps(IWMReader *iface, DWORD output, IWMOutputMediaProps *props)
 127 {
 128     struct async_reader *reader = impl_from_IWMReader(iface);
 129
 130     TRACE("reader %p, output %u, props %p.\n", reader, output, props);
 131
 132     return wm_reader_set_output_props(&reader->reader, output, props);
 133 }
 134
 135 static HRESULT WINAPI WMReader_GetOutputFormatCount(IWMReader *iface, DWORD output, DWORD *count)
 136 {
 137     struct async_reader *reader = impl_from_IWMReader(iface);
 138
 139     TRACE("reader %p, output %u, count %p.\n", reader, output, count);
 140
 141     return wm_reader_get_output_format_count(&reader->reader, output, count);
 142 }
 143
 144 static HRESULT WINAPI WMReader_GetOutputFormat(IWMReader *iface, DWORD output,
 145         DWORD index, IWMOutputMediaProps **props)
 146 {
 147     struct async_reader *reader = impl_from_IWMReader(iface);
 148
 149     TRACE("reader %p, output %u, index %u, props %p.\n", reader, output, index, props);
 150
 151     return wm_reader_get_output_format(&reader->reader, output, index, props);
 152 }
 153
 154 static HRESULT WINAPI WMReader_Start(IWMReader *iface, QWORD start, QWORD duration, float rate, void *context)
 155 {
 156     struct async_reader *This = impl_from_IWMReader(iface);
 157     FIXME("(%p)->(%s %s %f %p)\n", This, wine_dbgstr_longlong(start), wine_dbgstr_longlong(duration), rate, context);
 158     return E_NOTIMPL;
 159 }
 160
 161 static HRESULT WINAPI WMReader_Stop(IWMReader *iface)
 162 {
 163     struct async_reader *This = impl_from_IWMReader(iface);
 164     FIXME("(%p)\n", This);
 165     return E_NOTIMPL;
 166 }
 167
 168 static HRESULT WINAPI WMReader_Pause(IWMReader *iface)
 169 {
 170     struct async_reader *This = impl_from_IWMReader(iface);
 171     FIXME("(%p)\n", This);
 172     return E_NOTIMPL;
 173 }
 174
 175 static HRESULT WINAPI WMReader_Resume(IWMReader *iface)
 176 {
 177     struct async_reader *This = impl_from_IWMReader(iface);
 178     FIXME("(%p)\n", This);
 179     return E_NOTIMPL;
 180 }
 181
 182 static const IWMReaderVtbl WMReaderVtbl = {
 183     WMReader_QueryInterface,
 184     WMReader_AddRef,
 185     WMReader_Release,
 186     WMReader_Open,
 187     WMReader_Close,
 188     WMReader_GetOutputCount,
 189     WMReader_GetOutputProps,
 190     WMReader_SetOutputProps,
 191     WMReader_GetOutputFormatCount,
 192     WMReader_GetOutputFormat,
 193     WMReader_Start,
 194     WMReader_Stop,
 195     WMReader_Pause,
 196     WMReader_Resume
 197 };
 198
 199 static struct async_reader *impl_from_IWMReaderAdvanced6(IWMReaderAdvanced6 *iface)
 200 {
 201     return CONTAINING_RECORD(iface, struct async_reader, IWMReaderAdvanced6_iface);
 202 }
 203
 204 static HRESULT WINAPI WMReaderAdvanced_QueryInterface(IWMReaderAdvanced6 *iface, REFIID riid, void **ppv)
 205 {
 206     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 207     return IWMReader_QueryInterface(&This->IWMReader_iface, riid, ppv);
 208 }
 209
 210 static ULONG WINAPI WMReaderAdvanced_AddRef(IWMReaderAdvanced6 *iface)
 211 {
 212     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 213     return IWMReader_AddRef(&This->IWMReader_iface);
 214 }
 215
 216 static ULONG WINAPI WMReaderAdvanced_Release(IWMReaderAdvanced6 *iface)
 217 {
 218     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 219     return IWMReader_Release(&This->IWMReader_iface);
 220 }
 221
 222 static HRESULT WINAPI WMReaderAdvanced_SetUserProvidedClock(IWMReaderAdvanced6 *iface, BOOL user_clock)
 223 {
 224     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 225     FIXME("(%p)->(%x)\n", This, user_clock);
 226     return E_NOTIMPL;
 227 }
 228
 229 static HRESULT WINAPI WMReaderAdvanced_GetUserProvidedClock(IWMReaderAdvanced6 *iface, BOOL *user_clock)
 230 {
 231     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 232     FIXME("(%p)->(%p)\n", This, user_clock);
 233     return E_NOTIMPL;
 234 }
 235
 236 static HRESULT WINAPI WMReaderAdvanced_DeliverTime(IWMReaderAdvanced6 *iface, QWORD time)
 237 {
 238     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 239     FIXME("(%p)->(%s)\n", This, wine_dbgstr_longlong(time));
 240     return E_NOTIMPL;
 241 }
 242
 243 static HRESULT WINAPI WMReaderAdvanced_SetManualStreamSelection(IWMReaderAdvanced6 *iface, BOOL selection)
 244 {
 245     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 246     FIXME("(%p)->(%x)\n", This, selection);
 247     return E_NOTIMPL;
 248 }
 249
 250 static HRESULT WINAPI WMReaderAdvanced_GetManualStreamSelection(IWMReaderAdvanced6 *iface, BOOL *selection)
 251 {
 252     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 253     FIXME("(%p)->(%p)\n", This, selection);
 254     return E_NOTIMPL;
 255 }
 256
 257 static HRESULT WINAPI WMReaderAdvanced_SetStreamsSelected(IWMReaderAdvanced6 *iface, WORD stream_count,
 258         WORD *stream_numbers, WMT_STREAM_SELECTION *selections)
 259 {
 260     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 261     FIXME("(%p)->(%d %p %p)\n", This, stream_count, stream_numbers, selections);
 262     return E_NOTIMPL;
 263 }
 264
 265 static HRESULT WINAPI WMReaderAdvanced_GetStreamSelected(IWMReaderAdvanced6 *iface, WORD stream_num,
 266         WMT_STREAM_SELECTION *selection)
 267 {
 268     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 269     FIXME("(%p)->(%d %p)\n", This, stream_num, selection);
 270     return E_NOTIMPL;
 271 }
 272
 273 static HRESULT WINAPI WMReaderAdvanced_SetReceiveSelectionCallbacks(IWMReaderAdvanced6 *iface, BOOL get_callbacks)
 274 {
 275     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 276     FIXME("(%p)->(%x)\n", This, get_callbacks);
 277     return E_NOTIMPL;
 278 }
 279
 280 static HRESULT WINAPI WMReaderAdvanced_GetReceiveSelectionCallbacks(IWMReaderAdvanced6 *iface, BOOL *get_callbacks)
 281 {
 282     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 283     FIXME("(%p)->(%p)\n", This, get_callbacks);
 284     return E_NOTIMPL;
 285 }
 286
 287 static HRESULT WINAPI WMReaderAdvanced_SetReceiveStreamSamples(IWMReaderAdvanced6 *iface, WORD stream_num,
 288         BOOL receive_stream_samples)
 289 {
 290     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 291     FIXME("(%p)->(%d %x)\n", This, stream_num, receive_stream_samples);
 292     return E_NOTIMPL;
 293 }
 294
 295 static HRESULT WINAPI WMReaderAdvanced_GetReceiveStreamSamples(IWMReaderAdvanced6 *iface, WORD stream_num,
 296         BOOL *receive_stream_samples)
 297 {
 298     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 299     FIXME("(%p)->(%d %p)\n", This, stream_num, receive_stream_samples);
 300     return E_NOTIMPL;
 301 }
 302
 303 static HRESULT WINAPI WMReaderAdvanced_SetAllocateForOutput(IWMReaderAdvanced6 *iface, DWORD output_num, BOOL allocate)
 304 {
 305     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 306     FIXME("(%p)->(%d %x)\n", This, output_num, allocate);
 307     return E_NOTIMPL;
 308 }
 309
 310 static HRESULT WINAPI WMReaderAdvanced_GetAllocateForOutput(IWMReaderAdvanced6 *iface, DWORD output_num, BOOL *allocate)
 311 {
 312     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 313     FIXME("(%p)->(%d %p)\n", This, output_num, allocate);
 314     return E_NOTIMPL;
 315 }
 316
 317 static HRESULT WINAPI WMReaderAdvanced_SetAllocateForStream(IWMReaderAdvanced6 *iface, WORD output_num, BOOL allocate)
 318 {
 319     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 320     FIXME("(%p)->(%d %x)\n", This, output_num, allocate);
 321     return E_NOTIMPL;
 322 }
 323
 324 static HRESULT WINAPI WMReaderAdvanced_GetAllocateForStream(IWMReaderAdvanced6 *iface, WORD output_num, BOOL *allocate)
 325 {
 326     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 327     FIXME("(%p)->(%d %p)\n", This, output_num, allocate);
 328     return E_NOTIMPL;
 329 }
 330
 331 static HRESULT WINAPI WMReaderAdvanced_GetStatistics(IWMReaderAdvanced6 *iface, WM_READER_STATISTICS *statistics)
 332 {
 333     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 334     FIXME("(%p)->(%p)\n", This, statistics);
 335     return E_NOTIMPL;
 336 }
 337
 338 static HRESULT WINAPI WMReaderAdvanced_SetClientInfo(IWMReaderAdvanced6 *iface, WM_READER_CLIENTINFO *client_info)
 339 {
 340     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 341     FIXME("(%p)->(%p)\n", This, client_info);
 342     return E_NOTIMPL;
 343 }
 344
 345 static HRESULT WINAPI WMReaderAdvanced_GetMaxOutputSampleSize(IWMReaderAdvanced6 *iface, DWORD output, DWORD *max)
 346 {
 347     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 348     FIXME("(%p)->(%d %p)\n", This, output, max);
 349     return E_NOTIMPL;
 350 }
 351
 352 static HRESULT WINAPI WMReaderAdvanced_GetMaxStreamSampleSize(IWMReaderAdvanced6 *iface, WORD stream, DWORD *max)
 353 {
 354     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 355     FIXME("(%p)->(%d %p)\n", This, stream, max);
 356     return E_NOTIMPL;
 357 }
 358
 359 static HRESULT WINAPI WMReaderAdvanced_NotifyLateDelivery(IWMReaderAdvanced6 *iface, QWORD lateness)
 360 {
 361     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 362     FIXME("(%p)->(%s)\n", This, wine_dbgstr_longlong(lateness));
 363     return E_NOTIMPL;
 364 }
 365
 366 static HRESULT WINAPI WMReaderAdvanced2_SetPlayMode(IWMReaderAdvanced6 *iface, WMT_PLAY_MODE mode)
 367 {
 368     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 369     FIXME("(%p)->(%d)\n", This, mode);
 370     return E_NOTIMPL;
 371 }
 372
 373 static HRESULT WINAPI WMReaderAdvanced2_GetPlayMode(IWMReaderAdvanced6 *iface, WMT_PLAY_MODE *mode)
 374 {
 375     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 376     FIXME("(%p)->(%p)\n", This, mode);
 377     return E_NOTIMPL;
 378 }
 379
 380 static HRESULT WINAPI WMReaderAdvanced2_GetBufferProgress(IWMReaderAdvanced6 *iface, DWORD *percent, QWORD *buffering)
 381 {
 382     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 383     FIXME("(%p)->(%p %p)\n", This, percent, buffering);
 384     return E_NOTIMPL;
 385 }
 386
 387 static HRESULT WINAPI WMReaderAdvanced2_GetDownloadProgress(IWMReaderAdvanced6 *iface, DWORD *percent,
 388         QWORD *bytes_downloaded, QWORD *download)
 389 {
 390     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 391     FIXME("(%p)->(%p %p %p)\n", This, percent, bytes_downloaded, download);
 392     return E_NOTIMPL;
 393 }
 394
 395 static HRESULT WINAPI WMReaderAdvanced2_GetSaveAsProgress(IWMReaderAdvanced6 *iface, DWORD *percent)
 396 {
 397     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 398     FIXME("(%p)->(%p)\n", This, percent);
 399     return E_NOTIMPL;
 400 }
 401
 402 static HRESULT WINAPI WMReaderAdvanced2_SaveFileAs(IWMReaderAdvanced6 *iface, const WCHAR *filename)
 403 {
 404     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 405     FIXME("(%p)->(%s)\n", This, debugstr_w(filename));
 406     return E_NOTIMPL;
 407 }
 408
 409 static HRESULT WINAPI WMReaderAdvanced2_GetProtocolName(IWMReaderAdvanced6 *iface, WCHAR *protocol, DWORD *protocol_len)
 410 {
 411     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 412     FIXME("(%p)->(%p %p)\n", This, protocol, protocol_len);
 413     return E_NOTIMPL;
 414 }
 415
 416 static HRESULT WINAPI WMReaderAdvanced2_StartAtMarker(IWMReaderAdvanced6 *iface, WORD marker_index,
 417         QWORD duration, float rate, void *context)
 418 {
 419     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 420     FIXME("(%p)->(%d %s %f %p)\n", This, marker_index, wine_dbgstr_longlong(duration), rate, context);
 421     return E_NOTIMPL;
 422 }
 423
 424 static HRESULT WINAPI WMReaderAdvanced2_GetOutputSetting(IWMReaderAdvanced6 *iface, DWORD output_num,
 425         const WCHAR *name, WMT_ATTR_DATATYPE *type, BYTE *value, WORD *length)
 426 {
 427     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 428     FIXME("(%p)->(%d %s %p %p %p)\n", This, output_num, debugstr_w(name), type, value, length);
 429     return E_NOTIMPL;
 430 }
 431
 432 static HRESULT WINAPI WMReaderAdvanced2_SetOutputSetting(IWMReaderAdvanced6 *iface, DWORD output_num,
 433         const WCHAR *name, WMT_ATTR_DATATYPE type, const BYTE *value, WORD length)
 434 {
 435     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 436     FIXME("(%p)->(%d %s %d %p %d)\n", This, output_num, debugstr_w(name), type, value, length);
 437     return E_NOTIMPL;
 438 }
 439
 440 static HRESULT WINAPI WMReaderAdvanced2_Preroll(IWMReaderAdvanced6 *iface, QWORD start, QWORD duration, float rate)
 441 {
 442     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 443     FIXME("(%p)->(%s %s %f)\n", This, wine_dbgstr_longlong(start), wine_dbgstr_longlong(duration), rate);
 444     return E_NOTIMPL;
 445 }
 446
 447 static HRESULT WINAPI WMReaderAdvanced2_SetLogClientID(IWMReaderAdvanced6 *iface, BOOL log_client_id)
 448 {
 449     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 450     FIXME("(%p)->(%x)\n", This, log_client_id);
 451     return E_NOTIMPL;
 452 }
 453
 454 static HRESULT WINAPI WMReaderAdvanced2_GetLogClientID(IWMReaderAdvanced6 *iface, BOOL *log_client_id)
 455 {
 456     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 457     FIXME("(%p)->(%p)\n", This, log_client_id);
 458     return E_NOTIMPL;
 459 }
 460
 461 static HRESULT WINAPI WMReaderAdvanced2_StopBuffering(IWMReaderAdvanced6 *iface)
 462 {
 463     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 464     FIXME("(%p)\n", This);
 465     return E_NOTIMPL;
 466 }
 467
 468 static HRESULT WINAPI WMReaderAdvanced2_OpenStream(IWMReaderAdvanced6 *iface,
 469         IStream *stream, IWMReaderCallback *callback, void *context)
 470 {
 471     struct async_reader *reader = impl_from_IWMReaderAdvanced6(iface);
 472     HRESULT hr;
 473
 474     TRACE("reader %p, stream %p, callback %p, context %p.\n", reader, stream, callback, context);
 475
 476     EnterCriticalSection(&reader->reader.cs);
 477
 478     if (SUCCEEDED(hr = wm_reader_open_stream(&reader->reader, stream)))
 479         open_stream(reader, callback, context);
 480
 481     LeaveCriticalSection(&reader->reader.cs);
 482     return hr;
 483 }
 484
 485 static HRESULT WINAPI WMReaderAdvanced3_StopNetStreaming(IWMReaderAdvanced6 *iface)
 486 {
 487     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 488     FIXME("(%p)\n", This);
 489     return E_NOTIMPL;
 490 }
 491
 492 static HRESULT WINAPI WMReaderAdvanced3_StartAtPosition(IWMReaderAdvanced6 *iface, WORD stream_num,
 493         void *offset_start, void *duration, WMT_OFFSET_FORMAT format, float rate, void *context)
 494 {
 495     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 496     FIXME("(%p)->(%d %p %p %d %f %p)\n", This, stream_num, offset_start, duration, format, rate, context);
 497     return E_NOTIMPL;
 498 }
 499
 500 static HRESULT WINAPI WMReaderAdvanced4_GetLanguageCount(IWMReaderAdvanced6 *iface, DWORD output_num, WORD *language_count)
 501 {
 502     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 503     FIXME("(%p)->(%d %p)\n", This, output_num, language_count);
 504     return E_NOTIMPL;
 505 }
 506
 507 static HRESULT WINAPI WMReaderAdvanced4_GetLanguage(IWMReaderAdvanced6 *iface, DWORD output_num,
 508        WORD language, WCHAR *language_string, WORD *language_string_len)
 509 {
 510     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 511     FIXME("(%p)->(%d %x %p %p)\n", This, output_num, language, language_string, language_string_len);
 512     return E_NOTIMPL;
 513 }
 514
 515 static HRESULT WINAPI WMReaderAdvanced4_GetMaxSpeedFactor(IWMReaderAdvanced6 *iface, double *factor)
 516 {
 517     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 518     FIXME("(%p)->(%p)\n", This, factor);
 519     return E_NOTIMPL;
 520 }
 521
 522 static HRESULT WINAPI WMReaderAdvanced4_IsUsingFastCache(IWMReaderAdvanced6 *iface, BOOL *using_fast_cache)
 523 {
 524     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 525     FIXME("(%p)->(%p)\n", This, using_fast_cache);
 526     return E_NOTIMPL;
 527 }
 528
 529 static HRESULT WINAPI WMReaderAdvanced4_AddLogParam(IWMReaderAdvanced6 *iface, const WCHAR *namespace,
 530         const WCHAR *name, const WCHAR *value)
 531 {
 532     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 533     FIXME("(%p)->(%s %s %s)\n", This, debugstr_w(namespace), debugstr_w(name), debugstr_w(value));
 534     return E_NOTIMPL;
 535 }
 536
 537 static HRESULT WINAPI WMReaderAdvanced4_SendLogParams(IWMReaderAdvanced6 *iface)
 538 {
 539     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 540     FIXME("(%p)\n", This);
 541     return E_NOTIMPL;
 542 }
 543
 544 static HRESULT WINAPI WMReaderAdvanced4_CanSaveFileAs(IWMReaderAdvanced6 *iface, BOOL *can_save)
 545 {
 546     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 547     FIXME("(%p)->(%p)\n", This, can_save);
 548     return E_NOTIMPL;
 549 }
 550
 551 static HRESULT WINAPI WMReaderAdvanced4_CancelSaveFileAs(IWMReaderAdvanced6 *iface)
 552 {
 553     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 554     FIXME("(%p)\n", This);
 555     return E_NOTIMPL;
 556 }
 557
 558 static HRESULT WINAPI WMReaderAdvanced4_GetURL(IWMReaderAdvanced6 *iface, WCHAR *url, DWORD *url_len)
 559 {
 560     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 561     FIXME("(%p)->(%p %p)\n", This, url, url_len);
 562     return E_NOTIMPL;
 563 }
 564
 565 static HRESULT WINAPI WMReaderAdvanced5_SetPlayerHook(IWMReaderAdvanced6 *iface, DWORD output_num, IWMPlayerHook *hook)
 566 {
 567     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 568     FIXME("(%p)->(%d %p)\n", This, output_num, hook);
 569     return E_NOTIMPL;
 570 }
 571
 572 static HRESULT WINAPI WMReaderAdvanced6_SetProtectStreamSamples(IWMReaderAdvanced6 *iface, BYTE *cert,
 573         DWORD cert_size, DWORD cert_type, DWORD flags, BYTE *initialization_vector, DWORD *initialization_vector_size)
 574 {
 575     struct async_reader *This = impl_from_IWMReaderAdvanced6(iface);
 576     FIXME("(%p)->(%p %d %d %x %p %p)\n", This, cert, cert_size, cert_type, flags, initialization_vector,
 577           initialization_vector_size);
 578     return E_NOTIMPL;
 579 }
 580
 581 static const IWMReaderAdvanced6Vtbl WMReaderAdvanced6Vtbl = {
 582     WMReaderAdvanced_QueryInterface,
 583     WMReaderAdvanced_AddRef,
 584     WMReaderAdvanced_Release,
 585     WMReaderAdvanced_SetUserProvidedClock,
 586     WMReaderAdvanced_GetUserProvidedClock,
 587     WMReaderAdvanced_DeliverTime,
 588     WMReaderAdvanced_SetManualStreamSelection,
 589     WMReaderAdvanced_GetManualStreamSelection,
 590     WMReaderAdvanced_SetStreamsSelected,
 591     WMReaderAdvanced_GetStreamSelected,
 592     WMReaderAdvanced_SetReceiveSelectionCallbacks,
 593     WMReaderAdvanced_GetReceiveSelectionCallbacks,
 594     WMReaderAdvanced_SetReceiveStreamSamples,
 595     WMReaderAdvanced_GetReceiveStreamSamples,
 596     WMReaderAdvanced_SetAllocateForOutput,
 597     WMReaderAdvanced_GetAllocateForOutput,
 598     WMReaderAdvanced_SetAllocateForStream,
 599     WMReaderAdvanced_GetAllocateForStream,
 600     WMReaderAdvanced_GetStatistics,
 601     WMReaderAdvanced_SetClientInfo,
 602     WMReaderAdvanced_GetMaxOutputSampleSize,
 603     WMReaderAdvanced_GetMaxStreamSampleSize,
 604     WMReaderAdvanced_NotifyLateDelivery,
 605     WMReaderAdvanced2_SetPlayMode,
 606     WMReaderAdvanced2_GetPlayMode,
 607     WMReaderAdvanced2_GetBufferProgress,
 608     WMReaderAdvanced2_GetDownloadProgress,
 609     WMReaderAdvanced2_GetSaveAsProgress,
 610     WMReaderAdvanced2_SaveFileAs,
 611     WMReaderAdvanced2_GetProtocolName,
 612     WMReaderAdvanced2_StartAtMarker,
 613     WMReaderAdvanced2_GetOutputSetting,
 614     WMReaderAdvanced2_SetOutputSetting,
 615     WMReaderAdvanced2_Preroll,
 616     WMReaderAdvanced2_SetLogClientID,
 617     WMReaderAdvanced2_GetLogClientID,
 618     WMReaderAdvanced2_StopBuffering,
 619     WMReaderAdvanced2_OpenStream,
 620     WMReaderAdvanced3_StopNetStreaming,
 621     WMReaderAdvanced3_StartAtPosition,
 622     WMReaderAdvanced4_GetLanguageCount,
 623     WMReaderAdvanced4_GetLanguage,
 624     WMReaderAdvanced4_GetMaxSpeedFactor,
 625     WMReaderAdvanced4_IsUsingFastCache,
 626     WMReaderAdvanced4_AddLogParam,
 627     WMReaderAdvanced4_SendLogParams,
 628     WMReaderAdvanced4_CanSaveFileAs,
 629     WMReaderAdvanced4_CancelSaveFileAs,
 630     WMReaderAdvanced4_GetURL,
 631     WMReaderAdvanced5_SetPlayerHook,
 632     WMReaderAdvanced6_SetProtectStreamSamples
 633 };
 634
 635 static struct async_reader *impl_from_IWMReaderAccelerator(IWMReaderAccelerator *iface)
 636 {
 637     return CONTAINING_RECORD(iface, struct async_reader, IWMReaderAccelerator_iface);
 638 }
 639
 640 static HRESULT WINAPI reader_accl_QueryInterface(IWMReaderAccelerator *iface, REFIID riid, void **object)
 641 {
 642     struct async_reader *This = impl_from_IWMReaderAccelerator(iface);
 643     return IWMReader_QueryInterface(&This->IWMReader_iface, riid, object);
 644 }
 645
 646 static ULONG WINAPI reader_accl_AddRef(IWMReaderAccelerator *iface)
 647 {
 648     struct async_reader *This = impl_from_IWMReaderAccelerator(iface);
 649     return IWMReader_AddRef(&This->IWMReader_iface);
 650 }
 651
 652 static ULONG WINAPI reader_accl_Release(IWMReaderAccelerator *iface)
 653 {
 654     struct async_reader *This = impl_from_IWMReaderAccelerator(iface);
 655     return IWMReader_Release(&This->IWMReader_iface);
 656 }
 657
 658 static HRESULT WINAPI reader_accl_GetCodecInterface(IWMReaderAccelerator *iface, DWORD output, REFIID riid, void **codec)
 659 {
 660     struct async_reader *This = impl_from_IWMReaderAccelerator(iface);
 661
 662     FIXME("%p, %d, %s, %p\n", This, output, debugstr_guid(riid), codec);
 663
 664     return E_NOTIMPL;
 665 }
 666
 667 static HRESULT WINAPI reader_accl_Notify(IWMReaderAccelerator *iface, DWORD output, WM_MEDIA_TYPE *subtype)
 668 {
 669     struct async_reader *This = impl_from_IWMReaderAccelerator(iface);
 670
 671     FIXME("%p, %d, %p\n", This, output, subtype);
 672
 673     return E_NOTIMPL;
 674 }
 675
 676 static const IWMReaderAcceleratorVtbl WMReaderAcceleratorVtbl = {
 677     reader_accl_QueryInterface,
 678     reader_accl_AddRef,
 679     reader_accl_Release,
 680     reader_accl_GetCodecInterface,
 681     reader_accl_Notify
 682 };
 683
 684 static struct async_reader *impl_from_IWMReaderNetworkConfig2(IWMReaderNetworkConfig2 *iface)
 685 {
 686     return CONTAINING_RECORD(iface, struct async_reader, IWMReaderNetworkConfig2_iface);
 687 }
 688
 689 static HRESULT WINAPI networkconfig_QueryInterface(IWMReaderNetworkConfig2 *iface, REFIID riid, void **ppv)
 690 {
 691     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
 692     return IWMReader_QueryInterface(&This->IWMReader_iface, riid, ppv);
 693 }
 694
 695 static ULONG WINAPI networkconfig_AddRef(IWMReaderNetworkConfig2 *iface)
 696 {
 697     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
 698     return IWMReader_AddRef(&This->IWMReader_iface);
 699 }
 700
 701 static ULONG WINAPI networkconfig_Release(IWMReaderNetworkConfig2 *iface)
 702 {
 703     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
 704     return IWMReader_Release(&This->IWMReader_iface);
 705 }
 706
 707 static HRESULT WINAPI networkconfig_GetBufferingTime(IWMReaderNetworkConfig2 *iface, QWORD *buffering_time)
 708 {
 709     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
 710     FIXME("%p, %p\n", This, buffering_time);
 711     return E_NOTIMPL;
 712 }
 713
 714 static HRESULT WINAPI networkconfig_SetBufferingTime(IWMReaderNetworkConfig2 *iface, QWORD buffering_time)
 715 {
 716     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
 717     FIXME("%p, %s\n", This, wine_dbgstr_longlong(buffering_time));
 718     return E_NOTIMPL;
 719 }
 720
 721 static HRESULT WINAPI networkconfig_GetUDPPortRanges(IWMReaderNetworkConfig2 *iface, WM_PORT_NUMBER_RANGE *array,
 722         DWORD *ranges)
 723 {
 724     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
 725     FIXME("%p, %p, %p\n", This, array, ranges);
 726     return E_NOTIMPL;
 727 }
 728
 729 static HRESULT WINAPI networkconfig_SetUDPPortRanges(IWMReaderNetworkConfig2 *iface, WM_PORT_NUMBER_RANGE *array,
 730         DWORD ranges)
 731 {
 732     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
 733     FIXME("%p, %p, %u\n", This, array, ranges);
 734     return E_NOTIMPL;
 735 }
 736
 737 static HRESULT WINAPI networkconfig_GetProxySettings(IWMReaderNetworkConfig2 *iface, const WCHAR *protocol,
 738         WMT_PROXY_SETTINGS *proxy)
 739 {
 740     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
 741     FIXME("%p, %s, %p\n", This, debugstr_w(protocol), proxy);
 742     return E_NOTIMPL;
 743 }
 744
 745 static HRESULT WINAPI networkconfig_SetProxySettings(IWMReaderNetworkConfig2 *iface, LPCWSTR protocol,
 746         WMT_PROXY_SETTINGS proxy)
 747 {
 748     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
 749     FIXME("%p, %s, %d\n", This, debugstr_w(protocol), proxy);
 750     return E_NOTIMPL;
 751 }
 752
 753 static HRESULT WINAPI networkconfig_GetProxyHostName(IWMReaderNetworkConfig2 *iface, const WCHAR *protocol,
 754         WCHAR *hostname, DWORD *size)
 755 {
 756     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
 757     FIXME("%p, %s, %p, %p\n", This, debugstr_w(protocol), hostname, size);
 758     return E_NOTIMPL;
 759 }
 760
 761 static HRESULT WINAPI networkconfig_SetProxyHostName(IWMReaderNetworkConfig2 *iface, const WCHAR *protocol,
 762         const WCHAR *hostname)
 763 {
 764     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
 765     FIXME("%p, %s, %s\n", This, debugstr_w(protocol), debugstr_w(hostname));
 766     return E_NOTIMPL;
 767 }
 768
 769 static HRESULT WINAPI networkconfig_GetProxyPort(IWMReaderNetworkConfig2 *iface, const WCHAR *protocol,
 770         DWORD *port)
 771 {
 772     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
 773     FIXME("%p, %s, %p\n", This, debugstr_w(protocol), port);
 774     return E_NOTIMPL;
 775 }
 776
 777 static HRESULT WINAPI networkconfig_SetProxyPort(IWMReaderNetworkConfig2 *iface, const WCHAR *protocol,
 778         DWORD port)
 779 {
 780     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
 781     FIXME("%p, %s, %u\n", This, debugstr_w(protocol), port);
 782     return E_NOTIMPL;
 783 }
 784
 785 static HRESULT WINAPI networkconfig_GetProxyExceptionList(IWMReaderNetworkConfig2 *iface, const WCHAR *protocol,
 786         WCHAR *exceptions, DWORD *count)
 787 {
 788     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
 789     FIXME("%p, %s, %p, %p\n", This, debugstr_w(protocol), exceptions, count);
 790     return E_NOTIMPL;
 791 }
 792
 793 static HRESULT WINAPI networkconfig_SetProxyExceptionList(IWMReaderNetworkConfig2 *iface, const WCHAR *protocol,
 794         const WCHAR *exceptions)
 795 {
 796     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
 797     FIXME("%p, %s, %s\n", This, debugstr_w(protocol), debugstr_w(exceptions));
 798     return E_NOTIMPL;
 799 }
 800
 801 static HRESULT WINAPI networkconfig_GetProxyBypassForLocal(IWMReaderNetworkConfig2 *iface, const WCHAR *protocol,
 802         BOOL *bypass)
 803 {
 804     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
 805     FIXME("%p, %s, %p\n", This, debugstr_w(protocol), bypass);
 806     return E_NOTIMPL;
 807 }
 808
 809 static HRESULT WINAPI networkconfig_SetProxyBypassForLocal(IWMReaderNetworkConfig2 *iface, const WCHAR *protocol,
 810         BOOL bypass)
 811 {
 812     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
 813     FIXME("%p, %s, %d\n", This, debugstr_w(protocol), bypass);
 814     return E_NOTIMPL;
 815 }
 816
 817 static HRESULT WINAPI networkconfig_GetForceRerunAutoProxyDetection(IWMReaderNetworkConfig2 *iface,
 818         BOOL *detection)
 819 {
 820     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
 821     FIXME("%p, %p\n", This, detection);
 822     return E_NOTIMPL;
 823 }
 824
 825 static HRESULT WINAPI networkconfig_SetForceRerunAutoProxyDetection(IWMReaderNetworkConfig2 *iface,
 826         BOOL detection)
 827 {
 828     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
 829     FIXME("%p, %d\n", This, detection);
 830     return E_NOTIMPL;
 831 }
 832
 833 static HRESULT WINAPI networkconfig_GetEnableMulticast(IWMReaderNetworkConfig2 *iface, BOOL *multicast)
 834 {
 835     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
 836     FIXME("%p, %p\n", This, multicast);
 837     return E_NOTIMPL;
 838 }
 839
 840 static HRESULT WINAPI networkconfig_SetEnableMulticast(IWMReaderNetworkConfig2 *iface, BOOL multicast)
 841 {
 842     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
 843     FIXME("%p, %d\n", This, multicast);
 844     return E_NOTIMPL;
 845 }
 846
 847 static HRESULT WINAPI networkconfig_GetEnableHTTP(IWMReaderNetworkConfig2 *iface, BOOL *enable)
 848 {
 849     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
 850     FIXME("%p, %p\n", This, enable);
 851     return E_NOTIMPL;
 852 }
 853
 854 static HRESULT WINAPI networkconfig_SetEnableHTTP(IWMReaderNetworkConfig2 *iface, BOOL enable)
 855 {
 856     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
 857     FIXME("%p, %d\n", This, enable);
 858     return E_NOTIMPL;
 859 }
 860
 861 static HRESULT WINAPI networkconfig_GetEnableUDP(IWMReaderNetworkConfig2 *iface, BOOL *enable)
 862 {
 863     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
 864     FIXME("%p, %p\n", This, enable);
 865     return E_NOTIMPL;
 866 }
 867
 868 static HRESULT WINAPI networkconfig_SetEnableUDP(IWMReaderNetworkConfig2 *iface, BOOL enable)
 869 {
 870     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
 871     FIXME("%p, %d\n", This, enable);
 872     return E_NOTIMPL;
 873 }
 874
 875 static HRESULT WINAPI networkconfig_GetEnableTCP(IWMReaderNetworkConfig2 *iface, BOOL *enable)
 876 {
 877     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
 878     FIXME("%p, %p\n", This, enable);
 879     return E_NOTIMPL;
 880 }
 881
 882 static HRESULT WINAPI networkconfig_SetEnableTCP(IWMReaderNetworkConfig2 *iface, BOOL enable)
 883 {
 884     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
 885     FIXME("%p, %d\n", This, enable);
 886     return E_NOTIMPL;
 887 }
 888
 889 static HRESULT WINAPI networkconfig_ResetProtocolRollover(IWMReaderNetworkConfig2 *iface)
 890 {
 891     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
 892     FIXME("%p\n", This);
 893     return E_NOTIMPL;
 894 }
 895
 896 static HRESULT WINAPI networkconfig_GetConnectionBandwidth(IWMReaderNetworkConfig2 *iface, DWORD *bandwidth)
 897 {
 898     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
 899     FIXME("%p, %p\n", This, bandwidth);
 900     return E_NOTIMPL;
 901 }
 902
 903 static HRESULT WINAPI networkconfig_SetConnectionBandwidth(IWMReaderNetworkConfig2 *iface, DWORD bandwidth)
 904 {
 905     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
 906     FIXME("%p, %u\n", This, bandwidth);
 907     return E_NOTIMPL;
 908 }
 909
 910 static HRESULT WINAPI networkconfig_GetNumProtocolsSupported(IWMReaderNetworkConfig2 *iface, DWORD *protocols)
 911 {
 912     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
 913     FIXME("%p, %p\n", This, protocols);
 914     return E_NOTIMPL;
 915 }
 916
 917 static HRESULT WINAPI networkconfig_GetSupportedProtocolName(IWMReaderNetworkConfig2 *iface, DWORD protocol_num,
 918         WCHAR *protocol, DWORD *size)
 919 {
 920     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
 921     FIXME("%p, %u, %p %p\n", This, protocol_num, protocol, size);
 922     return E_NOTIMPL;
 923 }
 924
 925 static HRESULT WINAPI networkconfig_AddLoggingUrl(IWMReaderNetworkConfig2 *iface, const WCHAR *url)
 926 {
 927     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
 928     FIXME("%p, %s\n", This, debugstr_w(url));
 929     return E_NOTIMPL;
 930 }
 931
 932 static HRESULT WINAPI networkconfig_GetLoggingUrl(IWMReaderNetworkConfig2 *iface, DWORD index, WCHAR *url,
 933         DWORD *size)
 934 {
 935     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
 936     FIXME("%p, %u, %p, %p\n", This, index, url, size);
 937     return E_NOTIMPL;
 938 }
 939
 940 static HRESULT WINAPI networkconfig_GetLoggingUrlCount(IWMReaderNetworkConfig2 *iface, DWORD *count)
 941 {
 942     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
 943     FIXME("%p, %p\n", This, count);
 944     return E_NOTIMPL;
 945 }
 946
 947 static HRESULT WINAPI networkconfig_ResetLoggingUrlList(IWMReaderNetworkConfig2 *iface)
 948 {
 949     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
 950     FIXME("%p\n", This);
 951     return E_NOTIMPL;
 952 }
 953
 954 static HRESULT WINAPI networkconfig_GetEnableContentCaching(IWMReaderNetworkConfig2 *iface, BOOL *enable)
 955 {
 956     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
 957     FIXME("%p, %p\n", This, enable);
 958     return E_NOTIMPL;
 959 }
 960
 961 static HRESULT WINAPI networkconfig_SetEnableContentCaching(IWMReaderNetworkConfig2 *iface, BOOL enable)
 962 {
 963     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
 964     FIXME("%p, %d\n", This, enable);
 965     return E_NOTIMPL;
 966 }
 967
 968 static HRESULT WINAPI networkconfig_GetEnableFastCache(IWMReaderNetworkConfig2 *iface, BOOL *enable)
 969 {
 970     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
 971     FIXME("%p, %p\n", This, enable);
 972     return E_NOTIMPL;
 973 }
 974
 975 static HRESULT WINAPI networkconfig_SetEnableFastCache(IWMReaderNetworkConfig2 *iface, BOOL enable)
 976 {
 977     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
 978     FIXME("%p, %d\n", This, enable);
 979     return E_NOTIMPL;
 980 }
 981
 982 static HRESULT WINAPI networkconfig_GetAcceleratedStreamingDuration(IWMReaderNetworkConfig2 *iface,
 983         QWORD *duration)
 984 {
 985     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
 986     FIXME("%p, %p\n", This, duration);
 987     return E_NOTIMPL;
 988 }
 989
 990 static HRESULT WINAPI networkconfig_SetAcceleratedStreamingDuration(IWMReaderNetworkConfig2 *iface,
 991         QWORD duration)
 992 {
 993     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
 994     FIXME("%p, %s\n", This, wine_dbgstr_longlong(duration));
 995     return E_NOTIMPL;
 996 }
 997
 998 static HRESULT WINAPI networkconfig_GetAutoReconnectLimit(IWMReaderNetworkConfig2 *iface, DWORD *limit)
 999 {
1000     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
1001     FIXME("%p, %p\n", This, limit);
1002     return E_NOTIMPL;
1003 }
1004
1005 static HRESULT WINAPI networkconfig_SetAutoReconnectLimit(IWMReaderNetworkConfig2 *iface, DWORD limit)
1006 {
1007     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
1008     FIXME("%p, %u\n", This, limit);
1009     return E_NOTIMPL;
1010 }
1011
1012 static HRESULT WINAPI networkconfig_GetEnableResends(IWMReaderNetworkConfig2 *iface, BOOL *enable)
1013 {
1014     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
1015     FIXME("%p, %p\n", This, enable);
1016     return E_NOTIMPL;
1017 }
1018
1019 static HRESULT WINAPI networkconfig_SetEnableResends(IWMReaderNetworkConfig2 *iface, BOOL enable)
1020 {
1021     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
1022     FIXME("%p, %u\n", This, enable);
1023     return E_NOTIMPL;
1024 }
1025
1026 static HRESULT WINAPI networkconfig_GetEnableThinning(IWMReaderNetworkConfig2 *iface, BOOL *enable)
1027 {
1028     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
1029     FIXME("%p, %p\n", This, enable);
1030     return E_NOTIMPL;
1031 }
1032
1033 static HRESULT WINAPI networkconfig_SetEnableThinning(IWMReaderNetworkConfig2 *iface, BOOL enable)
1034 {
1035     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
1036     FIXME("%p, %u\n", This, enable);
1037     return E_NOTIMPL;
1038 }
1039
1040 static HRESULT WINAPI networkconfig_GetMaxNetPacketSize(IWMReaderNetworkConfig2 *iface, DWORD *packet_size)
1041 {
1042     struct async_reader *This = impl_from_IWMReaderNetworkConfig2(iface);
1043     FIXME("%p, %p\n", This, packet_size);
1044     return E_NOTIMPL;
1045 }
1046
1047 static const IWMReaderNetworkConfig2Vtbl WMReaderNetworkConfig2Vtbl =
1048 {
1049     networkconfig_QueryInterface,
1050     networkconfig_AddRef,
1051     networkconfig_Release,
1052     networkconfig_GetBufferingTime,
1053     networkconfig_SetBufferingTime,
1054     networkconfig_GetUDPPortRanges,
1055     networkconfig_SetUDPPortRanges,
1056     networkconfig_GetProxySettings,
1057     networkconfig_SetProxySettings,
1058     networkconfig_GetProxyHostName,
1059     networkconfig_SetProxyHostName,
1060     networkconfig_GetProxyPort,
1061     networkconfig_SetProxyPort,
1062     networkconfig_GetProxyExceptionList,
1063     networkconfig_SetProxyExceptionList,
1064     networkconfig_GetProxyBypassForLocal,
1065     networkconfig_SetProxyBypassForLocal,
1066     networkconfig_GetForceRerunAutoProxyDetection,
1067     networkconfig_SetForceRerunAutoProxyDetection,
1068     networkconfig_GetEnableMulticast,
1069     networkconfig_SetEnableMulticast,
1070     networkconfig_GetEnableHTTP,
1071     networkconfig_SetEnableHTTP,
1072     networkconfig_GetEnableUDP,
1073     networkconfig_SetEnableUDP,
1074     networkconfig_GetEnableTCP,
1075     networkconfig_SetEnableTCP,
1076     networkconfig_ResetProtocolRollover,
1077     networkconfig_GetConnectionBandwidth,
1078     networkconfig_SetConnectionBandwidth,
1079     networkconfig_GetNumProtocolsSupported,
1080     networkconfig_GetSupportedProtocolName,
1081     networkconfig_AddLoggingUrl,
1082     networkconfig_GetLoggingUrl,
1083     networkconfig_GetLoggingUrlCount,
1084     networkconfig_ResetLoggingUrlList,
1085     networkconfig_GetEnableContentCaching,
1086     networkconfig_SetEnableContentCaching,
1087     networkconfig_GetEnableFastCache,
1088     networkconfig_SetEnableFastCache,
1089     networkconfig_GetAcceleratedStreamingDuration,
1090     networkconfig_SetAcceleratedStreamingDuration,
1091     networkconfig_GetAutoReconnectLimit,
1092     networkconfig_SetAutoReconnectLimit,
1093     networkconfig_GetEnableResends,
1094     networkconfig_SetEnableResends,
1095     networkconfig_GetEnableThinning,
1096     networkconfig_SetEnableThinning,
1097     networkconfig_GetMaxNetPacketSize
1098 };
1099
1100 static struct async_reader *impl_from_IWMReaderStreamClock(IWMReaderStreamClock *iface)
1101 {
1102     return CONTAINING_RECORD(iface, struct async_reader, IWMReaderStreamClock_iface);
1103 }
1104
1105 static HRESULT WINAPI readclock_QueryInterface(IWMReaderStreamClock *iface, REFIID riid, void **ppv)
1106 {
1107     struct async_reader *This = impl_from_IWMReaderStreamClock(iface);
1108     return IWMReader_QueryInterface(&This->IWMReader_iface, riid, ppv);
1109 }
1110
1111 static ULONG WINAPI readclock_AddRef(IWMReaderStreamClock *iface)
1112 {
1113     struct async_reader *This = impl_from_IWMReaderStreamClock(iface);
1114     return IWMReader_AddRef(&This->IWMReader_iface);
1115 }
1116
1117 static ULONG WINAPI readclock_Release(IWMReaderStreamClock *iface)
1118 {
1119     struct async_reader *This = impl_from_IWMReaderStreamClock(iface);
1120     return IWMReader_Release(&This->IWMReader_iface);
1121 }
1122
1123 static HRESULT WINAPI readclock_GetTime(IWMReaderStreamClock *iface, QWORD *now)
1124 {
1125     struct async_reader *This = impl_from_IWMReaderStreamClock(iface);
1126     FIXME("%p, %p\n", This, now);
1127     return E_NOTIMPL;
1128 }
1129
1130 static HRESULT WINAPI readclock_SetTimer(IWMReaderStreamClock *iface, QWORD when, void *param, DWORD *id)
1131 {
1132     struct async_reader *This = impl_from_IWMReaderStreamClock(iface);
1133     FIXME("%p, %s, %p, %p\n", This, wine_dbgstr_longlong(when), param, id);
1134     return E_NOTIMPL;
1135 }
1136
1137 static HRESULT WINAPI readclock_KillTimer(IWMReaderStreamClock *iface, DWORD id)
1138 {
1139     struct async_reader *This = impl_from_IWMReaderStreamClock(iface);
1140     FIXME("%p, %d\n", This, id);
1141     return E_NOTIMPL;
1142 }
1143
1144 static const IWMReaderStreamClockVtbl WMReaderStreamClockVtbl =
1145 {
1146     readclock_QueryInterface,
1147     readclock_AddRef,
1148     readclock_Release,
1149     readclock_GetTime,
1150     readclock_SetTimer,
1151     readclock_KillTimer
1152 };
1153
1154 static struct async_reader *impl_from_IWMReaderTypeNegotiation(IWMReaderTypeNegotiation *iface)
1155 {
1156     return CONTAINING_RECORD(iface, struct async_reader, IWMReaderTypeNegotiation_iface);
1157 }
1158
1159 static HRESULT WINAPI negotiation_QueryInterface(IWMReaderTypeNegotiation *iface, REFIID riid, void **ppv)
1160 {
1161     struct async_reader *This = impl_from_IWMReaderTypeNegotiation(iface);
1162     return IWMReader_QueryInterface(&This->IWMReader_iface, riid, ppv);
1163 }
1164
1165 static ULONG WINAPI negotiation_AddRef(IWMReaderTypeNegotiation *iface)
1166 {
1167     struct async_reader *This = impl_from_IWMReaderTypeNegotiation(iface);
1168     return IWMReader_AddRef(&This->IWMReader_iface);
1169 }
1170
1171 static ULONG WINAPI negotiation_Release(IWMReaderTypeNegotiation *iface)
1172 {
1173     struct async_reader *This = impl_from_IWMReaderTypeNegotiation(iface);
1174     return IWMReader_Release(&This->IWMReader_iface);
1175 }
1176
1177 static HRESULT WINAPI negotiation_TryOutputProps(IWMReaderTypeNegotiation *iface, DWORD output, IWMOutputMediaProps *props)
1178 {
1179     struct async_reader *This = impl_from_IWMReaderTypeNegotiation(iface);
1180     FIXME("%p, %d, %p\n", This, output, props);
1181     return E_NOTIMPL;
1182 }
1183
1184 static const IWMReaderTypeNegotiationVtbl WMReaderTypeNegotiationVtbl =
1185 {
1186     negotiation_QueryInterface,
1187     negotiation_AddRef,
1188     negotiation_Release,
1189     negotiation_TryOutputProps
1190 };
1191
1192 static struct async_reader *impl_from_IReferenceClock(IReferenceClock *iface)
1193 {
1194     return CONTAINING_RECORD(iface, struct async_reader, IReferenceClock_iface);
1195 }
1196
1197 static HRESULT WINAPI refclock_QueryInterface(IReferenceClock *iface, REFIID riid, void **ppv)
1198 {
1199     struct async_reader *This = impl_from_IReferenceClock(iface);
1200     return IWMReader_QueryInterface(&This->IWMReader_iface, riid, ppv);
1201 }
1202
1203 static ULONG WINAPI refclock_AddRef(IReferenceClock *iface)
1204 {
1205     struct async_reader *This = impl_from_IReferenceClock(iface);
1206     return IWMReader_AddRef(&This->IWMReader_iface);
1207 }
1208
1209 static ULONG WINAPI refclock_Release(IReferenceClock *iface)
1210 {
1211     struct async_reader *This = impl_from_IReferenceClock(iface);
1212     return IWMReader_Release(&This->IWMReader_iface);
1213 }
1214
1215 static HRESULT WINAPI refclock_GetTime(IReferenceClock *iface, REFERENCE_TIME *time)
1216 {
1217     struct async_reader *This = impl_from_IReferenceClock(iface);
1218     FIXME("%p, %p\n", This, time);
1219     return E_NOTIMPL;
1220 }
1221
1222 static HRESULT WINAPI refclock_AdviseTime(IReferenceClock *iface, REFERENCE_TIME basetime,
1223         REFERENCE_TIME streamtime, HEVENT event, DWORD_PTR *cookie)
1224 {
1225     struct async_reader *This = impl_from_IReferenceClock(iface);
1226     FIXME("%p, %s, %s, %lu, %p\n", This, wine_dbgstr_longlong(basetime),
1227             wine_dbgstr_longlong(streamtime), event, cookie);
1228     return E_NOTIMPL;
1229 }
1230
1231 static HRESULT WINAPI refclock_AdvisePeriodic(IReferenceClock *iface, REFERENCE_TIME starttime,
1232         REFERENCE_TIME period, HSEMAPHORE semaphore, DWORD_PTR *cookie)
1233 {
1234     struct async_reader *This = impl_from_IReferenceClock(iface);
1235     FIXME("%p, %s, %s, %lu, %p\n", This, wine_dbgstr_longlong(starttime),
1236             wine_dbgstr_longlong(period), semaphore, cookie);
1237     return E_NOTIMPL;
1238 }
1239
1240 static HRESULT WINAPI refclock_Unadvise(IReferenceClock *iface, DWORD_PTR cookie)
1241 {
1242     struct async_reader *This = impl_from_IReferenceClock(iface);
1243     FIXME("%p, %lu\n", This, cookie);
1244     return E_NOTIMPL;
1245 }
1246
1247 static const IReferenceClockVtbl ReferenceClockVtbl =
1248 {
1249     refclock_QueryInterface,
1250     refclock_AddRef,
1251     refclock_Release,
1252     refclock_GetTime,
1253     refclock_AdviseTime,
1254     refclock_AdvisePeriodic,
1255     refclock_Unadvise
1256 };
1257
1258 static struct async_reader *impl_from_wm_reader(struct wm_reader *iface)
1259 {
1260     return CONTAINING_RECORD(iface, struct async_reader, reader);
1261 }
1262
1263 static void *async_reader_query_interface(struct wm_reader *iface, REFIID iid)
1264 {
1265     struct async_reader *reader = impl_from_wm_reader(iface);
1266
1267     TRACE("reader %p, iid %s.\n", reader, debugstr_guid(iid));
1268
1269     if (IsEqualIID(iid, &IID_IReferenceClock))
1270         return &reader->IReferenceClock_iface;
1271
1272     if (IsEqualIID(iid, &IID_IWMReader))
1273         return &reader->IWMReader_iface;
1274
1275     if (IsEqualIID(iid, &IID_IWMReaderAccelerator))
1276         return &reader->IWMReaderAccelerator_iface;
1277
1278     if (IsEqualIID(iid, &IID_IWMReaderAdvanced)
1279             || IsEqualIID(iid, &IID_IWMReaderAdvanced2)
1280             || IsEqualIID(iid, &IID_IWMReaderAdvanced3)
1281             || IsEqualIID(iid, &IID_IWMReaderAdvanced4)
1282             || IsEqualIID(iid, &IID_IWMReaderAdvanced5)
1283             || IsEqualIID(iid, &IID_IWMReaderAdvanced6))
1284         return &reader->IWMReaderAdvanced6_iface;
1285
1286     if (IsEqualIID(iid, &IID_IWMReaderNetworkConfig)
1287             || IsEqualIID(iid, &IID_IWMReaderNetworkConfig2))
1288         return &reader->IWMReaderNetworkConfig2_iface;
1289
1290     if (IsEqualIID(iid, &IID_IWMReaderStreamClock))
1291         return &reader->IWMReaderStreamClock_iface;
1292
1293     if (IsEqualIID(iid, &IID_IWMReaderTypeNegotiation))
1294         return &reader->IWMReaderTypeNegotiation_iface;
1295
1296     return NULL;
1297 }
1298
1299 static void async_reader_destroy(struct wm_reader *iface)
1300 {
1301     struct async_reader *reader = impl_from_wm_reader(iface);
1302
1303     TRACE("reader %p.\n", reader);
1304
1305     wm_reader_close(&reader->reader);
1306
1307     if (reader->callback)
1308         IWMReaderCallback_Release(reader->callback);
1309
1310     wm_reader_cleanup(&reader->reader);
1311     free(reader);
1312 }
1313
1314 static const struct wm_reader_ops async_reader_ops =
1315 {
1316     .query_interface = async_reader_query_interface,
1317     .destroy = async_reader_destroy,
1318 };
1319
1320 HRESULT WINAPI winegstreamer_create_wm_async_reader(IWMReader **reader)
1321 {
1322     struct async_reader *object;
1323
1324     TRACE("reader %p.\n", reader);
1325
1326     if (!(object = calloc(1, sizeof(*object))))
1327         return E_OUTOFMEMORY;
1328
1329     wm_reader_init(&object->reader, &async_reader_ops);
1330
1331     object->IReferenceClock_iface.lpVtbl = &ReferenceClockVtbl;
1332     object->IWMReader_iface.lpVtbl = &WMReaderVtbl;
1333     object->IWMReaderAdvanced6_iface.lpVtbl = &WMReaderAdvanced6Vtbl;
1334     object->IWMReaderAccelerator_iface.lpVtbl = &WMReaderAcceleratorVtbl;
1335     object->IWMReaderNetworkConfig2_iface.lpVtbl = &WMReaderNetworkConfig2Vtbl;
1336     object->IWMReaderStreamClock_iface.lpVtbl = &WMReaderStreamClockVtbl;
1337     object->IWMReaderTypeNegotiation_iface.lpVtbl = &WMReaderTypeNegotiationVtbl;
1338
1339     TRACE("Created async reader %p.\n", object);
1340     *reader = (IWMReader *)&object->IWMReader_iface;
1341     return S_OK;
1342 }