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