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