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