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