"Fossies" - the Fresh Open Source Software Archive

Member "wine-6.0.1/dlls/wmvcore/reader.c" (7 Jun 2021, 82124 Bytes) of package /linux/misc/wine-6.0.1.tar.xz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "reader.c" see the Fossies "Dox" file reference documentation and the latest Fossies "Diffs" side-by-side code changes report: 6.0_vs_6.0.1.

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