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