dlls/wmvcore/wmvcore_main.c

   1 /*
   2  * Copyright 2012 Austin English
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include "wmvcore.h"
  20
  21 #include "initguid.h"
  22 #include "wmsdk.h"
  23 #include "wine/debug.h"
  24
  25 WINE_DEFAULT_DEBUG_CHANNEL(wmvcore);
  26
  27 BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
  28 {
  29     TRACE("(0x%p, %d, %p)\n", hinstDLL, fdwReason, lpvReserved);
  30
  31     switch (fdwReason)
  32     {
  33         case DLL_WINE_PREATTACH:
  34             return FALSE;    /* prefer native version */
  35         case DLL_PROCESS_ATTACH:
  36             DisableThreadLibraryCalls(hinstDLL);
  37             break;
  38     }
  39
  40     return TRUE;
  41 }
  42
  43 HRESULT WINAPI DllRegisterServer(void)
  44 {
  45     FIXME("(): stub\n");
  46
  47     return S_OK;
  48 }
  49
  50 HRESULT WINAPI WMCheckURLScheme(const WCHAR *scheme)
  51 {
  52     FIXME("(%s): stub\n", wine_dbgstr_w(scheme));
  53
  54     return NS_E_INVALID_NAME;
  55 }
  56
  57 HRESULT WINAPI WMCreateEditor(IWMMetadataEditor **editor)
  58 {
  59     FIXME("(%p): stub\n", editor);
  60
  61     *editor = NULL;
  62
  63     return E_NOTIMPL;
  64 }
  65
  66 typedef struct {
  67     IWMReader IWMReader_iface;
  68     IWMReaderAdvanced6 IWMReaderAdvanced6_iface;
  69     IWMReaderAccelerator IWMReaderAccelerator_iface;
  70     LONG ref;
  71 } WMReader;
  72
  73 static inline WMReader *impl_from_IWMReader(IWMReader *iface)
  74 {
  75     return CONTAINING_RECORD(iface, WMReader, IWMReader_iface);
  76 }
  77
  78 static HRESULT WINAPI WMReader_QueryInterface(IWMReader *iface, REFIID riid, void **ppv)
  79 {
  80     WMReader *This = impl_from_IWMReader(iface);
  81
  82     if(IsEqualGUID(riid, &IID_IUnknown)) {
  83         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
  84         *ppv = &This->IWMReader_iface;
  85     }else if(IsEqualGUID(riid, &IID_IWMReader)) {
  86         TRACE("(%p)->(IID_IWMReader %p)\n", This, ppv);
  87         *ppv = &This->IWMReader_iface;
  88     }else if(IsEqualGUID(riid, &IID_IWMReaderAdvanced)) {
  89         TRACE("(%p)->(IID_IWMReaderAdvanced %p)\n", This, ppv);
  90         *ppv = &This->IWMReaderAdvanced6_iface;
  91     }else if(IsEqualGUID(riid, &IID_IWMReaderAdvanced2)) {
  92         TRACE("(%p)->(IID_IWMReaderAdvanced2 %p)\n", This, ppv);
  93         *ppv = &This->IWMReaderAdvanced6_iface;
  94     }else if(IsEqualGUID(riid, &IID_IWMReaderAdvanced3)) {
  95         TRACE("(%p)->(IID_IWMReaderAdvanced3 %p)\n", This, ppv);
  96         *ppv = &This->IWMReaderAdvanced6_iface;
  97     }else if(IsEqualGUID(riid, &IID_IWMReaderAdvanced4)) {
  98         TRACE("(%p)->(IID_IWMReaderAdvanced4 %p)\n", This, ppv);
  99         *ppv = &This->IWMReaderAdvanced6_iface;
 100     }else if(IsEqualGUID(riid, &IID_IWMReaderAdvanced5)) {
 101         TRACE("(%p)->(IID_IWMReaderAdvanced5 %p)\n", This, ppv);
 102         *ppv = &This->IWMReaderAdvanced6_iface;
 103     }else if(IsEqualGUID(riid, &IID_IWMReaderAdvanced6)) {
 104         TRACE("(%p)->(IID_IWMReaderAdvanced6 %p)\n", This, ppv);
 105         *ppv = &This->IWMReaderAdvanced6_iface;
 106     }else if(IsEqualGUID(riid, &IID_IWMReaderAccelerator)) {
 107         TRACE("(%p)->(IID_IWMReaderAccelerator %p)\n", This, ppv);
 108         *ppv = &This->IWMReaderAccelerator_iface;
 109     }else {
 110         *ppv = NULL;
 111         FIXME("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
 112         return E_NOINTERFACE;
 113     }
 114
 115     IUnknown_AddRef((IUnknown*)*ppv);
 116     return S_OK;
 117 }
 118
 119 static ULONG WINAPI WMReader_AddRef(IWMReader *iface)
 120 {
 121     WMReader *This = impl_from_IWMReader(iface);
 122     LONG ref = InterlockedIncrement(&This->ref);
 123
 124     TRACE("(%p) ref=%d\n", This, ref);
 125
 126     return ref;
 127 }
 128
 129 static ULONG WINAPI WMReader_Release(IWMReader *iface)
 130 {
 131     WMReader *This = impl_from_IWMReader(iface);
 132     LONG ref = InterlockedDecrement(&This->ref);
 133
 134     TRACE("(%p) ref=%d\n", This, ref);
 135
 136     if(!ref)
 137         heap_free(This);
 138
 139     return ref;
 140 }
 141
 142 static HRESULT WINAPI WMReader_Open(IWMReader *iface, const WCHAR *url, IWMReaderCallback *callback, void *context)
 143 {
 144     WMReader *This = impl_from_IWMReader(iface);
 145     FIXME("(%p)->(%s %p %p)\n", This, debugstr_w(url), callback, context);
 146     return E_NOTIMPL;
 147 }
 148
 149 static HRESULT WINAPI WMReader_Close(IWMReader *iface)
 150 {
 151     WMReader *This = impl_from_IWMReader(iface);
 152     FIXME("(%p)\n", This);
 153     return E_NOTIMPL;
 154 }
 155
 156 static HRESULT WINAPI WMReader_GetOutputCount(IWMReader *iface, DWORD *outputs)
 157 {
 158     WMReader *This = impl_from_IWMReader(iface);
 159     FIXME("(%p)->(%p)\n", This, outputs);
 160     return E_NOTIMPL;
 161 }
 162
 163 static HRESULT WINAPI WMReader_GetOutputProps(IWMReader *iface, DWORD output_num, IWMOutputMediaProps **output)
 164 {
 165     WMReader *This = impl_from_IWMReader(iface);
 166     FIXME("(%p)->(%u %p)\n", This, output_num, output);
 167     return E_NOTIMPL;
 168 }
 169
 170 static HRESULT WINAPI WMReader_SetOutputProps(IWMReader *iface, DWORD output_num, IWMOutputMediaProps *output)
 171 {
 172     WMReader *This = impl_from_IWMReader(iface);
 173     FIXME("(%p)->(%u %p)\n", This, output_num, output);
 174     return E_NOTIMPL;
 175 }
 176
 177 static HRESULT WINAPI WMReader_GetOutputFormatCount(IWMReader *iface, DWORD output_num, DWORD *formats)
 178 {
 179     WMReader *This = impl_from_IWMReader(iface);
 180     FIXME("(%p)->(%u %p)\n", This, output_num, formats);
 181     return E_NOTIMPL;
 182 }
 183
 184 static HRESULT WINAPI WMReader_GetOutputFormat(IWMReader *iface, DWORD output_num, DWORD format_num, IWMOutputMediaProps **props)
 185 {
 186     WMReader *This = impl_from_IWMReader(iface);
 187     FIXME("(%p)->(%u %u %p)\n", This, output_num, format_num, props);
 188     return E_NOTIMPL;
 189 }
 190
 191 static HRESULT WINAPI WMReader_Start(IWMReader *iface, QWORD start, QWORD duration, float rate, void *context)
 192 {
 193     WMReader *This = impl_from_IWMReader(iface);
 194     FIXME("(%p)->(%s %s %f %p)\n", This, wine_dbgstr_longlong(start), wine_dbgstr_longlong(duration), rate, context);
 195     return E_NOTIMPL;
 196 }
 197
 198 static HRESULT WINAPI WMReader_Stop(IWMReader *iface)
 199 {
 200     WMReader *This = impl_from_IWMReader(iface);
 201     FIXME("(%p)\n", This);
 202     return E_NOTIMPL;
 203 }
 204
 205 static HRESULT WINAPI WMReader_Pause(IWMReader *iface)
 206 {
 207     WMReader *This = impl_from_IWMReader(iface);
 208     FIXME("(%p)\n", This);
 209     return E_NOTIMPL;
 210 }
 211
 212 static HRESULT WINAPI WMReader_Resume(IWMReader *iface)
 213 {
 214     WMReader *This = impl_from_IWMReader(iface);
 215     FIXME("(%p)\n", This);
 216     return E_NOTIMPL;
 217 }
 218
 219 static const IWMReaderVtbl WMReaderVtbl = {
 220     WMReader_QueryInterface,
 221     WMReader_AddRef,
 222     WMReader_Release,
 223     WMReader_Open,
 224     WMReader_Close,
 225     WMReader_GetOutputCount,
 226     WMReader_GetOutputProps,
 227     WMReader_SetOutputProps,
 228     WMReader_GetOutputFormatCount,
 229     WMReader_GetOutputFormat,
 230     WMReader_Start,
 231     WMReader_Stop,
 232     WMReader_Pause,
 233     WMReader_Resume
 234 };
 235
 236 static inline WMReader *impl_from_IWMReaderAdvanced6(IWMReaderAdvanced6 *iface)
 237 {
 238     return CONTAINING_RECORD(iface, WMReader, IWMReaderAdvanced6_iface);
 239 }
 240
 241 static HRESULT WINAPI WMReaderAdvanced_QueryInterface(IWMReaderAdvanced6 *iface, REFIID riid, void **ppv)
 242 {
 243     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 244     return IWMReader_QueryInterface(&This->IWMReader_iface, riid, ppv);
 245 }
 246
 247 static ULONG WINAPI WMReaderAdvanced_AddRef(IWMReaderAdvanced6 *iface)
 248 {
 249     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 250     return IWMReader_AddRef(&This->IWMReader_iface);
 251 }
 252
 253 static ULONG WINAPI WMReaderAdvanced_Release(IWMReaderAdvanced6 *iface)
 254 {
 255     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 256     return IWMReader_Release(&This->IWMReader_iface);
 257 }
 258
 259 static HRESULT WINAPI WMReaderAdvanced_SetUserProvidedClock(IWMReaderAdvanced6 *iface, BOOL user_clock)
 260 {
 261     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 262     FIXME("(%p)->(%x)\n", This, user_clock);
 263     return E_NOTIMPL;
 264 }
 265
 266 static HRESULT WINAPI WMReaderAdvanced_GetUserProvidedClock(IWMReaderAdvanced6 *iface, BOOL *user_clock)
 267 {
 268     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 269     FIXME("(%p)->(%p)\n", This, user_clock);
 270     return E_NOTIMPL;
 271 }
 272
 273 static HRESULT WINAPI WMReaderAdvanced_DeliverTime(IWMReaderAdvanced6 *iface, QWORD time)
 274 {
 275     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 276     FIXME("(%p)->(%s)\n", This, wine_dbgstr_longlong(time));
 277     return E_NOTIMPL;
 278 }
 279
 280 static HRESULT WINAPI WMReaderAdvanced_SetManualStreamSelection(IWMReaderAdvanced6 *iface, BOOL selection)
 281 {
 282     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 283     FIXME("(%p)->(%x)\n", This, selection);
 284     return E_NOTIMPL;
 285 }
 286
 287 static HRESULT WINAPI WMReaderAdvanced_GetManualStreamSelection(IWMReaderAdvanced6 *iface, BOOL *selection)
 288 {
 289     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 290     FIXME("(%p)->(%p)\n", This, selection);
 291     return E_NOTIMPL;
 292 }
 293
 294 static HRESULT WINAPI WMReaderAdvanced_SetStreamsSelected(IWMReaderAdvanced6 *iface, WORD stream_count,
 295         WORD *stream_numbers, WMT_STREAM_SELECTION *selections)
 296 {
 297     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 298     FIXME("(%p)->(%d %p %p)\n", This, stream_count, stream_numbers, selections);
 299     return E_NOTIMPL;
 300 }
 301
 302 static HRESULT WINAPI WMReaderAdvanced_GetStreamSelected(IWMReaderAdvanced6 *iface, WORD stream_num,
 303         WMT_STREAM_SELECTION *selection)
 304 {
 305     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 306     FIXME("(%p)->(%d %p)\n", This, stream_num, selection);
 307     return E_NOTIMPL;
 308 }
 309
 310 static HRESULT WINAPI WMReaderAdvanced_SetReceiveSelectionCallbacks(IWMReaderAdvanced6 *iface, BOOL get_callbacks)
 311 {
 312     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 313     FIXME("(%p)->(%x)\n", This, get_callbacks);
 314     return E_NOTIMPL;
 315 }
 316
 317 static HRESULT WINAPI WMReaderAdvanced_GetReceiveSelectionCallbacks(IWMReaderAdvanced6 *iface, BOOL *get_callbacks)
 318 {
 319     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 320     FIXME("(%p)->(%p)\n", This, get_callbacks);
 321     return E_NOTIMPL;
 322 }
 323
 324 static HRESULT WINAPI WMReaderAdvanced_SetReceiveStreamSamples(IWMReaderAdvanced6 *iface, WORD stream_num,
 325         BOOL receive_stream_samples)
 326 {
 327     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 328     FIXME("(%p)->(%d %x)\n", This, stream_num, receive_stream_samples);
 329     return E_NOTIMPL;
 330 }
 331
 332 static HRESULT WINAPI WMReaderAdvanced_GetReceiveStreamSamples(IWMReaderAdvanced6 *iface, WORD stream_num,
 333         BOOL *receive_stream_samples)
 334 {
 335     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 336     FIXME("(%p)->(%d %p)\n", This, stream_num, receive_stream_samples);
 337     return E_NOTIMPL;
 338 }
 339
 340 static HRESULT WINAPI WMReaderAdvanced_SetAllocateForOutput(IWMReaderAdvanced6 *iface, DWORD output_num, BOOL allocate)
 341 {
 342     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 343     FIXME("(%p)->(%d %x)\n", This, output_num, allocate);
 344     return E_NOTIMPL;
 345 }
 346
 347 static HRESULT WINAPI WMReaderAdvanced_GetAllocateForOutput(IWMReaderAdvanced6 *iface, DWORD output_num, BOOL *allocate)
 348 {
 349     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 350     FIXME("(%p)->(%d %p)\n", This, output_num, allocate);
 351     return E_NOTIMPL;
 352 }
 353
 354 static HRESULT WINAPI WMReaderAdvanced_SetAllocateForStream(IWMReaderAdvanced6 *iface, WORD output_num, BOOL allocate)
 355 {
 356     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 357     FIXME("(%p)->(%d %x)\n", This, output_num, allocate);
 358     return E_NOTIMPL;
 359 }
 360
 361 static HRESULT WINAPI WMReaderAdvanced_GetAllocateForStream(IWMReaderAdvanced6 *iface, WORD output_num, BOOL *allocate)
 362 {
 363     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 364     FIXME("(%p)->(%d %p)\n", This, output_num, allocate);
 365     return E_NOTIMPL;
 366 }
 367
 368 static HRESULT WINAPI WMReaderAdvanced_GetStatistics(IWMReaderAdvanced6 *iface, WM_READER_STATISTICS *statistics)
 369 {
 370     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 371     FIXME("(%p)->(%p)\n", This, statistics);
 372     return E_NOTIMPL;
 373 }
 374
 375 static HRESULT WINAPI WMReaderAdvanced_SetClientInfo(IWMReaderAdvanced6 *iface, WM_READER_CLIENTINFO *client_info)
 376 {
 377     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 378     FIXME("(%p)->(%p)\n", This, client_info);
 379     return E_NOTIMPL;
 380 }
 381
 382 static HRESULT WINAPI WMReaderAdvanced_GetMaxOutputSampleSize(IWMReaderAdvanced6 *iface, DWORD output, DWORD *max)
 383 {
 384     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 385     FIXME("(%p)->(%d %p)\n", This, output, max);
 386     return E_NOTIMPL;
 387 }
 388
 389 static HRESULT WINAPI WMReaderAdvanced_GetMaxStreamSampleSize(IWMReaderAdvanced6 *iface, WORD stream, DWORD *max)
 390 {
 391     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 392     FIXME("(%p)->(%d %p)\n", This, stream, max);
 393     return E_NOTIMPL;
 394 }
 395
 396 static HRESULT WINAPI WMReaderAdvanced_NotifyLateDelivery(IWMReaderAdvanced6 *iface, QWORD lateness)
 397 {
 398     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 399     FIXME("(%p)->(%s)\n", This, wine_dbgstr_longlong(lateness));
 400     return E_NOTIMPL;
 401 }
 402
 403 static HRESULT WINAPI WMReaderAdvanced2_SetPlayMode(IWMReaderAdvanced6 *iface, WMT_PLAY_MODE mode)
 404 {
 405     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 406     FIXME("(%p)->(%d)\n", This, mode);
 407     return E_NOTIMPL;
 408 }
 409
 410 static HRESULT WINAPI WMReaderAdvanced2_GetPlayMode(IWMReaderAdvanced6 *iface, WMT_PLAY_MODE *mode)
 411 {
 412     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 413     FIXME("(%p)->(%p)\n", This, mode);
 414     return E_NOTIMPL;
 415 }
 416
 417 static HRESULT WINAPI WMReaderAdvanced2_GetBufferProgress(IWMReaderAdvanced6 *iface, DWORD *percent, QWORD *buffering)
 418 {
 419     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 420     FIXME("(%p)->(%p %p)\n", This, percent, buffering);
 421     return E_NOTIMPL;
 422 }
 423
 424 static HRESULT WINAPI WMReaderAdvanced2_GetDownloadProgress(IWMReaderAdvanced6 *iface, DWORD *percent,
 425         QWORD *bytes_downloaded, QWORD *download)
 426 {
 427     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 428     FIXME("(%p)->(%p %p %p)\n", This, percent, bytes_downloaded, download);
 429     return E_NOTIMPL;
 430 }
 431
 432 static HRESULT WINAPI WMReaderAdvanced2_GetSaveAsProgress(IWMReaderAdvanced6 *iface, DWORD *percent)
 433 {
 434     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 435     FIXME("(%p)->(%p)\n", This, percent);
 436     return E_NOTIMPL;
 437 }
 438
 439 static HRESULT WINAPI WMReaderAdvanced2_SaveFileAs(IWMReaderAdvanced6 *iface, const WCHAR *filename)
 440 {
 441     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 442     FIXME("(%p)->(%s)\n", This, debugstr_w(filename));
 443     return E_NOTIMPL;
 444 }
 445
 446 static HRESULT WINAPI WMReaderAdvanced2_GetProtocolName(IWMReaderAdvanced6 *iface, WCHAR *protocol, DWORD *protocol_len)
 447 {
 448     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 449     FIXME("(%p)->(%p %p)\n", This, protocol, protocol_len);
 450     return E_NOTIMPL;
 451 }
 452
 453 static HRESULT WINAPI WMReaderAdvanced2_StartAtMarker(IWMReaderAdvanced6 *iface, WORD marker_index,
 454         QWORD duration, float rate, void *context)
 455 {
 456     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 457     FIXME("(%p)->(%d %s %f %p)\n", This, marker_index, wine_dbgstr_longlong(duration), rate, context);
 458     return E_NOTIMPL;
 459 }
 460
 461 static HRESULT WINAPI WMReaderAdvanced2_GetOutputSetting(IWMReaderAdvanced6 *iface, DWORD output_num,
 462         const WCHAR *name, WMT_ATTR_DATATYPE *type, BYTE *value, WORD *length)
 463 {
 464     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 465     FIXME("(%p)->(%d %s %p %p %p)\n", This, output_num, debugstr_w(name), type, value, length);
 466     return E_NOTIMPL;
 467 }
 468
 469 static HRESULT WINAPI WMReaderAdvanced2_SetOutputSetting(IWMReaderAdvanced6 *iface, DWORD output_num,
 470         const WCHAR *name, WMT_ATTR_DATATYPE type, const BYTE *value, WORD length)
 471 {
 472     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 473     FIXME("(%p)->(%d %s %d %p %d)\n", This, output_num, debugstr_w(name), type, value, length);
 474     return E_NOTIMPL;
 475 }
 476
 477 static HRESULT WINAPI WMReaderAdvanced2_Preroll(IWMReaderAdvanced6 *iface, QWORD start, QWORD duration, float rate)
 478 {
 479     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 480     FIXME("(%p)->(%s %s %f)\n", This, wine_dbgstr_longlong(start), wine_dbgstr_longlong(duration), rate);
 481     return E_NOTIMPL;
 482 }
 483
 484 static HRESULT WINAPI WMReaderAdvanced2_SetLogClientID(IWMReaderAdvanced6 *iface, BOOL log_client_id)
 485 {
 486     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 487     FIXME("(%p)->(%x)\n", This, log_client_id);
 488     return E_NOTIMPL;
 489 }
 490
 491 static HRESULT WINAPI WMReaderAdvanced2_GetLogClientID(IWMReaderAdvanced6 *iface, BOOL *log_client_id)
 492 {
 493     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 494     FIXME("(%p)->(%p)\n", This, log_client_id);
 495     return E_NOTIMPL;
 496 }
 497
 498 static HRESULT WINAPI WMReaderAdvanced2_StopBuffering(IWMReaderAdvanced6 *iface)
 499 {
 500     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 501     FIXME("(%p)\n", This);
 502     return E_NOTIMPL;
 503 }
 504
 505 static HRESULT WINAPI WMReaderAdvanced2_OpenStream(IWMReaderAdvanced6 *iface, IStream *stream,
 506         IWMReaderCallback *callback, void *context)
 507 {
 508     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 509     FIXME("(%p)->(%p %p %p)\n", This, stream, callback, context);
 510     return E_NOTIMPL;
 511 }
 512
 513 static HRESULT WINAPI WMReaderAdvanced3_StopNetStreaming(IWMReaderAdvanced6 *iface)
 514 {
 515     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 516     FIXME("(%p)\n", This);
 517     return E_NOTIMPL;
 518 }
 519
 520 static HRESULT WINAPI WMReaderAdvanced3_StartAtPosition(IWMReaderAdvanced6 *iface, WORD stream_num,
 521         void *offset_start, void *duration, WMT_OFFSET_FORMAT format, float rate, void *context)
 522 {
 523     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 524     FIXME("(%p)->(%d %p %p %d %f %p)\n", This, stream_num, offset_start, duration, format, rate, context);
 525     return E_NOTIMPL;
 526 }
 527
 528 static HRESULT WINAPI WMReaderAdvanced4_GetLanguageCount(IWMReaderAdvanced6 *iface, DWORD output_num, WORD *language_count)
 529 {
 530     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 531     FIXME("(%p)->(%d %p)\n", This, output_num, language_count);
 532     return E_NOTIMPL;
 533 }
 534
 535 static HRESULT WINAPI WMReaderAdvanced4_GetLanguage(IWMReaderAdvanced6 *iface, DWORD output_num,
 536        WORD language, WCHAR *language_string, WORD *language_string_len)
 537 {
 538     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 539     FIXME("(%p)->(%d %x %p %p)\n", This, output_num, language, language_string, language_string_len);
 540     return E_NOTIMPL;
 541 }
 542
 543 static HRESULT WINAPI WMReaderAdvanced4_GetMaxSpeedFactor(IWMReaderAdvanced6 *iface, double *factor)
 544 {
 545     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 546     FIXME("(%p)->(%p)\n", This, factor);
 547     return E_NOTIMPL;
 548 }
 549
 550 static HRESULT WINAPI WMReaderAdvanced4_IsUsingFastCache(IWMReaderAdvanced6 *iface, BOOL *using_fast_cache)
 551 {
 552     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 553     FIXME("(%p)->(%p)\n", This, using_fast_cache);
 554     return E_NOTIMPL;
 555 }
 556
 557 static HRESULT WINAPI WMReaderAdvanced4_AddLogParam(IWMReaderAdvanced6 *iface, const WCHAR *namespace,
 558         const WCHAR *name, const WCHAR *value)
 559 {
 560     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 561     FIXME("(%p)->(%s %s %s)\n", This, debugstr_w(namespace), debugstr_w(name), debugstr_w(value));
 562     return E_NOTIMPL;
 563 }
 564
 565 static HRESULT WINAPI WMReaderAdvanced4_SendLogParams(IWMReaderAdvanced6 *iface)
 566 {
 567     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 568     FIXME("(%p)\n", This);
 569     return E_NOTIMPL;
 570 }
 571
 572 static HRESULT WINAPI WMReaderAdvanced4_CanSaveFileAs(IWMReaderAdvanced6 *iface, BOOL *can_save)
 573 {
 574     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 575     FIXME("(%p)->(%p)\n", This, can_save);
 576     return E_NOTIMPL;
 577 }
 578
 579 static HRESULT WINAPI WMReaderAdvanced4_CancelSaveFileAs(IWMReaderAdvanced6 *iface)
 580 {
 581     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 582     FIXME("(%p)\n", This);
 583     return E_NOTIMPL;
 584 }
 585
 586 static HRESULT WINAPI WMReaderAdvanced4_GetURL(IWMReaderAdvanced6 *iface, WCHAR *url, DWORD *url_len)
 587 {
 588     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 589     FIXME("(%p)->(%p %p)\n", This, url, url_len);
 590     return E_NOTIMPL;
 591 }
 592
 593 static HRESULT WINAPI WMReaderAdvanced5_SetPlayerHook(IWMReaderAdvanced6 *iface, DWORD output_num, IWMPlayerHook *hook)
 594 {
 595     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 596     FIXME("(%p)->(%d %p)\n", This, output_num, hook);
 597     return E_NOTIMPL;
 598 }
 599
 600 static HRESULT WINAPI WMReaderAdvanced6_SetProtextStreamSamples(IWMReaderAdvanced6 *iface, BYTE *cert,
 601         DWORD cert_size, DWORD cert_type, DWORD flags, BYTE *initialization_vector, DWORD *initialization_vector_size)
 602 {
 603     WMReader *This = impl_from_IWMReaderAdvanced6(iface);
 604     FIXME("(%p)->(%p %d %d %x %p %p)\n", This, cert, cert_size, cert_type, flags, initialization_vector,
 605           initialization_vector_size);
 606     return E_NOTIMPL;
 607 }
 608
 609 static const IWMReaderAdvanced6Vtbl WMReaderAdvanced6Vtbl = {
 610     WMReaderAdvanced_QueryInterface,
 611     WMReaderAdvanced_AddRef,
 612     WMReaderAdvanced_Release,
 613     WMReaderAdvanced_SetUserProvidedClock,
 614     WMReaderAdvanced_GetUserProvidedClock,
 615     WMReaderAdvanced_DeliverTime,
 616     WMReaderAdvanced_SetManualStreamSelection,
 617     WMReaderAdvanced_GetManualStreamSelection,
 618     WMReaderAdvanced_SetStreamsSelected,
 619     WMReaderAdvanced_GetStreamSelected,
 620     WMReaderAdvanced_SetReceiveSelectionCallbacks,
 621     WMReaderAdvanced_GetReceiveSelectionCallbacks,
 622     WMReaderAdvanced_SetReceiveStreamSamples,
 623     WMReaderAdvanced_GetReceiveStreamSamples,
 624     WMReaderAdvanced_SetAllocateForOutput,
 625     WMReaderAdvanced_GetAllocateForOutput,
 626     WMReaderAdvanced_SetAllocateForStream,
 627     WMReaderAdvanced_GetAllocateForStream,
 628     WMReaderAdvanced_GetStatistics,
 629     WMReaderAdvanced_SetClientInfo,
 630     WMReaderAdvanced_GetMaxOutputSampleSize,
 631     WMReaderAdvanced_GetMaxStreamSampleSize,
 632     WMReaderAdvanced_NotifyLateDelivery,
 633     WMReaderAdvanced2_SetPlayMode,
 634     WMReaderAdvanced2_GetPlayMode,
 635     WMReaderAdvanced2_GetBufferProgress,
 636     WMReaderAdvanced2_GetDownloadProgress,
 637     WMReaderAdvanced2_GetSaveAsProgress,
 638     WMReaderAdvanced2_SaveFileAs,
 639     WMReaderAdvanced2_GetProtocolName,
 640     WMReaderAdvanced2_StartAtMarker,
 641     WMReaderAdvanced2_GetOutputSetting,
 642     WMReaderAdvanced2_SetOutputSetting,
 643     WMReaderAdvanced2_Preroll,
 644     WMReaderAdvanced2_SetLogClientID,
 645     WMReaderAdvanced2_GetLogClientID,
 646     WMReaderAdvanced2_StopBuffering,
 647     WMReaderAdvanced2_OpenStream,
 648     WMReaderAdvanced3_StopNetStreaming,
 649     WMReaderAdvanced3_StartAtPosition,
 650     WMReaderAdvanced4_GetLanguageCount,
 651     WMReaderAdvanced4_GetLanguage,
 652     WMReaderAdvanced4_GetMaxSpeedFactor,
 653     WMReaderAdvanced4_IsUsingFastCache,
 654     WMReaderAdvanced4_AddLogParam,
 655     WMReaderAdvanced4_SendLogParams,
 656     WMReaderAdvanced4_CanSaveFileAs,
 657     WMReaderAdvanced4_CancelSaveFileAs,
 658     WMReaderAdvanced4_GetURL,
 659     WMReaderAdvanced5_SetPlayerHook,
 660     WMReaderAdvanced6_SetProtextStreamSamples
 661 };
 662
 663 static inline WMReader *impl_from_IWMReaderAccelerator(IWMReaderAccelerator *iface)
 664 {
 665     return CONTAINING_RECORD(iface, WMReader, IWMReaderAccelerator_iface);
 666 }
 667
 668 static HRESULT WINAPI reader_accl_QueryInterface(IWMReaderAccelerator *iface, REFIID riid, void **object)
 669 {
 670     WMReader *This = impl_from_IWMReaderAccelerator(iface);
 671     return IWMReader_QueryInterface(&This->IWMReader_iface, riid, object);
 672 }
 673
 674 static ULONG WINAPI reader_accl_AddRef(IWMReaderAccelerator *iface)
 675 {
 676     WMReader *This = impl_from_IWMReaderAccelerator(iface);
 677     return IWMReader_AddRef(&This->IWMReader_iface);
 678 }
 679
 680 static ULONG WINAPI reader_accl_Release(IWMReaderAccelerator *iface)
 681 {
 682     WMReader *This = impl_from_IWMReaderAccelerator(iface);
 683     return IWMReader_Release(&This->IWMReader_iface);
 684 }
 685
 686 static HRESULT WINAPI reader_accl_GetCodecInterface(IWMReaderAccelerator *iface, DWORD output, REFIID riid, void **codec)
 687 {
 688     WMReader *This = impl_from_IWMReaderAccelerator(iface);
 689
 690     FIXME("%p, %d, %s, %p\n", This, output, debugstr_guid(riid), codec);
 691
 692     return E_NOTIMPL;
 693 }
 694
 695 static HRESULT WINAPI reader_accl_Notify(IWMReaderAccelerator *iface, DWORD output, WM_MEDIA_TYPE *subtype)
 696 {
 697     WMReader *This = impl_from_IWMReaderAccelerator(iface);
 698
 699     FIXME("%p, %d, %p\n", This, output, subtype);
 700
 701     return E_NOTIMPL;
 702 }
 703
 704 static const IWMReaderAcceleratorVtbl WMReaderAcceleratorVtbl = {
 705     reader_accl_QueryInterface,
 706     reader_accl_AddRef,
 707     reader_accl_Release,
 708     reader_accl_GetCodecInterface,
 709     reader_accl_Notify
 710 };
 711
 712 HRESULT WINAPI WMCreateReader(IUnknown *reserved, DWORD rights, IWMReader **ret_reader)
 713 {
 714     WMReader *reader;
 715
 716     TRACE("(%p, %x, %p)\n", reserved, rights, ret_reader);
 717
 718     reader = heap_alloc(sizeof(*reader));
 719     if(!reader)
 720         return E_OUTOFMEMORY;
 721
 722     reader->IWMReader_iface.lpVtbl = &WMReaderVtbl;
 723     reader->IWMReaderAdvanced6_iface.lpVtbl = &WMReaderAdvanced6Vtbl;
 724     reader->IWMReaderAccelerator_iface.lpVtbl = &WMReaderAcceleratorVtbl;
 725     reader->ref = 1;
 726
 727     *ret_reader = &reader->IWMReader_iface;
 728     return S_OK;
 729 }
 730
 731 HRESULT WINAPI WMCreateReaderPriv(IWMReader **ret_reader)
 732 {
 733     return WMCreateReader(NULL, 0, ret_reader);
 734 }
 735
 736 HRESULT WINAPI WMCreateSyncReader(IUnknown *pcert, DWORD rights, IWMSyncReader **syncreader)
 737 {
 738     FIXME("(%p, %x, %p): stub\n", pcert, rights, syncreader);
 739
 740     *syncreader = NULL;
 741
 742     return E_NOTIMPL;
 743 }
 744
 745 typedef struct {
 746     IWMProfileManager IWMProfileManager_iface;
 747     LONG ref;
 748 } WMProfileManager;
 749
 750 static inline WMProfileManager *impl_from_IWMProfileManager(IWMProfileManager *iface)
 751 {
 752     return CONTAINING_RECORD(iface, WMProfileManager, IWMProfileManager_iface);
 753 }
 754
 755 static HRESULT WINAPI WMProfileManager_QueryInterface(IWMProfileManager *iface, REFIID riid, void **ppv)
 756 {
 757     WMProfileManager *This = impl_from_IWMProfileManager(iface);
 758
 759     if(IsEqualGUID(&IID_IUnknown, riid)) {
 760         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
 761         *ppv = &This->IWMProfileManager_iface;
 762     }else if(IsEqualGUID(&IID_IWMProfileManager, riid)) {
 763         TRACE("(%p)->(IID_IWMProfileManager %p)\n", This, ppv);
 764         *ppv = &This->IWMProfileManager_iface;
 765     }else {
 766         *ppv = NULL;
 767         return E_NOINTERFACE;
 768     }
 769
 770     IUnknown_AddRef((IUnknown*)*ppv);
 771     return S_OK;
 772 }
 773
 774 static ULONG WINAPI WMProfileManager_AddRef(IWMProfileManager *iface)
 775 {
 776     WMProfileManager *This = impl_from_IWMProfileManager(iface);
 777     LONG ref = InterlockedIncrement(&This->ref);
 778
 779     TRACE("(%p) ref=%d\n", This, ref);
 780
 781     return ref;
 782 }
 783
 784 static ULONG WINAPI WMProfileManager_Release(IWMProfileManager *iface)
 785 {
 786     WMProfileManager *This = impl_from_IWMProfileManager(iface);
 787     LONG ref = InterlockedDecrement(&This->ref);
 788
 789     TRACE("(%p) ref=%d\n", This, ref);
 790
 791     if(!ref)
 792         heap_free(This);
 793
 794     return ref;
 795 }
 796
 797 static HRESULT WINAPI WMProfileManager_CreateEmptyProfile(IWMProfileManager *iface, WMT_VERSION version, IWMProfile **ret)
 798 {
 799     WMProfileManager *This = impl_from_IWMProfileManager(iface);
 800     FIXME("(%p)->(%x %p)\n", This, version, ret);
 801     return E_NOTIMPL;
 802 }
 803
 804 static HRESULT WINAPI WMProfileManager_LoadProfileByID(IWMProfileManager *iface, REFGUID guid, IWMProfile **ret)
 805 {
 806     WMProfileManager *This = impl_from_IWMProfileManager(iface);
 807     FIXME("(%p)->(%s %p)\n", This, debugstr_guid(guid), ret);
 808     return E_NOTIMPL;
 809 }
 810
 811 static HRESULT WINAPI WMProfileManager_LoadProfileByData(IWMProfileManager *iface, const WCHAR *profile, IWMProfile **ret)
 812 {
 813     WMProfileManager *This = impl_from_IWMProfileManager(iface);
 814     FIXME("(%p)->(%s %p)\n", This, debugstr_w(profile), ret);
 815     return E_NOTIMPL;
 816 }
 817
 818 static HRESULT WINAPI WMProfileManager_SaveProfile(IWMProfileManager *iface, IWMProfile *profile, WCHAR *profile_str, DWORD *len)
 819 {
 820     WMProfileManager *This = impl_from_IWMProfileManager(iface);
 821     FIXME("(%p)->(%p %p %p)\n", This, profile, profile_str, len);
 822     return E_NOTIMPL;
 823 }
 824
 825 static HRESULT WINAPI WMProfileManager_GetSystemProfileCount(IWMProfileManager *iface, DWORD *ret)
 826 {
 827     WMProfileManager *This = impl_from_IWMProfileManager(iface);
 828     FIXME("(%p)->(%p)\n", This, ret);
 829     return E_NOTIMPL;
 830 }
 831
 832 static HRESULT WINAPI WMProfileManager_LoadSystemProfile(IWMProfileManager *iface, DWORD index, IWMProfile **ret)
 833 {
 834     WMProfileManager *This = impl_from_IWMProfileManager(iface);
 835     FIXME("(%p)->(%d %p)\n", This, index, ret);
 836     return E_NOTIMPL;
 837 }
 838
 839 static const IWMProfileManagerVtbl WMProfileManagerVtbl = {
 840     WMProfileManager_QueryInterface,
 841     WMProfileManager_AddRef,
 842     WMProfileManager_Release,
 843     WMProfileManager_CreateEmptyProfile,
 844     WMProfileManager_LoadProfileByID,
 845     WMProfileManager_LoadProfileByData,
 846     WMProfileManager_SaveProfile,
 847     WMProfileManager_GetSystemProfileCount,
 848     WMProfileManager_LoadSystemProfile
 849 };
 850
 851 HRESULT WINAPI WMCreateProfileManager(IWMProfileManager **ret)
 852 {
 853     WMProfileManager *profile_mgr;
 854
 855     TRACE("(%p)\n", ret);
 856
 857     profile_mgr = heap_alloc(sizeof(*profile_mgr));
 858     if(!profile_mgr)
 859         return E_OUTOFMEMORY;
 860
 861     profile_mgr->IWMProfileManager_iface.lpVtbl = &WMProfileManagerVtbl;
 862     profile_mgr->ref = 1;
 863
 864     *ret = &profile_mgr->IWMProfileManager_iface;
 865     return S_OK;
 866 }