dlls/wmvcore/reader.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 "wmsdk.h"
  22 #include "wine/debug.h"
  23 #include "wine/heap.h"
  24
  25 WINE_DEFAULT_DEBUG_CHANNEL(wmvcore);
  26
  27 typedef struct {
  28     IWMReader IWMReader_iface;
  29     IWMReaderAdvanced6 IWMReaderAdvanced6_iface;
  30     IWMReaderAccelerator IWMReaderAccelerator_iface;
  31     IWMReaderNetworkConfig2 IWMReaderNetworkConfig2_iface;
  32     IWMReaderStreamClock IWMReaderStreamClock_iface;
  33     IWMReaderTypeNegotiation IWMReaderTypeNegotiation_iface;
  34     IWMReaderTimecode IWMReaderTimecode_iface;
  35     IWMReaderPlaylistBurn IWMReaderPlaylistBurn_iface;
  36     IWMHeaderInfo3 IWMHeaderInfo3_iface;
  37     IWMLanguageList IWMLanguageList_iface;
  38     IReferenceClock IReferenceClock_iface;
  39     IWMProfile3 IWMProfile3_iface;
  40     IWMPacketSize2 IWMPacketSize2_iface;
  41     LONG ref;
  42 } WMReader;
  43
  44 static inline WMReader *impl_from_IWMReader(IWMReader *iface)
  45 {
  46     return CONTAINING_RECORD(iface, WMReader, IWMReader_iface);
  47 }
  48
  49 static HRESULT WINAPI WMReader_QueryInterface(IWMReader *iface, REFIID riid, void **ppv)
  50 {
  51     WMReader *This = impl_from_IWMReader(iface);
  52
  53     if(IsEqualGUID(riid, &IID_IUnknown)) {
  54         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
  55         *ppv = &This->IWMReader_iface;
  56     }else if(IsEqualGUID(riid, &IID_IWMReader)) {
  57         TRACE("(%p)->(IID_IWMReader %p)\n", This, ppv);
  58         *ppv = &This->IWMReader_iface;
  59     }else if(IsEqualGUID(riid, &IID_IWMReaderAdvanced)) {
  60         TRACE("(%p)->(IID_IWMReaderAdvanced %p)\n", This, ppv);
  61         *ppv = &This->IWMReaderAdvanced6_iface;
  62     }else if(IsEqualGUID(riid, &IID_IWMReaderAdvanced2)) {
  63         TRACE("(%p)->(IID_IWMReaderAdvanced2 %p)\n", This, ppv);
  64         *ppv = &This->IWMReaderAdvanced6_iface;
  65     }else if(IsEqualGUID(riid, &IID_IWMReaderAdvanced3)) {
  66         TRACE("(%p)->(IID_IWMReaderAdvanced3 %p)\n", This, ppv);
  67         *ppv = &This->IWMReaderAdvanced6_iface;
  68     }else if(IsEqualGUID(riid, &IID_IWMReaderAdvanced4)) {
  69         TRACE("(%p)->(IID_IWMReaderAdvanced4 %p)\n", This, ppv);
  70         *ppv = &This->IWMReaderAdvanced6_iface;
  71     }else if(IsEqualGUID(riid, &IID_IWMReaderAdvanced5)) {
  72         TRACE("(%p)->(IID_IWMReaderAdvanced5 %p)\n", This, ppv);
  73         *ppv = &This->IWMReaderAdvanced6_iface;
  74     }else if(IsEqualGUID(riid, &IID_IWMReaderAdvanced6)) {
  75         TRACE("(%p)->(IID_IWMReaderAdvanced6 %p)\n", This, ppv);
  76         *ppv = &This->IWMReaderAdvanced6_iface;
  77     }else if(IsEqualGUID(riid, &IID_IWMReaderAccelerator)) {
  78         TRACE("(%p)->(IID_IWMReaderAccelerator %p)\n", This, ppv);
  79         *ppv = &This->IWMReaderAccelerator_iface;
  80     }else if(IsEqualGUID(riid, &IID_IWMReaderNetworkConfig)) {
  81         TRACE("(%p)->(IWMReaderNetworkConfig %p)\n", This, ppv);
  82         *ppv = &This->IWMReaderNetworkConfig2_iface;
  83     }else if(IsEqualGUID(riid, &IID_IWMReaderNetworkConfig2)) {
  84         TRACE("(%p)->(IWMReaderNetworkConfig2 %p)\n", This, ppv);
  85         *ppv = &This->IWMReaderNetworkConfig2_iface;
  86     }else if(IsEqualGUID(riid, &IID_IWMReaderStreamClock)) {
  87         TRACE("(%p)->(IWMReaderStreamClock %p)\n", This, ppv);
  88         *ppv = &This->IWMReaderStreamClock_iface;
  89     }else if(IsEqualGUID(riid, &IID_IWMReaderTypeNegotiation)) {
  90         TRACE("(%p)->(IWMReaderTypeNegotiation %p)\n", This, ppv);
  91         *ppv = &This->IWMReaderTypeNegotiation_iface;
  92     }else if(IsEqualGUID(riid, &IID_IWMReaderTimecode)) {
  93         TRACE("(%p)->(IWMReaderTimecode %p)\n", This, ppv);
  94         *ppv = &This->IWMReaderTimecode_iface;
  95     }else if(IsEqualGUID(riid, &IID_IWMReaderPlaylistBurn)) {
  96         TRACE("(%p)->(IWMReaderPlaylistBurn %p)\n", This, ppv);
  97         *ppv = &This->IWMReaderPlaylistBurn_iface;
  98     }else if(IsEqualGUID(riid, &IID_IWMHeaderInfo)) {
  99         TRACE("(%p)->(IWMHeaderInfo %p)\n", This, ppv);
 100         *ppv = &This->IWMHeaderInfo3_iface;
 101     }else if(IsEqualGUID(riid, &IID_IWMHeaderInfo2)) {
 102         TRACE("(%p)->(IWMHeaderInfo2 %p)\n", This, ppv);
 103         *ppv = &This->IWMHeaderInfo3_iface;
 104     }else if(IsEqualGUID(riid, &IID_IWMHeaderInfo3)) {
 105         TRACE("(%p)->(IWMHeaderInfo3 %p)\n", This, ppv);
 106         *ppv = &This->IWMHeaderInfo3_iface;
 107     }else if(IsEqualGUID(riid, &IID_IWMLanguageList)) {
 108         TRACE("(%p)->(IWMLanguageList %p)\n", This, ppv);
 109         *ppv = &This->IWMLanguageList_iface;
 110     }else if(IsEqualGUID(riid, &IID_IReferenceClock)) {
 111         TRACE("(%p)->(IWMLanguageList %p)\n", This, ppv);
 112         *ppv = &This->IReferenceClock_iface;
 113     }else if(IsEqualGUID(riid, &IID_IWMProfile)) {
 114         TRACE("(%p)->(IWMProfile %p)\n", This, ppv);
 115         *ppv = &This->IWMProfile3_iface;
 116     }else if(IsEqualGUID(riid, &IID_IWMProfile2)) {
 117         TRACE("(%p)->(IWMProfile2 %p)\n", This, ppv);
 118         *ppv = &This->IWMProfile3_iface;
 119     }else if(IsEqualGUID(riid, &IID_IWMProfile3)) {
 120         TRACE("(%p)->(IWMProfile3 %p)\n", This, ppv);
 121         *ppv = &This->IWMProfile3_iface;
 122     }else if(IsEqualGUID(riid, &IID_IWMPacketSize)) {
 123         TRACE("(%p)->(IWMPacketSize %p)\n", This, ppv);
 124         *ppv = &This->IWMPacketSize2_iface;
 125     }else if(IsEqualGUID(riid, &IID_IWMPacketSize2)) {
 126         TRACE("(%p)->(IWMPacketSize2 %p)\n", This, ppv);
 127         *ppv = &This->IWMPacketSize2_iface;
 128     }else {
 129         *ppv = NULL;
 130         FIXME("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
 131         return E_NOINTERFACE;
 132     }
 133
 134     IUnknown_AddRef((IUnknown*)*ppv);
 135     return S_OK;
 136 }
 137
 138 static ULONG WINAPI WMReader_AddRef(IWMReader *iface)
 139 {
 140     WMReader *This = impl_from_IWMReader(iface);
 141     LONG ref = InterlockedIncrement(&This->ref);
 142
 143     TRACE("(%p) ref=%d\n", This, ref);
 144
 145     return ref;
 146 }
 147
 148 static ULONG WINAPI WMReader_Release(IWMReader *iface)
 149 {
 150     WMReader *This = impl_from_IWMReader(iface);
 151     LONG ref = InterlockedDecrement(&This->ref);
 152
 153     TRACE("(%p) ref=%d\n", This, ref);
 154
 155     if(!ref)
 156         heap_free(This);
 157
 158     return ref;
 159 }
 160
 161 static HRESULT WINAPI WMReader_Open(IWMReader *iface, const WCHAR *url, IWMReaderCallback *callback, void *context)
 162 {
 163     WMReader *This = impl_from_IWMReader(iface);
 164     FIXME("(%p)->(%s %p %p)\n", This, debugstr_w(url), callback, context);
 165     return E_NOTIMPL;
 166 }
 167
 168 static HRESULT WINAPI WMReader_Close(IWMReader *iface)
 169 {
 170     WMReader *This = impl_from_IWMReader(iface);
 171     FIXME("(%p)\n", This);
 172     return E_NOTIMPL;
 173 }
 174
 175 static HRESULT WINAPI WMReader_GetOutputCount(IWMReader *iface, DWORD *outputs)
 176 {
 177     WMReader *This = impl_from_IWMReader(iface);
 178     FIXME("(%p)->(%p)\n", This, outputs);
 179
 180     if(!outputs)
 181         return E_INVALIDARG;
 182
 183     *outputs = 0;
 184     return S_OK;
 185 }
 186
 187 static HRESULT WINAPI WMReader_GetOutputProps(IWMReader *iface, DWORD output_num, IWMOutputMediaProps **output)
 188 {
 189     WMReader *This = impl_from_IWMReader(iface);
 190     FIXME("(%p)->(%u %p)\n", This, output_num, output);
 191     return E_NOTIMPL;
 192 }
 193
 194 static HRESULT WINAPI WMReader_SetOutputProps(IWMReader *iface, DWORD output_num, IWMOutputMediaProps *output)
 195 {
 196     WMReader *This = impl_from_IWMReader(iface);
 197     FIXME("(%p)->(%u %p)\n", This, output_num, output);
 198     return E_NOTIMPL;
 199 }
 200
 201 static HRESULT WINAPI WMReader_GetOutputFormatCount(IWMReader *iface, DWORD output_num, DWORD *formats)
 202 {
 203     WMReader *This = impl_from_IWMReader(iface);
 204     FIXME("(%p)->(%u %p)\n", This, output_num, formats);
 205     return E_NOTIMPL;
 206 }
 207
 208 static HRESULT WINAPI WMReader_GetOutputFormat(IWMReader *iface, DWORD output_num, DWORD format_num, IWMOutputMediaProps **props)
 209 {
 210     WMReader *This = impl_from_IWMReader(iface);
 211     FIXME("(%p)->(%u %u %p)\n", This, output_num, format_num, props);
 212     return E_NOTIMPL;
 213 }
 214
 215 static HRESULT WINAPI WMReader_Start(IWMReader *iface, QWORD start, QWORD duration, float rate, void *context)
 216 {
 217     WMReader *This = impl_from_IWMReader(iface);
 218     FIXME("(%p)->(%s %s %f %p)\n", This, wine_dbgstr_longlong(start), wine_dbgstr_longlong(duration), rate, context);
 219     return E_NOTIMPL;
 220 }
 221
 222 static HRESULT WINAPI WMReader_Stop(IWMReader *iface)
 223 {
 224     WMReader *This = impl_from_IWMReader(iface);
 225     FIXME("(%p)\n", This);
 226     return E_NOTIMPL;
 227 }
 228
 229 static HRESULT WINAPI WMReader_Pause(IWMReader *iface)
 230 {
 231     WMReader *This = impl_from_IWMReader(iface);
 232     FIXME("(%p)\n", This);
 233     return E_NOTIMPL;
 234 }
 235
 236 static HRESULT WINAPI WMReader_Resume(IWMReader *iface)
 237 {
 238     WMReader *This = impl_from_IWMReader(iface);
 239     FIXME("(%p)\n", This);
 240     return E_NOTIMPL;
 241 }
 242
 243 static const IWMReaderVtbl WMReaderVtbl = {
 244     WMReader_QueryInterface,
 245     WMReader_AddRef,
 246     WMReader_Release,
 247     WMReader_Open,
 248     WMReader_Close,
 249     WMReader_GetOutputCount,
 250     WMReader_GetOutputProps,
 251     WMReader_SetOutputProps,
 252     WMReader_GetOutputFormatCount,
 253     WMReader_GetOutputFormat,
 254     WMReader_Start,
 255     WMReader_Stop,
 256     WMReader_Pause,
 257     WMReader_Resume
 258 };
 259
 260 static inline WMReader *impl_from_IWMReaderAdvanced6(IWMReaderAdvanced6 *iface)
 261 {
 262     return CONTAINING_RECORD(iface, WMReader, IWMReaderAdvanced6_iface);
 263 }
 264
 265 static HRESULT WINAPI WMReaderAdvanced_QueryInterface(IWMReaderAdvanced6 *iface, REFIID riid, void **ppv)
 266 {
 267     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 268     return IWMReader_QueryInterface(&This->IWMReader_iface, riid, ppv);
 269 }
 270
 271 static ULONG WINAPI WMReaderAdvanced_AddRef(IWMReaderAdvanced6 *iface)
 272 {
 273     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 274     return IWMReader_AddRef(&This->IWMReader_iface);
 275 }
 276
 277 static ULONG WINAPI WMReaderAdvanced_Release(IWMReaderAdvanced6 *iface)
 278 {
 279     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 280     return IWMReader_Release(&This->IWMReader_iface);
 281 }
 282
 283 static HRESULT WINAPI WMReaderAdvanced_SetUserProvidedClock(IWMReaderAdvanced6 *iface, BOOL user_clock)
 284 {
 285     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 286     FIXME("(%p)->(%x)\n", This, user_clock);
 287     return E_NOTIMPL;
 288 }
 289
 290 static HRESULT WINAPI WMReaderAdvanced_GetUserProvidedClock(IWMReaderAdvanced6 *iface, BOOL *user_clock)
 291 {
 292     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 293     FIXME("(%p)->(%p)\n", This, user_clock);
 294     return E_NOTIMPL;
 295 }
 296
 297 static HRESULT WINAPI WMReaderAdvanced_DeliverTime(IWMReaderAdvanced6 *iface, QWORD time)
 298 {
 299     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 300     FIXME("(%p)->(%s)\n", This, wine_dbgstr_longlong(time));
 301     return E_NOTIMPL;
 302 }
 303
 304 static HRESULT WINAPI WMReaderAdvanced_SetManualStreamSelection(IWMReaderAdvanced6 *iface, BOOL selection)
 305 {
 306     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 307     FIXME("(%p)->(%x)\n", This, selection);
 308     return E_NOTIMPL;
 309 }
 310
 311 static HRESULT WINAPI WMReaderAdvanced_GetManualStreamSelection(IWMReaderAdvanced6 *iface, BOOL *selection)
 312 {
 313     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 314     FIXME("(%p)->(%p)\n", This, selection);
 315     return E_NOTIMPL;
 316 }
 317
 318 static HRESULT WINAPI WMReaderAdvanced_SetStreamsSelected(IWMReaderAdvanced6 *iface, WORD stream_count,
 319         WORD *stream_numbers, WMT_STREAM_SELECTION *selections)
 320 {
 321     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 322     FIXME("(%p)->(%d %p %p)\n", This, stream_count, stream_numbers, selections);
 323     return E_NOTIMPL;
 324 }
 325
 326 static HRESULT WINAPI WMReaderAdvanced_GetStreamSelected(IWMReaderAdvanced6 *iface, WORD stream_num,
 327         WMT_STREAM_SELECTION *selection)
 328 {
 329     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 330     FIXME("(%p)->(%d %p)\n", This, stream_num, selection);
 331     return E_NOTIMPL;
 332 }
 333
 334 static HRESULT WINAPI WMReaderAdvanced_SetReceiveSelectionCallbacks(IWMReaderAdvanced6 *iface, BOOL get_callbacks)
 335 {
 336     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 337     FIXME("(%p)->(%x)\n", This, get_callbacks);
 338     return E_NOTIMPL;
 339 }
 340
 341 static HRESULT WINAPI WMReaderAdvanced_GetReceiveSelectionCallbacks(IWMReaderAdvanced6 *iface, BOOL *get_callbacks)
 342 {
 343     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 344     FIXME("(%p)->(%p)\n", This, get_callbacks);
 345     return E_NOTIMPL;
 346 }
 347
 348 static HRESULT WINAPI WMReaderAdvanced_SetReceiveStreamSamples(IWMReaderAdvanced6 *iface, WORD stream_num,
 349         BOOL receive_stream_samples)
 350 {
 351     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 352     FIXME("(%p)->(%d %x)\n", This, stream_num, receive_stream_samples);
 353     return E_NOTIMPL;
 354 }
 355
 356 static HRESULT WINAPI WMReaderAdvanced_GetReceiveStreamSamples(IWMReaderAdvanced6 *iface, WORD stream_num,
 357         BOOL *receive_stream_samples)
 358 {
 359     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 360     FIXME("(%p)->(%d %p)\n", This, stream_num, receive_stream_samples);
 361     return E_NOTIMPL;
 362 }
 363
 364 static HRESULT WINAPI WMReaderAdvanced_SetAllocateForOutput(IWMReaderAdvanced6 *iface, DWORD output_num, BOOL allocate)
 365 {
 366     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 367     FIXME("(%p)->(%d %x)\n", This, output_num, allocate);
 368     return E_NOTIMPL;
 369 }
 370
 371 static HRESULT WINAPI WMReaderAdvanced_GetAllocateForOutput(IWMReaderAdvanced6 *iface, DWORD output_num, BOOL *allocate)
 372 {
 373     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 374     FIXME("(%p)->(%d %p)\n", This, output_num, allocate);
 375     return E_NOTIMPL;
 376 }
 377
 378 static HRESULT WINAPI WMReaderAdvanced_SetAllocateForStream(IWMReaderAdvanced6 *iface, WORD output_num, BOOL allocate)
 379 {
 380     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 381     FIXME("(%p)->(%d %x)\n", This, output_num, allocate);
 382     return E_NOTIMPL;
 383 }
 384
 385 static HRESULT WINAPI WMReaderAdvanced_GetAllocateForStream(IWMReaderAdvanced6 *iface, WORD output_num, BOOL *allocate)
 386 {
 387     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 388     FIXME("(%p)->(%d %p)\n", This, output_num, allocate);
 389     return E_NOTIMPL;
 390 }
 391
 392 static HRESULT WINAPI WMReaderAdvanced_GetStatistics(IWMReaderAdvanced6 *iface, WM_READER_STATISTICS *statistics)
 393 {
 394     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 395     FIXME("(%p)->(%p)\n", This, statistics);
 396     return E_NOTIMPL;
 397 }
 398
 399 static HRESULT WINAPI WMReaderAdvanced_SetClientInfo(IWMReaderAdvanced6 *iface, WM_READER_CLIENTINFO *client_info)
 400 {
 401     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 402     FIXME("(%p)->(%p)\n", This, client_info);
 403     return E_NOTIMPL;
 404 }
 405
 406 static HRESULT WINAPI WMReaderAdvanced_GetMaxOutputSampleSize(IWMReaderAdvanced6 *iface, DWORD output, DWORD *max)
 407 {
 408     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 409     FIXME("(%p)->(%d %p)\n", This, output, max);
 410     return E_NOTIMPL;
 411 }
 412
 413 static HRESULT WINAPI WMReaderAdvanced_GetMaxStreamSampleSize(IWMReaderAdvanced6 *iface, WORD stream, DWORD *max)
 414 {
 415     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 416     FIXME("(%p)->(%d %p)\n", This, stream, max);
 417     return E_NOTIMPL;
 418 }
 419
 420 static HRESULT WINAPI WMReaderAdvanced_NotifyLateDelivery(IWMReaderAdvanced6 *iface, QWORD lateness)
 421 {
 422     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 423     FIXME("(%p)->(%s)\n", This, wine_dbgstr_longlong(lateness));
 424     return E_NOTIMPL;
 425 }
 426
 427 static HRESULT WINAPI WMReaderAdvanced2_SetPlayMode(IWMReaderAdvanced6 *iface, WMT_PLAY_MODE mode)
 428 {
 429     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 430     FIXME("(%p)->(%d)\n", This, mode);
 431     return E_NOTIMPL;
 432 }
 433
 434 static HRESULT WINAPI WMReaderAdvanced2_GetPlayMode(IWMReaderAdvanced6 *iface, WMT_PLAY_MODE *mode)
 435 {
 436     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 437     FIXME("(%p)->(%p)\n", This, mode);
 438     return E_NOTIMPL;
 439 }
 440
 441 static HRESULT WINAPI WMReaderAdvanced2_GetBufferProgress(IWMReaderAdvanced6 *iface, DWORD *percent, QWORD *buffering)
 442 {
 443     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 444     FIXME("(%p)->(%p %p)\n", This, percent, buffering);
 445     return E_NOTIMPL;
 446 }
 447
 448 static HRESULT WINAPI WMReaderAdvanced2_GetDownloadProgress(IWMReaderAdvanced6 *iface, DWORD *percent,
 449         QWORD *bytes_downloaded, QWORD *download)
 450 {
 451     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 452     FIXME("(%p)->(%p %p %p)\n", This, percent, bytes_downloaded, download);
 453     return E_NOTIMPL;
 454 }
 455
 456 static HRESULT WINAPI WMReaderAdvanced2_GetSaveAsProgress(IWMReaderAdvanced6 *iface, DWORD *percent)
 457 {
 458     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 459     FIXME("(%p)->(%p)\n", This, percent);
 460     return E_NOTIMPL;
 461 }
 462
 463 static HRESULT WINAPI WMReaderAdvanced2_SaveFileAs(IWMReaderAdvanced6 *iface, const WCHAR *filename)
 464 {
 465     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 466     FIXME("(%p)->(%s)\n", This, debugstr_w(filename));
 467     return E_NOTIMPL;
 468 }
 469
 470 static HRESULT WINAPI WMReaderAdvanced2_GetProtocolName(IWMReaderAdvanced6 *iface, WCHAR *protocol, DWORD *protocol_len)
 471 {
 472     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 473     FIXME("(%p)->(%p %p)\n", This, protocol, protocol_len);
 474     return E_NOTIMPL;
 475 }
 476
 477 static HRESULT WINAPI WMReaderAdvanced2_StartAtMarker(IWMReaderAdvanced6 *iface, WORD marker_index,
 478         QWORD duration, float rate, void *context)
 479 {
 480     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 481     FIXME("(%p)->(%d %s %f %p)\n", This, marker_index, wine_dbgstr_longlong(duration), rate, context);
 482     return E_NOTIMPL;
 483 }
 484
 485 static HRESULT WINAPI WMReaderAdvanced2_GetOutputSetting(IWMReaderAdvanced6 *iface, DWORD output_num,
 486         const WCHAR *name, WMT_ATTR_DATATYPE *type, BYTE *value, WORD *length)
 487 {
 488     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 489     FIXME("(%p)->(%d %s %p %p %p)\n", This, output_num, debugstr_w(name), type, value, length);
 490     return E_NOTIMPL;
 491 }
 492
 493 static HRESULT WINAPI WMReaderAdvanced2_SetOutputSetting(IWMReaderAdvanced6 *iface, DWORD output_num,
 494         const WCHAR *name, WMT_ATTR_DATATYPE type, const BYTE *value, WORD length)
 495 {
 496     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 497     FIXME("(%p)->(%d %s %d %p %d)\n", This, output_num, debugstr_w(name), type, value, length);
 498     return E_NOTIMPL;
 499 }
 500
 501 static HRESULT WINAPI WMReaderAdvanced2_Preroll(IWMReaderAdvanced6 *iface, QWORD start, QWORD duration, float rate)
 502 {
 503     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 504     FIXME("(%p)->(%s %s %f)\n", This, wine_dbgstr_longlong(start), wine_dbgstr_longlong(duration), rate);
 505     return E_NOTIMPL;
 506 }
 507
 508 static HRESULT WINAPI WMReaderAdvanced2_SetLogClientID(IWMReaderAdvanced6 *iface, BOOL log_client_id)
 509 {
 510     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 511     FIXME("(%p)->(%x)\n", This, log_client_id);
 512     return E_NOTIMPL;
 513 }
 514
 515 static HRESULT WINAPI WMReaderAdvanced2_GetLogClientID(IWMReaderAdvanced6 *iface, BOOL *log_client_id)
 516 {
 517     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 518     FIXME("(%p)->(%p)\n", This, log_client_id);
 519     return E_NOTIMPL;
 520 }
 521
 522 static HRESULT WINAPI WMReaderAdvanced2_StopBuffering(IWMReaderAdvanced6 *iface)
 523 {
 524     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 525     FIXME("(%p)\n", This);
 526     return E_NOTIMPL;
 527 }
 528
 529 static HRESULT WINAPI WMReaderAdvanced2_OpenStream(IWMReaderAdvanced6 *iface, IStream *stream,
 530         IWMReaderCallback *callback, void *context)
 531 {
 532     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 533     FIXME("(%p)->(%p %p %p)\n", This, stream, callback, context);
 534     return E_NOTIMPL;
 535 }
 536
 537 static HRESULT WINAPI WMReaderAdvanced3_StopNetStreaming(IWMReaderAdvanced6 *iface)
 538 {
 539     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 540     FIXME("(%p)\n", This);
 541     return E_NOTIMPL;
 542 }
 543
 544 static HRESULT WINAPI WMReaderAdvanced3_StartAtPosition(IWMReaderAdvanced6 *iface, WORD stream_num,
 545         void *offset_start, void *duration, WMT_OFFSET_FORMAT format, float rate, void *context)
 546 {
 547     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 548     FIXME("(%p)->(%d %p %p %d %f %p)\n", This, stream_num, offset_start, duration, format, rate, context);
 549     return E_NOTIMPL;
 550 }
 551
 552 static HRESULT WINAPI WMReaderAdvanced4_GetLanguageCount(IWMReaderAdvanced6 *iface, DWORD output_num, WORD *language_count)
 553 {
 554     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 555     FIXME("(%p)->(%d %p)\n", This, output_num, language_count);
 556     return E_NOTIMPL;
 557 }
 558
 559 static HRESULT WINAPI WMReaderAdvanced4_GetLanguage(IWMReaderAdvanced6 *iface, DWORD output_num,
 560        WORD language, WCHAR *language_string, WORD *language_string_len)
 561 {
 562     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 563     FIXME("(%p)->(%d %x %p %p)\n", This, output_num, language, language_string, language_string_len);
 564     return E_NOTIMPL;
 565 }
 566
 567 static HRESULT WINAPI WMReaderAdvanced4_GetMaxSpeedFactor(IWMReaderAdvanced6 *iface, double *factor)
 568 {
 569     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 570     FIXME("(%p)->(%p)\n", This, factor);
 571     return E_NOTIMPL;
 572 }
 573
 574 static HRESULT WINAPI WMReaderAdvanced4_IsUsingFastCache(IWMReaderAdvanced6 *iface, BOOL *using_fast_cache)
 575 {
 576     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 577     FIXME("(%p)->(%p)\n", This, using_fast_cache);
 578     return E_NOTIMPL;
 579 }
 580
 581 static HRESULT WINAPI WMReaderAdvanced4_AddLogParam(IWMReaderAdvanced6 *iface, const WCHAR *namespace,
 582         const WCHAR *name, const WCHAR *value)
 583 {
 584     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 585     FIXME("(%p)->(%s %s %s)\n", This, debugstr_w(namespace), debugstr_w(name), debugstr_w(value));
 586     return E_NOTIMPL;
 587 }
 588
 589 static HRESULT WINAPI WMReaderAdvanced4_SendLogParams(IWMReaderAdvanced6 *iface)
 590 {
 591     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 592     FIXME("(%p)\n", This);
 593     return E_NOTIMPL;
 594 }
 595
 596 static HRESULT WINAPI WMReaderAdvanced4_CanSaveFileAs(IWMReaderAdvanced6 *iface, BOOL *can_save)
 597 {
 598     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 599     FIXME("(%p)->(%p)\n", This, can_save);
 600     return E_NOTIMPL;
 601 }
 602
 603 static HRESULT WINAPI WMReaderAdvanced4_CancelSaveFileAs(IWMReaderAdvanced6 *iface)
 604 {
 605     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 606     FIXME("(%p)\n", This);
 607     return E_NOTIMPL;
 608 }
 609
 610 static HRESULT WINAPI WMReaderAdvanced4_GetURL(IWMReaderAdvanced6 *iface, WCHAR *url, DWORD *url_len)
 611 {
 612     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 613     FIXME("(%p)->(%p %p)\n", This, url, url_len);
 614     return E_NOTIMPL;
 615 }
 616
 617 static HRESULT WINAPI WMReaderAdvanced5_SetPlayerHook(IWMReaderAdvanced6 *iface, DWORD output_num, IWMPlayerHook *hook)
 618 {
 619     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 620     FIXME("(%p)->(%d %p)\n", This, output_num, hook);
 621     return E_NOTIMPL;
 622 }
 623
 624 static HRESULT WINAPI WMReaderAdvanced6_SetProtectStreamSamples(IWMReaderAdvanced6 *iface, BYTE *cert,
 625         DWORD cert_size, DWORD cert_type, DWORD flags, BYTE *initialization_vector, DWORD *initialization_vector_size)
 626 {
 627     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 628     FIXME("(%p)->(%p %d %d %x %p %p)\n", This, cert, cert_size, cert_type, flags, initialization_vector,
 629           initialization_vector_size);
 630     return E_NOTIMPL;
 631 }
 632
 633 static const IWMReaderAdvanced6Vtbl WMReaderAdvanced6Vtbl = {
 634     WMReaderAdvanced_QueryInterface,
 635     WMReaderAdvanced_AddRef,
 636     WMReaderAdvanced_Release,
 637     WMReaderAdvanced_SetUserProvidedClock,
 638     WMReaderAdvanced_GetUserProvidedClock,
 639     WMReaderAdvanced_DeliverTime,
 640     WMReaderAdvanced_SetManualStreamSelection,
 641     WMReaderAdvanced_GetManualStreamSelection,
 642     WMReaderAdvanced_SetStreamsSelected,
 643     WMReaderAdvanced_GetStreamSelected,
 644     WMReaderAdvanced_SetReceiveSelectionCallbacks,
 645     WMReaderAdvanced_GetReceiveSelectionCallbacks,
 646     WMReaderAdvanced_SetReceiveStreamSamples,
 647     WMReaderAdvanced_GetReceiveStreamSamples,
 648     WMReaderAdvanced_SetAllocateForOutput,
 649     WMReaderAdvanced_GetAllocateForOutput,
 650     WMReaderAdvanced_SetAllocateForStream,
 651     WMReaderAdvanced_GetAllocateForStream,
 652     WMReaderAdvanced_GetStatistics,
 653     WMReaderAdvanced_SetClientInfo,
 654     WMReaderAdvanced_GetMaxOutputSampleSize,
 655     WMReaderAdvanced_GetMaxStreamSampleSize,
 656     WMReaderAdvanced_NotifyLateDelivery,
 657     WMReaderAdvanced2_SetPlayMode,
 658     WMReaderAdvanced2_GetPlayMode,
 659     WMReaderAdvanced2_GetBufferProgress,
 660     WMReaderAdvanced2_GetDownloadProgress,
 661     WMReaderAdvanced2_GetSaveAsProgress,
 662     WMReaderAdvanced2_SaveFileAs,
 663     WMReaderAdvanced2_GetProtocolName,
 664     WMReaderAdvanced2_StartAtMarker,
 665     WMReaderAdvanced2_GetOutputSetting,
 666     WMReaderAdvanced2_SetOutputSetting,
 667     WMReaderAdvanced2_Preroll,
 668     WMReaderAdvanced2_SetLogClientID,
 669     WMReaderAdvanced2_GetLogClientID,
 670     WMReaderAdvanced2_StopBuffering,
 671     WMReaderAdvanced2_OpenStream,
 672     WMReaderAdvanced3_StopNetStreaming,
 673     WMReaderAdvanced3_StartAtPosition,
 674     WMReaderAdvanced4_GetLanguageCount,
 675     WMReaderAdvanced4_GetLanguage,
 676     WMReaderAdvanced4_GetMaxSpeedFactor,
 677     WMReaderAdvanced4_IsUsingFastCache,
 678     WMReaderAdvanced4_AddLogParam,
 679     WMReaderAdvanced4_SendLogParams,
 680     WMReaderAdvanced4_CanSaveFileAs,
 681     WMReaderAdvanced4_CancelSaveFileAs,
 682     WMReaderAdvanced4_GetURL,
 683     WMReaderAdvanced5_SetPlayerHook,
 684     WMReaderAdvanced6_SetProtectStreamSamples
 685 };
 686
 687 static inline WMReader *impl_from_IWMReaderAccelerator(IWMReaderAccelerator *iface)
 688 {
 689     return CONTAINING_RECORD(iface, WMReader, IWMReaderAccelerator_iface);
 690 }
 691
 692 static HRESULT WINAPI reader_accl_QueryInterface(IWMReaderAccelerator *iface, REFIID riid, void **object)
 693 {
 694     WMReader *This = impl_from_IWMReaderAccelerator(iface);
 695     return IWMReader_QueryInterface(&This->IWMReader_iface, riid, object);
 696 }
 697
 698 static ULONG WINAPI reader_accl_AddRef(IWMReaderAccelerator *iface)
 699 {
 700     WMReader *This = impl_from_IWMReaderAccelerator(iface);
 701     return IWMReader_AddRef(&This->IWMReader_iface);
 702 }
 703
 704 static ULONG WINAPI reader_accl_Release(IWMReaderAccelerator *iface)
 705 {
 706     WMReader *This = impl_from_IWMReaderAccelerator(iface);
 707     return IWMReader_Release(&This->IWMReader_iface);
 708 }
 709
 710 static HRESULT WINAPI reader_accl_GetCodecInterface(IWMReaderAccelerator *iface, DWORD output, REFIID riid, void **codec)
 711 {
 712     WMReader *This = impl_from_IWMReaderAccelerator(iface);
 713
 714     FIXME("%p, %d, %s, %p\n", This, output, debugstr_guid(riid), codec);
 715
 716     return E_NOTIMPL;
 717 }
 718
 719 static HRESULT WINAPI reader_accl_Notify(IWMReaderAccelerator *iface, DWORD output, WM_MEDIA_TYPE *subtype)
 720 {
 721     WMReader *This = impl_from_IWMReaderAccelerator(iface);
 722
 723     FIXME("%p, %d, %p\n", This, output, subtype);
 724
 725     return E_NOTIMPL;
 726 }
 727
 728 static const IWMReaderAcceleratorVtbl WMReaderAcceleratorVtbl = {
 729     reader_accl_QueryInterface,
 730     reader_accl_AddRef,
 731     reader_accl_Release,
 732     reader_accl_GetCodecInterface,
 733     reader_accl_Notify
 734 };
 735
 736 static inline WMReader *impl_from_IWMReaderNetworkConfig2(IWMReaderNetworkConfig2 *iface)
 737 {
 738     return CONTAINING_RECORD(iface, WMReader, IWMReaderNetworkConfig2_iface);
 739 }
 740
 741 static HRESULT WINAPI networkconfig_QueryInterface(IWMReaderNetworkConfig2 *iface, REFIID riid, void **ppv)
 742 {
 743     WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
 744     return IWMReader_QueryInterface(&This->IWMReader_iface, riid, ppv);
 745 }
 746
 747 static ULONG WINAPI networkconfig_AddRef(IWMReaderNetworkConfig2 *iface)
 748 {
 749     WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
 750     return IWMReader_AddRef(&This->IWMReader_iface);
 751 }
 752
 753 static ULONG WINAPI networkconfig_Release(IWMReaderNetworkConfig2 *iface)
 754 {
 755     WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
 756     return IWMReader_Release(&This->IWMReader_iface);
 757 }
 758
 759 static HRESULT WINAPI networkconfig_GetBufferingTime(IWMReaderNetworkConfig2 *iface, QWORD *buffering_time)
 760 {
 761     WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
 762     FIXME("%p, %p\n", This, buffering_time);
 763     return E_NOTIMPL;
 764 }
 765
 766 static HRESULT WINAPI networkconfig_SetBufferingTime(IWMReaderNetworkConfig2 *iface, QWORD buffering_time)
 767 {
 768     WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
 769     FIXME("%p, %s\n", This, wine_dbgstr_longlong(buffering_time));
 770     return E_NOTIMPL;
 771 }
 772
 773 static HRESULT WINAPI networkconfig_GetUDPPortRanges(IWMReaderNetworkConfig2 *iface, WM_PORT_NUMBER_RANGE *array,
 774         DWORD *ranges)
 775 {
 776     WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
 777     FIXME("%p, %p, %p\n", This, array, ranges);
 778     return E_NOTIMPL;
 779 }
 780
 781 static HRESULT WINAPI networkconfig_SetUDPPortRanges(IWMReaderNetworkConfig2 *iface, WM_PORT_NUMBER_RANGE *array,
 782         DWORD ranges)
 783 {
 784     WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
 785     FIXME("%p, %p, %u\n", This, array, ranges);
 786     return E_NOTIMPL;
 787 }
 788
 789 static HRESULT WINAPI networkconfig_GetProxySettings(IWMReaderNetworkConfig2 *iface, const WCHAR *protocol,
 790         WMT_PROXY_SETTINGS *proxy)
 791 {
 792     WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
 793     FIXME("%p, %s, %p\n", This, debugstr_w(protocol), proxy);
 794     return E_NOTIMPL;
 795 }
 796
 797 static HRESULT WINAPI networkconfig_SetProxySettings(IWMReaderNetworkConfig2 *iface, LPCWSTR protocol,
 798         WMT_PROXY_SETTINGS proxy)
 799 {
 800     WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
 801     FIXME("%p, %s, %d\n", This, debugstr_w(protocol), proxy);
 802     return E_NOTIMPL;
 803 }
 804
 805 static HRESULT WINAPI networkconfig_GetProxyHostName(IWMReaderNetworkConfig2 *iface, const WCHAR *protocol,
 806         WCHAR *hostname, DWORD *size)
 807 {
 808     WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
 809     FIXME("%p, %s, %p, %p\n", This, debugstr_w(protocol), hostname, size);
 810     return E_NOTIMPL;
 811 }
 812
 813 static HRESULT WINAPI networkconfig_SetProxyHostName(IWMReaderNetworkConfig2 *iface, const WCHAR *protocol,
 814         const WCHAR *hostname)
 815 {
 816     WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
 817     FIXME("%p, %s, %s\n", This, debugstr_w(protocol), debugstr_w(hostname));
 818     return E_NOTIMPL;
 819 }
 820
 821 static HRESULT WINAPI networkconfig_GetProxyPort(IWMReaderNetworkConfig2 *iface, const WCHAR *protocol,
 822         DWORD *port)
 823 {
 824     WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
 825     FIXME("%p, %s, %p\n", This, debugstr_w(protocol), port);
 826     return E_NOTIMPL;
 827 }
 828
 829 static HRESULT WINAPI networkconfig_SetProxyPort(IWMReaderNetworkConfig2 *iface, const WCHAR *protocol,
 830         DWORD port)
 831 {
 832     WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
 833     FIXME("%p, %s, %u\n", This, debugstr_w(protocol), port);
 834     return E_NOTIMPL;
 835 }
 836
 837 static HRESULT WINAPI networkconfig_GetProxyExceptionList(IWMReaderNetworkConfig2 *iface, const WCHAR *protocol,
 838         WCHAR *exceptions, DWORD *count)
 839 {
 840     WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
 841     FIXME("%p, %s, %p, %p\n", This, debugstr_w(protocol), exceptions, count);
 842     return E_NOTIMPL;
 843 }
 844
 845 static HRESULT WINAPI networkconfig_SetProxyExceptionList(IWMReaderNetworkConfig2 *iface, const WCHAR *protocol,
 846         const WCHAR *exceptions)
 847 {
 848     WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
 849     FIXME("%p, %s, %s\n", This, debugstr_w(protocol), debugstr_w(exceptions));
 850     return E_NOTIMPL;
 851 }
 852
 853 static HRESULT WINAPI networkconfig_GetProxyBypassForLocal(IWMReaderNetworkConfig2 *iface, const WCHAR *protocol,
 854         BOOL *bypass)
 855 {
 856     WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
 857     FIXME("%p, %s, %p\n", This, debugstr_w(protocol), bypass);
 858     return E_NOTIMPL;
 859 }
 860
 861 static HRESULT WINAPI networkconfig_SetProxyBypassForLocal(IWMReaderNetworkConfig2 *iface, const WCHAR *protocol,
 862         BOOL bypass)
 863 {
 864     WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
 865     FIXME("%p, %s, %d\n", This, debugstr_w(protocol), bypass);
 866     return E_NOTIMPL;
 867 }
 868
 869 static HRESULT WINAPI networkconfig_GetForceRerunAutoProxyDetection(IWMReaderNetworkConfig2 *iface,
 870         BOOL *detection)
 871 {
 872     WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
 873     FIXME("%p, %p\n", This, detection);
 874     return E_NOTIMPL;
 875 }
 876
 877 static HRESULT WINAPI networkconfig_SetForceRerunAutoProxyDetection(IWMReaderNetworkConfig2 *iface,
 878         BOOL detection)
 879 {
 880     WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
 881     FIXME("%p, %d\n", This, detection);
 882     return E_NOTIMPL;
 883 }
 884
 885 static HRESULT WINAPI networkconfig_GetEnableMulticast(IWMReaderNetworkConfig2 *iface, BOOL *multicast)
 886 {
 887     WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
 888     FIXME("%p, %p\n", This, multicast);
 889     return E_NOTIMPL;
 890 }
 891
 892 static HRESULT WINAPI networkconfig_SetEnableMulticast(IWMReaderNetworkConfig2 *iface, BOOL multicast)
 893 {
 894     WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
 895     FIXME("%p, %d\n", This, multicast);
 896     return E_NOTIMPL;
 897 }
 898
 899 static HRESULT WINAPI networkconfig_GetEnableHTTP(IWMReaderNetworkConfig2 *iface, BOOL *enable)
 900 {
 901     WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
 902     FIXME("%p, %p\n", This, enable);
 903     return E_NOTIMPL;
 904 }
 905
 906 static HRESULT WINAPI networkconfig_SetEnableHTTP(IWMReaderNetworkConfig2 *iface, BOOL enable)
 907 {
 908     WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
 909     FIXME("%p, %d\n", This, enable);
 910     return E_NOTIMPL;
 911 }
 912
 913 static HRESULT WINAPI networkconfig_GetEnableUDP(IWMReaderNetworkConfig2 *iface, BOOL *enable)
 914 {
 915     WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
 916     FIXME("%p, %p\n", This, enable);
 917     return E_NOTIMPL;
 918 }
 919
 920 static HRESULT WINAPI networkconfig_SetEnableUDP(IWMReaderNetworkConfig2 *iface, BOOL enable)
 921 {
 922     WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
 923     FIXME("%p, %d\n", This, enable);
 924     return E_NOTIMPL;
 925 }
 926
 927 static HRESULT WINAPI networkconfig_GetEnableTCP(IWMReaderNetworkConfig2 *iface, BOOL *enable)
 928 {
 929     WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
 930     FIXME("%p, %p\n", This, enable);
 931     return E_NOTIMPL;
 932 }
 933
 934 static HRESULT WINAPI networkconfig_SetEnableTCP(IWMReaderNetworkConfig2 *iface, BOOL enable)
 935 {
 936     WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
 937     FIXME("%p, %d\n", This, enable);
 938     return E_NOTIMPL;
 939 }
 940
 941 static HRESULT WINAPI networkconfig_ResetProtocolRollover(IWMReaderNetworkConfig2 *iface)
 942 {
 943     WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
 944     FIXME("%p\n", This);
 945     return E_NOTIMPL;
 946 }
 947
 948 static HRESULT WINAPI networkconfig_GetConnectionBandwidth(IWMReaderNetworkConfig2 *iface, DWORD *bandwidth)
 949 {
 950     WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
 951     FIXME("%p, %p\n", This, bandwidth);
 952     return E_NOTIMPL;
 953 }
 954
 955 static HRESULT WINAPI networkconfig_SetConnectionBandwidth(IWMReaderNetworkConfig2 *iface, DWORD bandwidth)
 956 {
 957     WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
 958     FIXME("%p, %u\n", This, bandwidth);
 959     return E_NOTIMPL;
 960 }
 961
 962 static HRESULT WINAPI networkconfig_GetNumProtocolsSupported(IWMReaderNetworkConfig2 *iface, DWORD *protocols)
 963 {
 964     WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
 965     FIXME("%p, %p\n", This, protocols);
 966     return E_NOTIMPL;
 967 }
 968
 969 static HRESULT WINAPI networkconfig_GetSupportedProtocolName(IWMReaderNetworkConfig2 *iface, DWORD protocol_num,
 970         WCHAR *protocol, DWORD *size)
 971 {
 972     WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
 973     FIXME("%p, %u, %p %p\n", This, protocol_num, protocol, size);
 974     return E_NOTIMPL;
 975 }
 976
 977 static HRESULT WINAPI networkconfig_AddLoggingUrl(IWMReaderNetworkConfig2 *iface, const WCHAR *url)
 978 {
 979     WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
 980     FIXME("%p, %s\n", This, debugstr_w(url));
 981     return E_NOTIMPL;
 982 }
 983
 984 static HRESULT WINAPI networkconfig_GetLoggingUrl(IWMReaderNetworkConfig2 *iface, DWORD index, WCHAR *url,
 985         DWORD *size)
 986 {
 987     WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
 988     FIXME("%p, %u, %p, %p\n", This, index, url, size);
 989     return E_NOTIMPL;
 990 }
 991
 992 static HRESULT WINAPI networkconfig_GetLoggingUrlCount(IWMReaderNetworkConfig2 *iface, DWORD *count)
 993 {
 994     WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
 995     FIXME("%p, %p\n", This, count);
 996     return E_NOTIMPL;
 997 }
 998
 999 static HRESULT WINAPI networkconfig_ResetLoggingUrlList(IWMReaderNetworkConfig2 *iface)
1000 {
1001     WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
1002     FIXME("%p\n", This);
1003     return E_NOTIMPL;
1004 }
1005
1006 static HRESULT WINAPI networkconfig_GetEnableContentCaching(IWMReaderNetworkConfig2 *iface, BOOL *enable)
1007 {
1008     WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
1009     FIXME("%p, %p\n", This, enable);
1010     return E_NOTIMPL;
1011 }
1012
1013 static HRESULT WINAPI networkconfig_SetEnableContentCaching(IWMReaderNetworkConfig2 *iface, BOOL enable)
1014 {
1015     WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
1016     FIXME("%p, %d\n", This, enable);
1017     return E_NOTIMPL;
1018 }
1019
1020 static HRESULT WINAPI networkconfig_GetEnableFastCache(IWMReaderNetworkConfig2 *iface, BOOL *enable)
1021 {
1022     WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
1023     FIXME("%p, %p\n", This, enable);
1024     return E_NOTIMPL;
1025 }
1026
1027 static HRESULT WINAPI networkconfig_SetEnableFastCache(IWMReaderNetworkConfig2 *iface, BOOL enable)
1028 {
1029     WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
1030     FIXME("%p, %d\n", This, enable);
1031     return E_NOTIMPL;
1032 }
1033
1034 static HRESULT WINAPI networkconfig_GetAcceleratedStreamingDuration(IWMReaderNetworkConfig2 *iface,
1035         QWORD *duration)
1036 {
1037     WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
1038     FIXME("%p, %p\n", This, duration);
1039     return E_NOTIMPL;
1040 }
1041
1042 static HRESULT WINAPI networkconfig_SetAcceleratedStreamingDuration(IWMReaderNetworkConfig2 *iface,
1043         QWORD duration)
1044 {
1045     WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
1046     FIXME("%p, %s\n", This, wine_dbgstr_longlong(duration));
1047     return E_NOTIMPL;
1048 }
1049
1050 static HRESULT WINAPI networkconfig_GetAutoReconnectLimit(IWMReaderNetworkConfig2 *iface, DWORD *limit)
1051 {
1052     WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
1053     FIXME("%p, %p\n", This, limit);
1054     return E_NOTIMPL;
1055 }
1056
1057 static HRESULT WINAPI networkconfig_SetAutoReconnectLimit(IWMReaderNetworkConfig2 *iface, DWORD limit)
1058 {
1059     WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
1060     FIXME("%p, %u\n", This, limit);
1061     return E_NOTIMPL;
1062 }
1063
1064 static HRESULT WINAPI networkconfig_GetEnableResends(IWMReaderNetworkConfig2 *iface, BOOL *enable)
1065 {
1066     WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
1067     FIXME("%p, %p\n", This, enable);
1068     return E_NOTIMPL;
1069 }
1070
1071 static HRESULT WINAPI networkconfig_SetEnableResends(IWMReaderNetworkConfig2 *iface, BOOL enable)
1072 {
1073     WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
1074     FIXME("%p, %u\n", This, enable);
1075     return E_NOTIMPL;
1076 }
1077
1078 static HRESULT WINAPI networkconfig_GetEnableThinning(IWMReaderNetworkConfig2 *iface, BOOL *enable)
1079 {
1080     WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
1081     FIXME("%p, %p\n", This, enable);
1082     return E_NOTIMPL;
1083 }
1084
1085 static HRESULT WINAPI networkconfig_SetEnableThinning(IWMReaderNetworkConfig2 *iface, BOOL enable)
1086 {
1087     WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
1088     FIXME("%p, %u\n", This, enable);
1089     return E_NOTIMPL;
1090 }
1091
1092 static HRESULT WINAPI networkconfig_GetMaxNetPacketSize(IWMReaderNetworkConfig2 *iface, DWORD *packet_size)
1093 {
1094     WMReader *This = impl_from_IWMReaderNetworkConfig2(iface);
1095     FIXME("%p, %p\n", This, packet_size);
1096     return E_NOTIMPL;
1097 }
1098
1099 static const IWMReaderNetworkConfig2Vtbl WMReaderNetworkConfig2Vtbl =
1100 {
1101     networkconfig_QueryInterface,
1102     networkconfig_AddRef,
1103     networkconfig_Release,
1104     networkconfig_GetBufferingTime,
1105     networkconfig_SetBufferingTime,
1106     networkconfig_GetUDPPortRanges,
1107     networkconfig_SetUDPPortRanges,
1108     networkconfig_GetProxySettings,
1109     networkconfig_SetProxySettings,
1110     networkconfig_GetProxyHostName,
1111     networkconfig_SetProxyHostName,
1112     networkconfig_GetProxyPort,
1113     networkconfig_SetProxyPort,
1114     networkconfig_GetProxyExceptionList,
1115     networkconfig_SetProxyExceptionList,
1116     networkconfig_GetProxyBypassForLocal,
1117     networkconfig_SetProxyBypassForLocal,
1118     networkconfig_GetForceRerunAutoProxyDetection,
1119     networkconfig_SetForceRerunAutoProxyDetection,
1120     networkconfig_GetEnableMulticast,
1121     networkconfig_SetEnableMulticast,
1122     networkconfig_GetEnableHTTP,
1123     networkconfig_SetEnableHTTP,
1124     networkconfig_GetEnableUDP,
1125     networkconfig_SetEnableUDP,
1126     networkconfig_GetEnableTCP,
1127     networkconfig_SetEnableTCP,
1128     networkconfig_ResetProtocolRollover,
1129     networkconfig_GetConnectionBandwidth,
1130     networkconfig_SetConnectionBandwidth,
1131     networkconfig_GetNumProtocolsSupported,
1132     networkconfig_GetSupportedProtocolName,
1133     networkconfig_AddLoggingUrl,
1134     networkconfig_GetLoggingUrl,
1135     networkconfig_GetLoggingUrlCount,
1136     networkconfig_ResetLoggingUrlList,
1137     networkconfig_GetEnableContentCaching,
1138     networkconfig_SetEnableContentCaching,
1139     networkconfig_GetEnableFastCache,
1140     networkconfig_SetEnableFastCache,
1141     networkconfig_GetAcceleratedStreamingDuration,
1142     networkconfig_SetAcceleratedStreamingDuration,
1143     networkconfig_GetAutoReconnectLimit,
1144     networkconfig_SetAutoReconnectLimit,
1145     networkconfig_GetEnableResends,
1146     networkconfig_SetEnableResends,
1147     networkconfig_GetEnableThinning,
1148     networkconfig_SetEnableThinning,
1149     networkconfig_GetMaxNetPacketSize
1150 };
1151
1152 static inline WMReader *impl_from_IWMReaderStreamClock(IWMReaderStreamClock *iface)
1153 {
1154     return CONTAINING_RECORD(iface, WMReader, IWMReaderStreamClock_iface);
1155 }
1156
1157 static HRESULT WINAPI readclock_QueryInterface(IWMReaderStreamClock *iface, REFIID riid, void **ppv)
1158 {
1159     WMReader *This = impl_from_IWMReaderStreamClock(iface);
1160     return IWMReader_QueryInterface(&This->IWMReader_iface, riid, ppv);
1161 }
1162
1163 static ULONG WINAPI readclock_AddRef(IWMReaderStreamClock *iface)
1164 {
1165     WMReader *This = impl_from_IWMReaderStreamClock(iface);
1166     return IWMReader_AddRef(&This->IWMReader_iface);
1167 }
1168
1169 static ULONG WINAPI readclock_Release(IWMReaderStreamClock *iface)
1170 {
1171     WMReader *This = impl_from_IWMReaderStreamClock(iface);
1172     return IWMReader_Release(&This->IWMReader_iface);
1173 }
1174
1175 static HRESULT WINAPI readclock_GetTime(IWMReaderStreamClock *iface, QWORD *now)
1176 {
1177     WMReader *This = impl_from_IWMReaderStreamClock(iface);
1178     FIXME("%p, %p\n", This, now);
1179     return E_NOTIMPL;
1180 }
1181
1182 static HRESULT WINAPI readclock_SetTimer(IWMReaderStreamClock *iface, QWORD when, void *param, DWORD *id)
1183 {
1184     WMReader *This = impl_from_IWMReaderStreamClock(iface);
1185     FIXME("%p, %s, %p, %p\n", This, wine_dbgstr_longlong(when), param, id);
1186     return E_NOTIMPL;
1187 }
1188
1189 static HRESULT WINAPI readclock_KillTimer(IWMReaderStreamClock *iface, DWORD id)
1190 {
1191     WMReader *This = impl_from_IWMReaderStreamClock(iface);
1192     FIXME("%p, %d\n", This, id);
1193     return E_NOTIMPL;
1194 }
1195
1196 static const IWMReaderStreamClockVtbl WMReaderStreamClockVtbl =
1197 {
1198     readclock_QueryInterface,
1199     readclock_AddRef,
1200     readclock_Release,
1201     readclock_GetTime,
1202     readclock_SetTimer,
1203     readclock_KillTimer
1204 };
1205
1206 static inline WMReader *impl_from_IWMReaderTypeNegotiation(IWMReaderTypeNegotiation *iface)
1207 {
1208     return CONTAINING_RECORD(iface, WMReader, IWMReaderTypeNegotiation_iface);
1209 }
1210
1211 static HRESULT WINAPI negotiation_QueryInterface(IWMReaderTypeNegotiation *iface, REFIID riid, void **ppv)
1212 {
1213     WMReader *This = impl_from_IWMReaderTypeNegotiation(iface);
1214     return IWMReader_QueryInterface(&This->IWMReader_iface, riid, ppv);
1215 }
1216
1217 static ULONG WINAPI negotiation_AddRef(IWMReaderTypeNegotiation *iface)
1218 {
1219     WMReader *This = impl_from_IWMReaderTypeNegotiation(iface);
1220     return IWMReader_AddRef(&This->IWMReader_iface);
1221 }
1222
1223 static ULONG WINAPI negotiation_Release(IWMReaderTypeNegotiation *iface)
1224 {
1225     WMReader *This = impl_from_IWMReaderTypeNegotiation(iface);
1226     return IWMReader_Release(&This->IWMReader_iface);
1227 }
1228
1229 static HRESULT WINAPI negotiation_TryOutputProps(IWMReaderTypeNegotiation *iface, DWORD output, IWMOutputMediaProps *props)
1230 {
1231     WMReader *This = impl_from_IWMReaderTypeNegotiation(iface);
1232     FIXME("%p, %d, %p\n", This, output, props);
1233     return E_NOTIMPL;
1234 }
1235
1236 static const IWMReaderTypeNegotiationVtbl WMReaderTypeNegotiationVtbl =
1237 {
1238     negotiation_QueryInterface,
1239     negotiation_AddRef,
1240     negotiation_Release,
1241     negotiation_TryOutputProps
1242 };
1243
1244 static inline WMReader *impl_from_IWMReaderTimecode(IWMReaderTimecode *iface)
1245 {
1246     return CONTAINING_RECORD(iface, WMReader, IWMReaderTimecode_iface);
1247 }
1248
1249 static HRESULT WINAPI timecode_QueryInterface(IWMReaderTimecode *iface, REFIID riid, void **ppv)
1250 {
1251     WMReader *This = impl_from_IWMReaderTimecode(iface);
1252     return IWMReader_QueryInterface(&This->IWMReader_iface, riid, ppv);
1253 }
1254
1255 static ULONG WINAPI timecode_AddRef(IWMReaderTimecode *iface)
1256 {
1257     WMReader *This = impl_from_IWMReaderTimecode(iface);
1258     return IWMReader_AddRef(&This->IWMReader_iface);
1259 }
1260
1261 static ULONG WINAPI timecode_Release(IWMReaderTimecode *iface)
1262 {
1263     WMReader *This = impl_from_IWMReaderTimecode(iface);
1264     return IWMReader_Release(&This->IWMReader_iface);
1265 }
1266
1267 static HRESULT WINAPI timecode_GetTimecodeRangeCount(IWMReaderTimecode *iface, WORD num, WORD *count)
1268 {
1269     WMReader *This = impl_from_IWMReaderTimecode(iface);
1270     FIXME("%p, %d, %p\n", This, num, count);
1271     return E_NOTIMPL;
1272 }
1273
1274 static HRESULT WINAPI timecode_GetTimecodeRangeBounds(IWMReaderTimecode *iface, WORD stream, WORD range,
1275         DWORD *start_timecode, DWORD *end_timecode)
1276 {
1277     WMReader *This = impl_from_IWMReaderTimecode(iface);
1278     FIXME("%p, %d, %d, %p, %p\n", This, stream, range, start_timecode, end_timecode);
1279     return E_NOTIMPL;
1280 }
1281
1282 static const IWMReaderTimecodeVtbl WMReaderTimecodeVtbl =
1283 {
1284     timecode_QueryInterface,
1285     timecode_AddRef,
1286     timecode_Release,
1287     timecode_GetTimecodeRangeCount,
1288     timecode_GetTimecodeRangeBounds
1289 };
1290
1291
1292 static inline WMReader *impl_from_IWMReaderPlaylistBurn(IWMReaderPlaylistBurn *iface)
1293 {
1294     return CONTAINING_RECORD(iface, WMReader, IWMReaderPlaylistBurn_iface);
1295 }
1296
1297 static HRESULT WINAPI playlist_QueryInterface(IWMReaderPlaylistBurn *iface, REFIID riid, void **ppv)
1298 {
1299     WMReader *This = impl_from_IWMReaderPlaylistBurn(iface);
1300     return IWMReader_QueryInterface(&This->IWMReader_iface, riid, ppv);
1301 }
1302
1303 static ULONG WINAPI playlist_AddRef(IWMReaderPlaylistBurn *iface)
1304 {
1305     WMReader *This = impl_from_IWMReaderPlaylistBurn(iface);
1306     return IWMReader_AddRef(&This->IWMReader_iface);
1307 }
1308
1309 static ULONG WINAPI playlist_Release(IWMReaderPlaylistBurn *iface)
1310 {
1311     WMReader *This = impl_from_IWMReaderPlaylistBurn(iface);
1312     return IWMReader_Release(&This->IWMReader_iface);
1313 }
1314
1315 static HRESULT WINAPI playlist_InitPlaylistBurn(IWMReaderPlaylistBurn *iface, DWORD count,
1316         LPCWSTR_WMSDK_TYPE_SAFE *filenames, IWMStatusCallback *callback, void *context)
1317 {
1318     WMReader *This = impl_from_IWMReaderPlaylistBurn(iface);
1319     FIXME("%p, %d, %p, %p, %p\n", This, count, filenames, callback, context);
1320     return E_NOTIMPL;
1321 }
1322
1323 static HRESULT WINAPI playlist_GetInitResults(IWMReaderPlaylistBurn *iface, DWORD count, HRESULT *stat)
1324 {
1325     WMReader *This = impl_from_IWMReaderPlaylistBurn(iface);
1326     FIXME("%p, %d, %p\n", This, count, stat);
1327     return E_NOTIMPL;
1328 }
1329
1330 static HRESULT WINAPI playlist_Cancel(IWMReaderPlaylistBurn *iface)
1331 {
1332     WMReader *This = impl_from_IWMReaderPlaylistBurn(iface);
1333     FIXME("%p\n", This);
1334     return E_NOTIMPL;
1335 }
1336
1337 static HRESULT WINAPI playlist_EndPlaylistBurn(IWMReaderPlaylistBurn *iface, HRESULT result)
1338 {
1339     WMReader *This = impl_from_IWMReaderPlaylistBurn(iface);
1340     FIXME("%p, 0x%08x\n", This, result);
1341     return E_NOTIMPL;
1342 }
1343
1344 static const IWMReaderPlaylistBurnVtbl WMReaderPlaylistBurnVtbl =
1345 {
1346     playlist_QueryInterface,
1347     playlist_AddRef,
1348     playlist_Release,
1349     playlist_InitPlaylistBurn,
1350     playlist_GetInitResults,
1351     playlist_Cancel,
1352     playlist_EndPlaylistBurn
1353 };
1354
1355 static inline WMReader *impl_from_IWMHeaderInfo3(IWMHeaderInfo3 *iface)
1356 {
1357     return CONTAINING_RECORD(iface, WMReader, IWMHeaderInfo3_iface);
1358 }
1359
1360 static HRESULT WINAPI headerinfo_QueryInterface(IWMHeaderInfo3 *iface, REFIID riid, void **ppv)
1361 {
1362     WMReader *This = impl_from_IWMHeaderInfo3(iface);
1363     return IWMReader_QueryInterface(&This->IWMReader_iface, riid, ppv);
1364 }
1365
1366 static ULONG WINAPI headerinfo_AddRef(IWMHeaderInfo3 *iface)
1367 {
1368     WMReader *This = impl_from_IWMHeaderInfo3(iface);
1369     return IWMReader_AddRef(&This->IWMReader_iface);
1370 }
1371
1372 static ULONG WINAPI headerinfo_Release(IWMHeaderInfo3 *iface)
1373 {
1374     WMReader *This = impl_from_IWMHeaderInfo3(iface);
1375     return IWMReader_Release(&This->IWMReader_iface);
1376 }
1377
1378 static HRESULT WINAPI headerinfo_GetAttributeCount(IWMHeaderInfo3 *iface, WORD stream_num, WORD *attributes)
1379 {
1380     WMReader *This = impl_from_IWMHeaderInfo3(iface);
1381     FIXME("%p, %d, %p\n", This, stream_num, attributes);
1382     return E_NOTIMPL;
1383 }
1384
1385 static HRESULT WINAPI headerinfo_GetAttributeByIndex(IWMHeaderInfo3 *iface, WORD index, WORD *stream_num,
1386         WCHAR *name, WORD *name_len, WMT_ATTR_DATATYPE *type, BYTE *value, WORD *length)
1387 {
1388     WMReader *This = impl_from_IWMHeaderInfo3(iface);
1389     FIXME("%p, %d, %p, %p, %p, %p, %p, %p\n", This, index, stream_num, name, name_len, type,
1390             value, length);
1391     return E_NOTIMPL;
1392 }
1393
1394 static HRESULT WINAPI headerinfo_GetAttributeByName(IWMHeaderInfo3 *iface, WORD *stream_num, LPCWSTR name,
1395         WMT_ATTR_DATATYPE *type, BYTE *value, WORD *length)
1396 {
1397     WMReader *This = impl_from_IWMHeaderInfo3(iface);
1398     FIXME("%p, %p, %s, %p, %p, %p\n", This, stream_num, debugstr_w(name), type, value, length);
1399     return E_NOTIMPL;
1400 }
1401
1402 static HRESULT WINAPI headerinfo_SetAttribute(IWMHeaderInfo3 *iface, WORD stream_num, LPCWSTR name,
1403         WMT_ATTR_DATATYPE type, const BYTE *value, WORD length)
1404 {
1405     WMReader *This = impl_from_IWMHeaderInfo3(iface);
1406     FIXME("%p, %d, %s, %d, %p, %d\n", This, stream_num, debugstr_w(name), type, value, length);
1407     return E_NOTIMPL;
1408 }
1409
1410 static HRESULT WINAPI headerinfo_GetMarkerCount(IWMHeaderInfo3 *iface, WORD *markers)
1411 {
1412     WMReader *This = impl_from_IWMHeaderInfo3(iface);
1413     FIXME("%p, %p\n", This, markers);
1414     return E_NOTIMPL;
1415 }
1416
1417 static HRESULT WINAPI headerinfo_GetMarker(IWMHeaderInfo3 *iface, WORD index, WCHAR *marker_name,
1418         WORD *marker_len, QWORD *marker_time)
1419 {
1420     WMReader *This = impl_from_IWMHeaderInfo3(iface);
1421     FIXME("%p, %d, %p, %p, %p\n", This, index, marker_name, marker_len, marker_time);
1422     return E_NOTIMPL;
1423 }
1424
1425 static HRESULT WINAPI headerinfo_AddMarker(IWMHeaderInfo3 *iface, LPCWSTR_WMSDK_TYPE_SAFE marker_name,
1426         QWORD marker_time)
1427 {
1428     WMReader *This = impl_from_IWMHeaderInfo3(iface);
1429     FIXME("%p, %p, %s\n", This, marker_name, wine_dbgstr_longlong(marker_time));
1430     return E_NOTIMPL;
1431 }
1432
1433 static HRESULT WINAPI headerinfo_RemoveMarker(IWMHeaderInfo3 *iface, WORD index)
1434 {
1435     WMReader *This = impl_from_IWMHeaderInfo3(iface);
1436     FIXME("%p, %d\n", This, index);
1437     return E_NOTIMPL;
1438 }
1439
1440 static HRESULT WINAPI headerinfo_GetScriptCount(IWMHeaderInfo3 *iface, WORD *scripts)
1441 {
1442     WMReader *This = impl_from_IWMHeaderInfo3(iface);
1443     FIXME("%p, %p\n", This, scripts);
1444     return E_NOTIMPL;
1445 }
1446
1447 static HRESULT WINAPI headerinfo_GetScript(IWMHeaderInfo3 *iface, WORD index, WCHAR *type,
1448         WORD *type_len, WCHAR *command, WORD *command_len, QWORD *script_time)
1449 {
1450     WMReader *This = impl_from_IWMHeaderInfo3(iface);
1451     FIXME("%p, %d, %p, %p, %p, %p, %p\n", This, index, type, type_len, command, command_len, script_time);
1452     return E_NOTIMPL;
1453 }
1454
1455 static HRESULT WINAPI headerinfo_AddScript(IWMHeaderInfo3 *iface, LPCWSTR_WMSDK_TYPE_SAFE type,
1456         LPCWSTR_WMSDK_TYPE_SAFE command, QWORD script_time)
1457 {
1458     WMReader *This = impl_from_IWMHeaderInfo3(iface);
1459     FIXME("%p, %s, %s, %s\n", This, debugstr_w(type), debugstr_w(command), wine_dbgstr_longlong(script_time));
1460     return E_NOTIMPL;
1461 }
1462
1463 static HRESULT WINAPI headerinfo_RemoveScript(IWMHeaderInfo3 *iface, WORD index)
1464 {
1465     WMReader *This = impl_from_IWMHeaderInfo3(iface);
1466     FIXME("%p, %d\n", This, index);
1467     return E_NOTIMPL;
1468 }
1469
1470 static HRESULT WINAPI headerinfo_GetCodecInfoCount(IWMHeaderInfo3 *iface, DWORD *codec_infos)
1471 {
1472     WMReader *This = impl_from_IWMHeaderInfo3(iface);
1473     FIXME("%p, %p\n", This, codec_infos);
1474     return E_NOTIMPL;
1475 }
1476
1477 static HRESULT WINAPI headerinfo_GetCodecInfo(IWMHeaderInfo3 *iface, DWORD index, WORD *name_len,
1478         WCHAR *name, WORD *description_len, WCHAR *description, WMT_CODEC_INFO_TYPE *codec_type,
1479         WORD *codec_info_cnt, BYTE *codec_info)
1480 {
1481     WMReader *This = impl_from_IWMHeaderInfo3(iface);
1482     FIXME("%p, %d, %p, %p, %p, %p, %p, %p, %p\n", This, index, name_len, name, description_len,
1483             description, codec_type, codec_info_cnt, codec_info);
1484     return E_NOTIMPL;
1485 }
1486
1487 static HRESULT WINAPI headerinfo_GetAttributeCountEx(IWMHeaderInfo3 *iface, WORD stream_num, WORD *attributes)
1488 {
1489     WMReader *This = impl_from_IWMHeaderInfo3(iface);
1490     FIXME("%p, %d, %p\n", This, stream_num, attributes);
1491     return E_NOTIMPL;
1492 }
1493
1494 static HRESULT WINAPI headerinfo_GetAttributeIndices(IWMHeaderInfo3 *iface, WORD stream_num, LPCWSTR name,
1495         WORD *lang_index, WORD *indices, WORD *count)
1496 {
1497     WMReader *This = impl_from_IWMHeaderInfo3(iface);
1498     FIXME("%p, %d, %s, %p, %p, %p\n", This, stream_num, debugstr_w(name), lang_index, indices, count);
1499     return E_NOTIMPL;
1500 }
1501
1502 static HRESULT WINAPI headerinfo_GetAttributeByIndexEx(IWMHeaderInfo3 *iface, WORD stream_num,
1503         WORD index, LPWSTR name, WORD *name_len, WMT_ATTR_DATATYPE *type, WORD *lang_index,
1504         BYTE *value, DWORD *data_len)
1505 {
1506     WMReader *This = impl_from_IWMHeaderInfo3(iface);
1507     FIXME("%p, %d, %d, %s, %p, %p, %p, %p, %p\n", This, stream_num, index, debugstr_w(name), name_len,
1508             type, lang_index, value, data_len);
1509     return E_NOTIMPL;
1510 }
1511
1512 static HRESULT WINAPI headerinfo_ModifyAttribute(IWMHeaderInfo3 *iface, WORD stream_num,
1513         WORD index, WMT_ATTR_DATATYPE type, WORD lang_index, const BYTE *value, DWORD length)
1514 {
1515     WMReader *This = impl_from_IWMHeaderInfo3(iface);
1516     FIXME("%p, %d, %d, %d, %d, %p, %d\n", This, stream_num, index, type, lang_index, value, length);
1517     return E_NOTIMPL;
1518 }
1519
1520 static HRESULT WINAPI headerinfo_AddAttribute(IWMHeaderInfo3 *iface, WORD stream_num, LPCWSTR name,
1521         WORD *index, WMT_ATTR_DATATYPE type, WORD lang_index, const BYTE *value, DWORD length)
1522 {
1523     WMReader *This = impl_from_IWMHeaderInfo3(iface);
1524     FIXME("%p, %d, %s, %p, %d, %d, %p, %d\n", This, stream_num, debugstr_w(name), index,
1525             type, lang_index, value, length);
1526     return E_NOTIMPL;
1527 }
1528
1529 static HRESULT WINAPI headerinfo_DeleteAttribute(IWMHeaderInfo3 *iface, WORD stream_num, WORD index)
1530 {
1531     WMReader *This = impl_from_IWMHeaderInfo3(iface);
1532     FIXME("%p, %d, %d\n", This, stream_num, index);
1533     return E_NOTIMPL;
1534 }
1535
1536 static HRESULT WINAPI headerinfo_AddCodecInfo(IWMHeaderInfo3 *iface, LPCWSTR_WMSDK_TYPE_SAFE name,
1537         LPCWSTR_WMSDK_TYPE_SAFE description, WMT_CODEC_INFO_TYPE codec_type, WORD codec_info_cnt,
1538         BYTE *codec_info)
1539 {
1540     WMReader *This = impl_from_IWMHeaderInfo3(iface);
1541     FIXME("%p, %p, %p, %d, %d, %p\n", This, name, description, codec_type, codec_info_cnt,
1542             codec_info);
1543     return E_NOTIMPL;
1544 }
1545
1546 static const IWMHeaderInfo3Vtbl WMHeaderInfo3Vtbl =
1547 {
1548     headerinfo_QueryInterface,
1549     headerinfo_AddRef,
1550     headerinfo_Release,
1551     headerinfo_GetAttributeCount,
1552     headerinfo_GetAttributeByIndex,
1553     headerinfo_GetAttributeByName,
1554     headerinfo_SetAttribute,
1555     headerinfo_GetMarkerCount,
1556     headerinfo_GetMarker,
1557     headerinfo_AddMarker,
1558     headerinfo_RemoveMarker,
1559     headerinfo_GetScriptCount,
1560     headerinfo_GetScript,
1561     headerinfo_AddScript,
1562     headerinfo_RemoveScript,
1563     headerinfo_GetCodecInfoCount,
1564     headerinfo_GetCodecInfo,
1565     headerinfo_GetAttributeCountEx,
1566     headerinfo_GetAttributeIndices,
1567     headerinfo_GetAttributeByIndexEx,
1568     headerinfo_ModifyAttribute,
1569     headerinfo_AddAttribute,
1570     headerinfo_DeleteAttribute,
1571     headerinfo_AddCodecInfo
1572 };
1573
1574
1575 static inline WMReader *impl_from_IWMLanguageList(IWMLanguageList *iface)
1576 {
1577     return CONTAINING_RECORD(iface, WMReader, IWMLanguageList_iface);
1578 }
1579
1580 static HRESULT WINAPI langlist_QueryInterface(IWMLanguageList *iface, REFIID riid, void **ppv)
1581 {
1582     WMReader *This = impl_from_IWMLanguageList(iface);
1583     return IWMReader_QueryInterface(&This->IWMReader_iface, riid, ppv);
1584 }
1585
1586 static ULONG WINAPI langlist_AddRef(IWMLanguageList *iface)
1587 {
1588     WMReader *This = impl_from_IWMLanguageList(iface);
1589     return IWMReader_AddRef(&This->IWMReader_iface);
1590 }
1591
1592 static ULONG WINAPI langlist_Release(IWMLanguageList *iface)
1593 {
1594     WMReader *This = impl_from_IWMLanguageList(iface);
1595     return IWMReader_Release(&This->IWMReader_iface);
1596 }
1597
1598 static HRESULT WINAPI langlist_GetLanguageCount(IWMLanguageList *iface, WORD *count)
1599 {
1600     WMReader *This = impl_from_IWMLanguageList(iface);
1601     FIXME("%p, %p\n", This, count);
1602     return E_NOTIMPL;
1603 }
1604
1605 static HRESULT WINAPI langlist_GetLanguageDetails(IWMLanguageList *iface, WORD index,
1606         WCHAR *language, WORD *length)
1607 {
1608     WMReader *This = impl_from_IWMLanguageList(iface);
1609     FIXME("%p, %d, %p, %p\n", This, index, language, length);
1610     return E_NOTIMPL;
1611 }
1612
1613 static HRESULT WINAPI langlist_AddLanguageByRFC1766String(IWMLanguageList *iface, LPCWSTR_WMSDK_TYPE_SAFE language,
1614         WORD *index)
1615 {
1616     WMReader *This = impl_from_IWMLanguageList(iface);
1617     FIXME("%p, %p, %p\n", This, language, index);
1618     return E_NOTIMPL;
1619 }
1620
1621 static const IWMLanguageListVtbl WMLanguageListVtbl =
1622 {
1623     langlist_QueryInterface,
1624     langlist_AddRef,
1625     langlist_Release,
1626     langlist_GetLanguageCount,
1627     langlist_GetLanguageDetails,
1628     langlist_AddLanguageByRFC1766String
1629 };
1630
1631 static inline WMReader *impl_from_IReferenceClock(IReferenceClock *iface)
1632 {
1633     return CONTAINING_RECORD(iface, WMReader, IReferenceClock_iface);
1634 }
1635
1636 static HRESULT WINAPI refclock_QueryInterface(IReferenceClock *iface, REFIID riid, void **ppv)
1637 {
1638     WMReader *This = impl_from_IReferenceClock(iface);
1639     return IWMReader_QueryInterface(&This->IWMReader_iface, riid, ppv);
1640 }
1641
1642 static ULONG WINAPI refclock_AddRef(IReferenceClock *iface)
1643 {
1644     WMReader *This = impl_from_IReferenceClock(iface);
1645     return IWMReader_AddRef(&This->IWMReader_iface);
1646 }
1647
1648 static ULONG WINAPI refclock_Release(IReferenceClock *iface)
1649 {
1650     WMReader *This = impl_from_IReferenceClock(iface);
1651     return IWMReader_Release(&This->IWMReader_iface);
1652 }
1653
1654 static HRESULT WINAPI refclock_GetTime(IReferenceClock *iface, REFERENCE_TIME *time)
1655 {
1656     WMReader *This = impl_from_IReferenceClock(iface);
1657     FIXME("%p, %p\n", This, time);
1658     return E_NOTIMPL;
1659 }
1660
1661 static HRESULT WINAPI refclock_AdviseTime(IReferenceClock *iface, REFERENCE_TIME basetime,
1662         REFERENCE_TIME streamtime, HEVENT event, DWORD_PTR *cookie)
1663 {
1664     WMReader *This = impl_from_IReferenceClock(iface);
1665     FIXME("%p, %s, %s, %lu, %p\n", This, wine_dbgstr_longlong(basetime),
1666             wine_dbgstr_longlong(streamtime), event, cookie);
1667     return E_NOTIMPL;
1668 }
1669
1670 static HRESULT WINAPI refclock_AdvisePeriodic(IReferenceClock *iface, REFERENCE_TIME starttime,
1671         REFERENCE_TIME period, HSEMAPHORE semaphore, DWORD_PTR *cookie)
1672 {
1673     WMReader *This = impl_from_IReferenceClock(iface);
1674     FIXME("%p, %s, %s, %lu, %p\n", This, wine_dbgstr_longlong(starttime),
1675             wine_dbgstr_longlong(period), semaphore, cookie);
1676     return E_NOTIMPL;
1677 }
1678
1679 static HRESULT WINAPI refclock_Unadvise(IReferenceClock *iface, DWORD_PTR cookie)
1680 {
1681     WMReader *This = impl_from_IReferenceClock(iface);
1682     FIXME("%p, %lu\n", This, cookie);
1683     return E_NOTIMPL;
1684 }
1685
1686 static const IReferenceClockVtbl ReferenceClockVtbl =
1687 {
1688     refclock_QueryInterface,
1689     refclock_AddRef,
1690     refclock_Release,
1691     refclock_GetTime,
1692     refclock_AdviseTime,
1693     refclock_AdvisePeriodic,
1694     refclock_Unadvise
1695 };
1696
1697 static inline WMReader *impl_from_IWMProfile3(IWMProfile3 *iface)
1698 {
1699     return CONTAINING_RECORD(iface, WMReader, IWMProfile3_iface);
1700 }
1701
1702 static HRESULT WINAPI profile3_QueryInterface(IWMProfile3 *iface, REFIID riid, void **ppv)
1703 {
1704     WMReader *This = impl_from_IWMProfile3(iface);
1705     return IWMReader_QueryInterface(&This->IWMReader_iface, riid, ppv);
1706 }
1707
1708 static ULONG WINAPI profile3_AddRef(IWMProfile3 *iface)
1709 {
1710     WMReader *This = impl_from_IWMProfile3(iface);
1711     return IWMReader_AddRef(&This->IWMReader_iface);
1712 }
1713
1714 static ULONG WINAPI profile3_Release(IWMProfile3 *iface)
1715 {
1716     WMReader *This = impl_from_IWMProfile3(iface);
1717     return IWMReader_Release(&This->IWMReader_iface);
1718 }
1719
1720 static HRESULT WINAPI profile3_GetVersion(IWMProfile3 *iface, WMT_VERSION *version)
1721 {
1722     WMReader *This = impl_from_IWMProfile3(iface);
1723     FIXME("%p, %p\n", This, version);
1724     return E_NOTIMPL;
1725 }
1726
1727 static HRESULT WINAPI profile3_GetName(IWMProfile3 *iface, WCHAR *name, DWORD *length)
1728 {
1729     WMReader *This = impl_from_IWMProfile3(iface);
1730     FIXME("%p, %p, %p\n", This, name, length);
1731     return E_NOTIMPL;
1732 }
1733
1734 static HRESULT WINAPI profile3_SetName(IWMProfile3 *iface, const WCHAR *name)
1735 {
1736     WMReader *This = impl_from_IWMProfile3(iface);
1737     FIXME("%p, %s\n", This, debugstr_w(name));
1738     return E_NOTIMPL;
1739 }
1740
1741 static HRESULT WINAPI profile3_GetDescription(IWMProfile3 *iface, WCHAR *description, DWORD *length)
1742 {
1743     WMReader *This = impl_from_IWMProfile3(iface);
1744     FIXME("%p, %p, %p\n", This, description, length);
1745     return E_NOTIMPL;
1746 }
1747
1748 static HRESULT WINAPI profile3_SetDescription(IWMProfile3 *iface, const WCHAR *description)
1749 {
1750     WMReader *This = impl_from_IWMProfile3(iface);
1751     FIXME("%p, %s\n", This, debugstr_w(description));
1752     return E_NOTIMPL;
1753 }
1754
1755 static HRESULT WINAPI profile3_GetStreamCount(IWMProfile3 *iface, DWORD *count)
1756 {
1757     WMReader *This = impl_from_IWMProfile3(iface);
1758     FIXME("%p, %p\n", This, count);
1759
1760     if (!count)
1761         return E_INVALIDARG;
1762
1763     *count = 0;
1764     return S_OK;
1765 }
1766
1767 static HRESULT WINAPI profile3_GetStream(IWMProfile3 *iface, DWORD index, IWMStreamConfig **config)
1768 {
1769     WMReader *This = impl_from_IWMProfile3(iface);
1770     FIXME("%p, %d, %p\n", This, index, config);
1771     return E_NOTIMPL;
1772 }
1773
1774 static HRESULT WINAPI profile3_GetStreamByNumber(IWMProfile3 *iface, WORD stream, IWMStreamConfig **config)
1775 {
1776     WMReader *This = impl_from_IWMProfile3(iface);
1777     FIXME("%p, %d, %p\n", This, stream, config);
1778     return E_NOTIMPL;
1779 }
1780
1781 static HRESULT WINAPI profile3_RemoveStream(IWMProfile3 *iface, IWMStreamConfig *config)
1782 {
1783     WMReader *This = impl_from_IWMProfile3(iface);
1784     FIXME("%p, %p\n", This, config);
1785     return E_NOTIMPL;
1786 }
1787
1788 static HRESULT WINAPI profile3_RemoveStreamByNumber(IWMProfile3 *iface, WORD stream)
1789 {
1790     WMReader *This = impl_from_IWMProfile3(iface);
1791     FIXME("%p, %d\n", This, stream);
1792     return E_NOTIMPL;
1793 }
1794
1795 static HRESULT WINAPI profile3_AddStream(IWMProfile3 *iface, IWMStreamConfig *config)
1796 {
1797     WMReader *This = impl_from_IWMProfile3(iface);
1798     FIXME("%p, %p\n", This, config);
1799     return E_NOTIMPL;
1800 }
1801
1802 static HRESULT WINAPI profile3_ReconfigStream(IWMProfile3 *iface, IWMStreamConfig *config)
1803 {
1804     WMReader *This = impl_from_IWMProfile3(iface);
1805     FIXME("%p, %p\n", This, config);
1806     return E_NOTIMPL;
1807 }
1808
1809 static HRESULT WINAPI profile3_CreateNewStream(IWMProfile3 *iface, REFGUID type, IWMStreamConfig **config)
1810 {
1811     WMReader *This = impl_from_IWMProfile3(iface);
1812     FIXME("%p, %s, %p\n", This, debugstr_guid(type), config);
1813     return E_NOTIMPL;
1814 }
1815
1816 static HRESULT WINAPI profile3_GetMutualExclusionCount(IWMProfile3 *iface, DWORD *count)
1817 {
1818     WMReader *This = impl_from_IWMProfile3(iface);
1819     FIXME("%p, %p\n", This, count);
1820     return E_NOTIMPL;
1821 }
1822
1823 static HRESULT WINAPI profile3_GetMutualExclusion(IWMProfile3 *iface, DWORD index, IWMMutualExclusion **mutual)
1824 {
1825     WMReader *This = impl_from_IWMProfile3(iface);
1826     FIXME("%p, %d, %p\n", This, index, mutual);
1827     return E_NOTIMPL;
1828 }
1829
1830 static HRESULT WINAPI profile3_RemoveMutualExclusion(IWMProfile3 *iface, IWMMutualExclusion *mutual)
1831 {
1832     WMReader *This = impl_from_IWMProfile3(iface);
1833     FIXME("%p, %p\n", This, mutual);
1834     return E_NOTIMPL;
1835 }
1836
1837 static HRESULT WINAPI profile3_AddMutualExclusion(IWMProfile3 *iface, IWMMutualExclusion *mutual)
1838 {
1839     WMReader *This = impl_from_IWMProfile3(iface);
1840     FIXME("%p, %p\n", This, mutual);
1841     return E_NOTIMPL;
1842 }
1843
1844 static HRESULT WINAPI profile3_CreateNewMutualExclusion(IWMProfile3 *iface, IWMMutualExclusion **mutual)
1845 {
1846     WMReader *This = impl_from_IWMProfile3(iface);
1847     FIXME("%p, %p\n", This, mutual);
1848     return E_NOTIMPL;
1849 }
1850
1851 static HRESULT WINAPI profile3_GetProfileID(IWMProfile3 *iface, GUID *guid)
1852 {
1853     WMReader *This = impl_from_IWMProfile3(iface);
1854     FIXME("%p, %p\n", This, guid);
1855     return E_NOTIMPL;
1856 }
1857
1858 static HRESULT WINAPI profile3_GetStorageFormat(IWMProfile3 *iface, WMT_STORAGE_FORMAT *storage)
1859 {
1860     WMReader *This = impl_from_IWMProfile3(iface);
1861     FIXME("%p, %p\n", This, storage);
1862     return E_NOTIMPL;
1863 }
1864
1865 static HRESULT WINAPI profile3_SetStorageFormat(IWMProfile3 *iface, WMT_STORAGE_FORMAT storage)
1866 {
1867     WMReader *This = impl_from_IWMProfile3(iface);
1868     FIXME("%p, %d\n", This, storage);
1869     return E_NOTIMPL;
1870 }
1871
1872 static HRESULT WINAPI profile3_GetBandwidthSharingCount(IWMProfile3 *iface, DWORD *count)
1873 {
1874     WMReader *This = impl_from_IWMProfile3(iface);
1875     FIXME("%p, %p\n", This, count);
1876     return E_NOTIMPL;
1877 }
1878
1879 static HRESULT WINAPI profile3_GetBandwidthSharing(IWMProfile3 *iface, DWORD index, IWMBandwidthSharing **bandwidth)
1880 {
1881     WMReader *This = impl_from_IWMProfile3(iface);
1882     FIXME("%p, %d, %p\n", This, index, bandwidth);
1883     return E_NOTIMPL;
1884 }
1885
1886 static HRESULT WINAPI profile3_RemoveBandwidthSharing( IWMProfile3 *iface, IWMBandwidthSharing *bandwidth)
1887 {
1888     WMReader *This = impl_from_IWMProfile3(iface);
1889     FIXME("%p, %p\n", This, bandwidth);
1890     return E_NOTIMPL;
1891 }
1892
1893 static HRESULT WINAPI profile3_AddBandwidthSharing(IWMProfile3 *iface, IWMBandwidthSharing *bandwidth)
1894 {
1895     WMReader *This = impl_from_IWMProfile3(iface);
1896     FIXME("%p, %p\n", This, bandwidth);
1897     return E_NOTIMPL;
1898 }
1899
1900 static HRESULT WINAPI profile3_CreateNewBandwidthSharing( IWMProfile3 *iface, IWMBandwidthSharing **bandwidth)
1901 {
1902     WMReader *This = impl_from_IWMProfile3(iface);
1903     FIXME("%p, %p\n", This, bandwidth);
1904     return E_NOTIMPL;
1905 }
1906
1907 static HRESULT WINAPI profile3_GetStreamPrioritization(IWMProfile3 *iface, IWMStreamPrioritization **stream)
1908 {
1909     WMReader *This = impl_from_IWMProfile3(iface);
1910     FIXME("%p, %p\n", This, stream);
1911     return E_NOTIMPL;
1912 }
1913
1914 static HRESULT WINAPI profile3_SetStreamPrioritization(IWMProfile3 *iface, IWMStreamPrioritization *stream)
1915 {
1916     WMReader *This = impl_from_IWMProfile3(iface);
1917     FIXME("%p, %p\n", This, stream);
1918     return E_NOTIMPL;
1919 }
1920
1921 static HRESULT WINAPI profile3_RemoveStreamPrioritization(IWMProfile3 *iface)
1922 {
1923     WMReader *This = impl_from_IWMProfile3(iface);
1924     FIXME("%p\n", This);
1925     return E_NOTIMPL;
1926 }
1927
1928 static HRESULT WINAPI profile3_CreateNewStreamPrioritization(IWMProfile3 *iface, IWMStreamPrioritization **stream)
1929 {
1930     WMReader *This = impl_from_IWMProfile3(iface);
1931     FIXME("%p, %p\n", This, stream);
1932     return E_NOTIMPL;
1933 }
1934
1935 static HRESULT WINAPI profile3_GetExpectedPacketCount(IWMProfile3 *iface, QWORD duration, QWORD *packets)
1936 {
1937     WMReader *This = impl_from_IWMProfile3(iface);
1938     FIXME("%p, %s, %p\n", This, wine_dbgstr_longlong(duration), packets);
1939     return E_NOTIMPL;
1940 }
1941
1942 static const IWMProfile3Vtbl WMProfile3Vtbl =
1943 {
1944     profile3_QueryInterface,
1945     profile3_AddRef,
1946     profile3_Release,
1947     profile3_GetVersion,
1948     profile3_GetName,
1949     profile3_SetName,
1950     profile3_GetDescription,
1951     profile3_SetDescription,
1952     profile3_GetStreamCount,
1953     profile3_GetStream,
1954     profile3_GetStreamByNumber,
1955     profile3_RemoveStream,
1956     profile3_RemoveStreamByNumber,
1957     profile3_AddStream,
1958     profile3_ReconfigStream,
1959     profile3_CreateNewStream,
1960     profile3_GetMutualExclusionCount,
1961     profile3_GetMutualExclusion,
1962     profile3_RemoveMutualExclusion,
1963     profile3_AddMutualExclusion,
1964     profile3_CreateNewMutualExclusion,
1965     profile3_GetProfileID,
1966     profile3_GetStorageFormat,
1967     profile3_SetStorageFormat,
1968     profile3_GetBandwidthSharingCount,
1969     profile3_GetBandwidthSharing,
1970     profile3_RemoveBandwidthSharing,
1971     profile3_AddBandwidthSharing,
1972     profile3_CreateNewBandwidthSharing,
1973     profile3_GetStreamPrioritization,
1974     profile3_SetStreamPrioritization,
1975     profile3_RemoveStreamPrioritization,
1976     profile3_CreateNewStreamPrioritization,
1977     profile3_GetExpectedPacketCount
1978 };
1979
1980 static inline WMReader *impl_from_IWMPacketSize2(IWMPacketSize2 *iface)
1981 {
1982     return CONTAINING_RECORD(iface, WMReader, IWMPacketSize2_iface);
1983 }
1984
1985 static HRESULT WINAPI packetsize_QueryInterface(IWMPacketSize2 *iface, REFIID riid, void **ppv)
1986 {
1987     WMReader *This = impl_from_IWMPacketSize2(iface);
1988     return IWMReader_QueryInterface(&This->IWMReader_iface, riid, ppv);
1989 }
1990
1991 static ULONG WINAPI packetsize_AddRef(IWMPacketSize2 *iface)
1992 {
1993     WMReader *This = impl_from_IWMPacketSize2(iface);
1994     return IWMReader_AddRef(&This->IWMReader_iface);
1995 }
1996
1997 static ULONG WINAPI packetsize_Release(IWMPacketSize2 *iface)
1998 {
1999     WMReader *This = impl_from_IWMPacketSize2(iface);
2000     return IWMReader_Release(&This->IWMReader_iface);
2001 }
2002
2003 static HRESULT WINAPI packetsize_GetMaxPacketSize(IWMPacketSize2 *iface, DWORD *size)
2004 {
2005     WMReader *This = impl_from_IWMPacketSize2(iface);
2006     FIXME("%p, %p\n", This, size);
2007     return E_NOTIMPL;
2008 }
2009
2010 static HRESULT WINAPI packetsize_SetMaxPacketSize(IWMPacketSize2 *iface, DWORD size)
2011 {
2012     WMReader *This = impl_from_IWMPacketSize2(iface);
2013     FIXME("%p, %d\n", This, size);
2014     return E_NOTIMPL;
2015 }
2016
2017 static HRESULT WINAPI packetsize_GetMinPacketSize(IWMPacketSize2 *iface, DWORD *size)
2018 {
2019     WMReader *This = impl_from_IWMPacketSize2(iface);
2020     FIXME("%p, %p\n", This, size);
2021     return E_NOTIMPL;
2022 }
2023
2024 static HRESULT WINAPI packetsize_SetMinPacketSize(IWMPacketSize2 *iface, DWORD size)
2025 {
2026     WMReader *This = impl_from_IWMPacketSize2(iface);
2027     FIXME("%p, %d\n", This, size);
2028     return E_NOTIMPL;
2029 }
2030
2031 static const IWMPacketSize2Vtbl WMPacketSize2Vtbl =
2032 {
2033     packetsize_QueryInterface,
2034     packetsize_AddRef,
2035     packetsize_Release,
2036     packetsize_GetMaxPacketSize,
2037     packetsize_SetMaxPacketSize,
2038     packetsize_GetMinPacketSize,
2039     packetsize_SetMinPacketSize
2040 };
2041
2042 HRESULT WINAPI WMCreateReader(IUnknown *reserved, DWORD rights, IWMReader **ret_reader)
2043 {
2044     WMReader *reader;
2045
2046     TRACE("(%p, %x, %p)\n", reserved, rights, ret_reader);
2047
2048     reader = heap_alloc(sizeof(*reader));
2049     if(!reader)
2050         return E_OUTOFMEMORY;
2051
2052     reader->IWMReader_iface.lpVtbl = &WMReaderVtbl;
2053     reader->IWMReaderAdvanced6_iface.lpVtbl = &WMReaderAdvanced6Vtbl;
2054     reader->IWMReaderAccelerator_iface.lpVtbl = &WMReaderAcceleratorVtbl;
2055     reader->IWMReaderNetworkConfig2_iface.lpVtbl = &WMReaderNetworkConfig2Vtbl;
2056     reader->IWMReaderStreamClock_iface.lpVtbl = &WMReaderStreamClockVtbl;
2057     reader->IWMReaderTypeNegotiation_iface.lpVtbl = &WMReaderTypeNegotiationVtbl;
2058     reader->IWMReaderTimecode_iface.lpVtbl = &WMReaderTimecodeVtbl;
2059     reader->IWMReaderPlaylistBurn_iface.lpVtbl = &WMReaderPlaylistBurnVtbl;
2060     reader->IWMHeaderInfo3_iface.lpVtbl = &WMHeaderInfo3Vtbl;
2061     reader->IWMLanguageList_iface.lpVtbl = &WMLanguageListVtbl;
2062     reader->IReferenceClock_iface.lpVtbl = &ReferenceClockVtbl;
2063     reader->IWMProfile3_iface.lpVtbl = &WMProfile3Vtbl;
2064     reader->IWMPacketSize2_iface.lpVtbl = &WMPacketSize2Vtbl;
2065     reader->ref = 1;
2066
2067     *ret_reader = &reader->IWMReader_iface;
2068     return S_OK;
2069 }
2070
2071 HRESULT WINAPI WMCreateReaderPriv(IWMReader **ret_reader)
2072 {
2073     return WMCreateReader(NULL, 0, ret_reader);
2074 }