wine1.6-dev 1:1.6.2-0ubuntu4 / usr / include / wine / windows / wmsdkidl.h

/*** Autogenerated by WIDL 1.6.2 from wmsdkidl.idl - Do not edit ***/

#ifndef __REQUIRED_RPCNDR_H_VERSION__
#define __REQUIRED_RPCNDR_H_VERSION__ 475
#endif

#include <rpc.h>
#include <rpcndr.h>

#ifndef COM_NO_WINDOWS_H
#include <windows.h>
#include <ole2.h>
#endif

#ifndef __wmsdkidl_h__
#define __wmsdkidl_h__

/* Forward declarations */

#ifndef __IWMStatusCallback_FWD_DEFINED__
#define __IWMStatusCallback_FWD_DEFINED__
typedef interface IWMStatusCallback IWMStatusCallback;
#endif

#ifndef __IWMReaderCallback_FWD_DEFINED__
#define __IWMReaderCallback_FWD_DEFINED__
typedef interface IWMReaderCallback IWMReaderCallback;
#endif

#ifndef __IWMMediaProps_FWD_DEFINED__
#define __IWMMediaProps_FWD_DEFINED__
typedef interface IWMMediaProps IWMMediaProps;
#endif

#ifndef __IWMOutputMediaProps_FWD_DEFINED__
#define __IWMOutputMediaProps_FWD_DEFINED__
typedef interface IWMOutputMediaProps IWMOutputMediaProps;
#endif

#ifndef __IWMMetadataEditor_FWD_DEFINED__
#define __IWMMetadataEditor_FWD_DEFINED__
typedef interface IWMMetadataEditor IWMMetadataEditor;
#endif

#ifndef __IWMReader_FWD_DEFINED__
#define __IWMReader_FWD_DEFINED__
typedef interface IWMReader IWMReader;
#endif

#ifndef __IWMSyncReader_FWD_DEFINED__
#define __IWMSyncReader_FWD_DEFINED__
typedef interface IWMSyncReader IWMSyncReader;
#endif

/* Headers for imported files */

#include <oaidl.h>
#include <wmsbuffer.h>

#ifdef __cplusplus
extern "C" {
#endif

typedef UINT64 QWORD;
typedef struct _WMMediaType {
    GUID majortype;
    GUID subtype;
    BOOL bFixedSizeSamples;
    BOOL bTemporalCompression;
    ULONG lSampleSize;
    GUID formattype;
    IUnknown *pUnk;
    ULONG cbFormat;
    BYTE *pbFormat;
} WM_MEDIA_TYPE;
typedef enum WMT_ATTR_DATATYPE {
    WMT_TYPE_DWORD = 0,
    WMT_TYPE_STRING = 1,
    WMT_TYPE_BINARY = 2,
    WMT_TYPE_BOOL = 3,
    WMT_TYPE_QWORD = 4,
    WMT_TYPE_WORD = 5,
    WMT_TYPE_GUID = 6
} WMT_ATTR_DATATYPE;
typedef enum WMT_STATUS {
    WMT_ERROR = 0,
    WMT_OPENED = 1,
    WMT_BUFFERING_START = 2,
    WMT_BUFFERING_STOP = 3,
    WMT_EOF = 4,
    WMT_END_OF_FILE = 4,
    WMT_END_OF_SEGMENT = 5,
    WMT_END_OF_STREAMING = 6,
    WMT_LOCATING = 7,
    WMT_CONNECTING = 8,
    WMT_NO_RIGHTS = 9,
    WMT_MISSING_CODEC = 10,
    WMT_STARTED = 11,
    WMT_STOPPED = 12,
    WMT_CLOSED = 13,
    WMT_STRIDING = 14,
    WMT_TIMER = 15,
    WMT_INDEX_PROGRESS = 16,
    WMT_SAVEAS_START = 17,
    WMT_SAVEAS_STOP = 18,
    WMT_NEW_SOURCEFLAGS = 19,
    WMT_NEW_METADATA = 20,
    WMT_BACKUPRESTORE_BEGIN = 21,
    WMT_SOURCE_SWITCH = 22,
    WMT_ACQUIRE_LICENSE = 23,
    WMT_INDIVIDUALIZE = 24,
    WMT_NEEDS_INDIVIDUALIZATION = 25,
    WMT_NO_RIGHTS_EX = 26,
    WMT_BACKUPRESTORE_END = 27,
    WMT_BACKUPRESTORE_CONNECTING = 28,
    WMT_BACKUPRESTORE_DISCONNECTING = 29,
    WMT_ERROR_WITHURL = 30,
    WMT_RESTRICTED_LICENSE = 31,
    WMT_CLIENT_CONNECT = 32,
    WMT_CLIENT_DISCONNECT = 33,
    WMT_NATIVE_OUTPUT_PROPS_CHANGED = 34,
    WMT_RECONNECT_START = 35,
    WMT_RECONNECT_END = 36,
    WMT_CLIENT_CONNECT_EX = 37,
    WMT_CLIENT_DISCONNECT_EX = 38,
    WMT_SET_FEC_SPAN = 39,
    WMT_PREROLL_READY = 40,
    WMT_PREROLL_COMPLETE = 41,
    WMT_CLIENT_PROPERTIES = 42,
    WMT_LICENSEURL_SIGNATURE_STATE = 43,
    WMT_INIT_PLAYLIST_BURN = 44,
    WMT_TRANSCRYPTOR_INIT = 45,
    WMT_TRANSCRYPTOR_SEEKED = 46,
    WMT_TRANSCRYPTOR_READ = 47,
    WMT_TRANSCRYPTOR_CLOSED = 48,
    WMT_PROXIMITY_RESULT = 49,
    WMT_PROXIMITY_COMPLETED = 50,
    WMT_CONTENT_ENABLER = 51
} WMT_STATUS;
typedef enum WMT_STREAM_SELECTION {
    WMT_OFF = 0,
    WMT_CLEANPOINT_ONLY = 1,
    WMT_ON = 2
} WMT_STREAM_SELECTION;
/*****************************************************************************
 * IWMStatusCallback interface
 */
#ifndef __IWMStatusCallback_INTERFACE_DEFINED__
#define __IWMStatusCallback_INTERFACE_DEFINED__

DEFINE_GUID(IID_IWMStatusCallback, 0x6d7cdc70, 0x9888, 0x11d3, 0x8e,0xdc, 0x00,0xc0,0x4f,0x61,0x09,0xcf);
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("6d7cdc70-9888-11d3-8edc-00c04f6109cf")
IWMStatusCallback : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE OnStatus(
        WMT_STATUS Status,
        HRESULT hr,
        WMT_ATTR_DATATYPE dwType,
        BYTE *pValue,
        void *pvContext) = 0;

};
#ifdef __CRT_UUID_DECL
__CRT_UUID_DECL(IWMStatusCallback, 0x6d7cdc70, 0x9888, 0x11d3, 0x8e,0xdc, 0x00,0xc0,0x4f,0x61,0x09,0xcf)
#endif
#else
typedef struct IWMStatusCallbackVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IWMStatusCallback* This,
        REFIID riid,
        void **ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IWMStatusCallback* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IWMStatusCallback* This);

    /*** IWMStatusCallback methods ***/
    HRESULT (STDMETHODCALLTYPE *OnStatus)(
        IWMStatusCallback* This,
        WMT_STATUS Status,
        HRESULT hr,
        WMT_ATTR_DATATYPE dwType,
        BYTE *pValue,
        void *pvContext);

    END_INTERFACE
} IWMStatusCallbackVtbl;
interface IWMStatusCallback {
    CONST_VTBL IWMStatusCallbackVtbl* lpVtbl;
};

#ifdef COBJMACROS
#ifndef WIDL_C_INLINE_WRAPPERS
/*** IUnknown methods ***/
#define IWMStatusCallback_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
#define IWMStatusCallback_AddRef(This) (This)->lpVtbl->AddRef(This)
#define IWMStatusCallback_Release(This) (This)->lpVtbl->Release(This)
/*** IWMStatusCallback methods ***/
#define IWMStatusCallback_OnStatus(This,Status,hr,dwType,pValue,pvContext) (This)->lpVtbl->OnStatus(This,Status,hr,dwType,pValue,pvContext)
#else
/*** IUnknown methods ***/
static FORCEINLINE HRESULT IWMStatusCallback_QueryInterface(IWMStatusCallback* This,REFIID riid,void **ppvObject) {
    return This->lpVtbl->QueryInterface(This,riid,ppvObject);
}
static FORCEINLINE ULONG IWMStatusCallback_AddRef(IWMStatusCallback* This) {
    return This->lpVtbl->AddRef(This);
}
static FORCEINLINE ULONG IWMStatusCallback_Release(IWMStatusCallback* This) {
    return This->lpVtbl->Release(This);
}
/*** IWMStatusCallback methods ***/
static FORCEINLINE HRESULT IWMStatusCallback_OnStatus(IWMStatusCallback* This,WMT_STATUS Status,HRESULT hr,WMT_ATTR_DATATYPE dwType,BYTE *pValue,void *pvContext) {
    return This->lpVtbl->OnStatus(This,Status,hr,dwType,pValue,pvContext);
}
#endif
#endif

#endif

HRESULT STDMETHODCALLTYPE IWMStatusCallback_OnStatus_Proxy(
    IWMStatusCallback* This,
    WMT_STATUS Status,
    HRESULT hr,
    WMT_ATTR_DATATYPE dwType,
    BYTE *pValue,
    void *pvContext);
void __RPC_STUB IWMStatusCallback_OnStatus_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IWMStatusCallback_INTERFACE_DEFINED__ */

/*****************************************************************************
 * IWMReaderCallback interface
 */
#ifndef __IWMReaderCallback_INTERFACE_DEFINED__
#define __IWMReaderCallback_INTERFACE_DEFINED__

DEFINE_GUID(IID_IWMReaderCallback, 0x96406bd8, 0x2b2b, 0x11d3, 0xb3,0x6b, 0x00,0xc0,0x4f,0x61,0x08,0xff);
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("96406bd8-2b2b-11d3-b36b-00c04f6108ff")
IWMReaderCallback : public IWMStatusCallback
{
    virtual HRESULT STDMETHODCALLTYPE OnSample(
        DWORD dwOutputNum,
        QWORD cnsSampleTime,
        QWORD cnsSampleDuration,
        DWORD dwFlags,
        INSSBuffer *pSample,
        void *pvContext) = 0;

};
#ifdef __CRT_UUID_DECL
__CRT_UUID_DECL(IWMReaderCallback, 0x96406bd8, 0x2b2b, 0x11d3, 0xb3,0x6b, 0x00,0xc0,0x4f,0x61,0x08,0xff)
#endif
#else
typedef struct IWMReaderCallbackVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IWMReaderCallback* This,
        REFIID riid,
        void **ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IWMReaderCallback* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IWMReaderCallback* This);

    /*** IWMStatusCallback methods ***/
    HRESULT (STDMETHODCALLTYPE *OnStatus)(
        IWMReaderCallback* This,
        WMT_STATUS Status,
        HRESULT hr,
        WMT_ATTR_DATATYPE dwType,
        BYTE *pValue,
        void *pvContext);

    /*** IWMReaderCallback methods ***/
    HRESULT (STDMETHODCALLTYPE *OnSample)(
        IWMReaderCallback* This,
        DWORD dwOutputNum,
        QWORD cnsSampleTime,
        QWORD cnsSampleDuration,
        DWORD dwFlags,
        INSSBuffer *pSample,
        void *pvContext);

    END_INTERFACE
} IWMReaderCallbackVtbl;
interface IWMReaderCallback {
    CONST_VTBL IWMReaderCallbackVtbl* lpVtbl;
};

#ifdef COBJMACROS
#ifndef WIDL_C_INLINE_WRAPPERS
/*** IUnknown methods ***/
#define IWMReaderCallback_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
#define IWMReaderCallback_AddRef(This) (This)->lpVtbl->AddRef(This)
#define IWMReaderCallback_Release(This) (This)->lpVtbl->Release(This)
/*** IWMStatusCallback methods ***/
#define IWMReaderCallback_OnStatus(This,Status,hr,dwType,pValue,pvContext) (This)->lpVtbl->OnStatus(This,Status,hr,dwType,pValue,pvContext)
/*** IWMReaderCallback methods ***/
#define IWMReaderCallback_OnSample(This,dwOutputNum,cnsSampleTime,cnsSampleDuration,dwFlags,pSample,pvContext) (This)->lpVtbl->OnSample(This,dwOutputNum,cnsSampleTime,cnsSampleDuration,dwFlags,pSample,pvContext)
#else
/*** IUnknown methods ***/
static FORCEINLINE HRESULT IWMReaderCallback_QueryInterface(IWMReaderCallback* This,REFIID riid,void **ppvObject) {
    return This->lpVtbl->QueryInterface(This,riid,ppvObject);
}
static FORCEINLINE ULONG IWMReaderCallback_AddRef(IWMReaderCallback* This) {
    return This->lpVtbl->AddRef(This);
}
static FORCEINLINE ULONG IWMReaderCallback_Release(IWMReaderCallback* This) {
    return This->lpVtbl->Release(This);
}
/*** IWMStatusCallback methods ***/
static FORCEINLINE HRESULT IWMReaderCallback_OnStatus(IWMReaderCallback* This,WMT_STATUS Status,HRESULT hr,WMT_ATTR_DATATYPE dwType,BYTE *pValue,void *pvContext) {
    return This->lpVtbl->OnStatus(This,Status,hr,dwType,pValue,pvContext);
}
/*** IWMReaderCallback methods ***/
static FORCEINLINE HRESULT IWMReaderCallback_OnSample(IWMReaderCallback* This,DWORD dwOutputNum,QWORD cnsSampleTime,QWORD cnsSampleDuration,DWORD dwFlags,INSSBuffer *pSample,void *pvContext) {
    return This->lpVtbl->OnSample(This,dwOutputNum,cnsSampleTime,cnsSampleDuration,dwFlags,pSample,pvContext);
}
#endif
#endif

#endif

HRESULT STDMETHODCALLTYPE IWMReaderCallback_OnSample_Proxy(
    IWMReaderCallback* This,
    DWORD dwOutputNum,
    QWORD cnsSampleTime,
    QWORD cnsSampleDuration,
    DWORD dwFlags,
    INSSBuffer *pSample,
    void *pvContext);
void __RPC_STUB IWMReaderCallback_OnSample_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IWMReaderCallback_INTERFACE_DEFINED__ */

/*****************************************************************************
 * IWMMediaProps interface
 */
#ifndef __IWMMediaProps_INTERFACE_DEFINED__
#define __IWMMediaProps_INTERFACE_DEFINED__

DEFINE_GUID(IID_IWMMediaProps, 0x96406bce, 0x2b2b, 0x11d3, 0xb3,0x6b, 0x00,0xc0,0x4f,0x61,0x08,0xff);
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("96406bce-2b2b-11d3-b36b-00c04f6108ff")
IWMMediaProps : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE GetType(
        GUID *pguidType) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetMediaType(
        WM_MEDIA_TYPE *pType,
        DWORD *pcbType) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetMediaType(
        WM_MEDIA_TYPE *pType) = 0;

};
#ifdef __CRT_UUID_DECL
__CRT_UUID_DECL(IWMMediaProps, 0x96406bce, 0x2b2b, 0x11d3, 0xb3,0x6b, 0x00,0xc0,0x4f,0x61,0x08,0xff)
#endif
#else
typedef struct IWMMediaPropsVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IWMMediaProps* This,
        REFIID riid,
        void **ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IWMMediaProps* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IWMMediaProps* This);

    /*** IWMMediaProps methods ***/
    HRESULT (STDMETHODCALLTYPE *GetType)(
        IWMMediaProps* This,
        GUID *pguidType);

    HRESULT (STDMETHODCALLTYPE *GetMediaType)(
        IWMMediaProps* This,
        WM_MEDIA_TYPE *pType,
        DWORD *pcbType);

    HRESULT (STDMETHODCALLTYPE *SetMediaType)(
        IWMMediaProps* This,
        WM_MEDIA_TYPE *pType);

    END_INTERFACE
} IWMMediaPropsVtbl;
interface IWMMediaProps {
    CONST_VTBL IWMMediaPropsVtbl* lpVtbl;
};

#ifdef COBJMACROS
#ifndef WIDL_C_INLINE_WRAPPERS
/*** IUnknown methods ***/
#define IWMMediaProps_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
#define IWMMediaProps_AddRef(This) (This)->lpVtbl->AddRef(This)
#define IWMMediaProps_Release(This) (This)->lpVtbl->Release(This)
/*** IWMMediaProps methods ***/
#define IWMMediaProps_GetType(This,pguidType) (This)->lpVtbl->GetType(This,pguidType)
#define IWMMediaProps_GetMediaType(This,pType,pcbType) (This)->lpVtbl->GetMediaType(This,pType,pcbType)
#define IWMMediaProps_SetMediaType(This,pType) (This)->lpVtbl->SetMediaType(This,pType)
#else
/*** IUnknown methods ***/
static FORCEINLINE HRESULT IWMMediaProps_QueryInterface(IWMMediaProps* This,REFIID riid,void **ppvObject) {
    return This->lpVtbl->QueryInterface(This,riid,ppvObject);
}
static FORCEINLINE ULONG IWMMediaProps_AddRef(IWMMediaProps* This) {
    return This->lpVtbl->AddRef(This);
}
static FORCEINLINE ULONG IWMMediaProps_Release(IWMMediaProps* This) {
    return This->lpVtbl->Release(This);
}
/*** IWMMediaProps methods ***/
static FORCEINLINE HRESULT IWMMediaProps_GetType(IWMMediaProps* This,GUID *pguidType) {
    return This->lpVtbl->GetType(This,pguidType);
}
static FORCEINLINE HRESULT IWMMediaProps_GetMediaType(IWMMediaProps* This,WM_MEDIA_TYPE *pType,DWORD *pcbType) {
    return This->lpVtbl->GetMediaType(This,pType,pcbType);
}
static FORCEINLINE HRESULT IWMMediaProps_SetMediaType(IWMMediaProps* This,WM_MEDIA_TYPE *pType) {
    return This->lpVtbl->SetMediaType(This,pType);
}
#endif
#endif

#endif

HRESULT STDMETHODCALLTYPE IWMMediaProps_GetType_Proxy(
    IWMMediaProps* This,
    GUID *pguidType);
void __RPC_STUB IWMMediaProps_GetType_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IWMMediaProps_GetMediaType_Proxy(
    IWMMediaProps* This,
    WM_MEDIA_TYPE *pType,
    DWORD *pcbType);
void __RPC_STUB IWMMediaProps_GetMediaType_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IWMMediaProps_SetMediaType_Proxy(
    IWMMediaProps* This,
    WM_MEDIA_TYPE *pType);
void __RPC_STUB IWMMediaProps_SetMediaType_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IWMMediaProps_INTERFACE_DEFINED__ */

/*****************************************************************************
 * IWMOutputMediaProps interface
 */
#ifndef __IWMOutputMediaProps_INTERFACE_DEFINED__
#define __IWMOutputMediaProps_INTERFACE_DEFINED__

DEFINE_GUID(IID_IWMOutputMediaProps, 0x96406bd7, 0x2b2b, 0x11d3, 0xb3,0x6b, 0x00,0xc0,0x4f,0x61,0x08,0xff);
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("96406bd7-2b2b-11d3-b36b-00c04f6108ff")
IWMOutputMediaProps : public IWMMediaProps
{
    virtual HRESULT STDMETHODCALLTYPE GetStreamGroupName(
        WCHAR *pwszName,
        WORD *pcchName) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetConnectionName(
        WCHAR *pwszName,
        WORD *pcchName) = 0;

};
#ifdef __CRT_UUID_DECL
__CRT_UUID_DECL(IWMOutputMediaProps, 0x96406bd7, 0x2b2b, 0x11d3, 0xb3,0x6b, 0x00,0xc0,0x4f,0x61,0x08,0xff)
#endif
#else
typedef struct IWMOutputMediaPropsVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IWMOutputMediaProps* This,
        REFIID riid,
        void **ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IWMOutputMediaProps* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IWMOutputMediaProps* This);

    /*** IWMMediaProps methods ***/
    HRESULT (STDMETHODCALLTYPE *GetType)(
        IWMOutputMediaProps* This,
        GUID *pguidType);

    HRESULT (STDMETHODCALLTYPE *GetMediaType)(
        IWMOutputMediaProps* This,
        WM_MEDIA_TYPE *pType,
        DWORD *pcbType);

    HRESULT (STDMETHODCALLTYPE *SetMediaType)(
        IWMOutputMediaProps* This,
        WM_MEDIA_TYPE *pType);

    /*** IWMOutputMediaProps methods ***/
    HRESULT (STDMETHODCALLTYPE *GetStreamGroupName)(
        IWMOutputMediaProps* This,
        WCHAR *pwszName,
        WORD *pcchName);

    HRESULT (STDMETHODCALLTYPE *GetConnectionName)(
        IWMOutputMediaProps* This,
        WCHAR *pwszName,
        WORD *pcchName);

    END_INTERFACE
} IWMOutputMediaPropsVtbl;
interface IWMOutputMediaProps {
    CONST_VTBL IWMOutputMediaPropsVtbl* lpVtbl;
};

#ifdef COBJMACROS
#ifndef WIDL_C_INLINE_WRAPPERS
/*** IUnknown methods ***/
#define IWMOutputMediaProps_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
#define IWMOutputMediaProps_AddRef(This) (This)->lpVtbl->AddRef(This)
#define IWMOutputMediaProps_Release(This) (This)->lpVtbl->Release(This)
/*** IWMMediaProps methods ***/
#define IWMOutputMediaProps_GetType(This,pguidType) (This)->lpVtbl->GetType(This,pguidType)
#define IWMOutputMediaProps_GetMediaType(This,pType,pcbType) (This)->lpVtbl->GetMediaType(This,pType,pcbType)
#define IWMOutputMediaProps_SetMediaType(This,pType) (This)->lpVtbl->SetMediaType(This,pType)
/*** IWMOutputMediaProps methods ***/
#define IWMOutputMediaProps_GetStreamGroupName(This,pwszName,pcchName) (This)->lpVtbl->GetStreamGroupName(This,pwszName,pcchName)
#define IWMOutputMediaProps_GetConnectionName(This,pwszName,pcchName) (This)->lpVtbl->GetConnectionName(This,pwszName,pcchName)
#else
/*** IUnknown methods ***/
static FORCEINLINE HRESULT IWMOutputMediaProps_QueryInterface(IWMOutputMediaProps* This,REFIID riid,void **ppvObject) {
    return This->lpVtbl->QueryInterface(This,riid,ppvObject);
}
static FORCEINLINE ULONG IWMOutputMediaProps_AddRef(IWMOutputMediaProps* This) {
    return This->lpVtbl->AddRef(This);
}
static FORCEINLINE ULONG IWMOutputMediaProps_Release(IWMOutputMediaProps* This) {
    return This->lpVtbl->Release(This);
}
/*** IWMMediaProps methods ***/
static FORCEINLINE HRESULT IWMOutputMediaProps_GetType(IWMOutputMediaProps* This,GUID *pguidType) {
    return This->lpVtbl->GetType(This,pguidType);
}
static FORCEINLINE HRESULT IWMOutputMediaProps_GetMediaType(IWMOutputMediaProps* This,WM_MEDIA_TYPE *pType,DWORD *pcbType) {
    return This->lpVtbl->GetMediaType(This,pType,pcbType);
}
static FORCEINLINE HRESULT IWMOutputMediaProps_SetMediaType(IWMOutputMediaProps* This,WM_MEDIA_TYPE *pType) {
    return This->lpVtbl->SetMediaType(This,pType);
}
/*** IWMOutputMediaProps methods ***/
static FORCEINLINE HRESULT IWMOutputMediaProps_GetStreamGroupName(IWMOutputMediaProps* This,WCHAR *pwszName,WORD *pcchName) {
    return This->lpVtbl->GetStreamGroupName(This,pwszName,pcchName);
}
static FORCEINLINE HRESULT IWMOutputMediaProps_GetConnectionName(IWMOutputMediaProps* This,WCHAR *pwszName,WORD *pcchName) {
    return This->lpVtbl->GetConnectionName(This,pwszName,pcchName);
}
#endif
#endif

#endif

HRESULT STDMETHODCALLTYPE IWMOutputMediaProps_GetStreamGroupName_Proxy(
    IWMOutputMediaProps* This,
    WCHAR *pwszName,
    WORD *pcchName);
void __RPC_STUB IWMOutputMediaProps_GetStreamGroupName_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IWMOutputMediaProps_GetConnectionName_Proxy(
    IWMOutputMediaProps* This,
    WCHAR *pwszName,
    WORD *pcchName);
void __RPC_STUB IWMOutputMediaProps_GetConnectionName_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IWMOutputMediaProps_INTERFACE_DEFINED__ */

/*****************************************************************************
 * IWMMetadataEditor interface
 */
#ifndef __IWMMetadataEditor_INTERFACE_DEFINED__
#define __IWMMetadataEditor_INTERFACE_DEFINED__

DEFINE_GUID(IID_IWMMetadataEditor, 0x96406bd9, 0x2b2b, 0x11d3, 0xb3,0x6b, 0x00,0xc0,0x4f,0x61,0x08,0xff);
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("96406bd9-2b2b-11d3-b36b-00c04f6108ff")
IWMMetadataEditor : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE Open(
        const WCHAR *pwszFilename) = 0;

    virtual HRESULT STDMETHODCALLTYPE Close(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE Flush(
        ) = 0;

};
#ifdef __CRT_UUID_DECL
__CRT_UUID_DECL(IWMMetadataEditor, 0x96406bd9, 0x2b2b, 0x11d3, 0xb3,0x6b, 0x00,0xc0,0x4f,0x61,0x08,0xff)
#endif
#else
typedef struct IWMMetadataEditorVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IWMMetadataEditor* This,
        REFIID riid,
        void **ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IWMMetadataEditor* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IWMMetadataEditor* This);

    /*** IWMMetadataEditor methods ***/
    HRESULT (STDMETHODCALLTYPE *Open)(
        IWMMetadataEditor* This,
        const WCHAR *pwszFilename);

    HRESULT (STDMETHODCALLTYPE *Close)(
        IWMMetadataEditor* This);

    HRESULT (STDMETHODCALLTYPE *Flush)(
        IWMMetadataEditor* This);

    END_INTERFACE
} IWMMetadataEditorVtbl;
interface IWMMetadataEditor {
    CONST_VTBL IWMMetadataEditorVtbl* lpVtbl;
};

#ifdef COBJMACROS
#ifndef WIDL_C_INLINE_WRAPPERS
/*** IUnknown methods ***/
#define IWMMetadataEditor_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
#define IWMMetadataEditor_AddRef(This) (This)->lpVtbl->AddRef(This)
#define IWMMetadataEditor_Release(This) (This)->lpVtbl->Release(This)
/*** IWMMetadataEditor methods ***/
#define IWMMetadataEditor_Open(This,pwszFilename) (This)->lpVtbl->Open(This,pwszFilename)
#define IWMMetadataEditor_Close(This) (This)->lpVtbl->Close(This)
#define IWMMetadataEditor_Flush(This) (This)->lpVtbl->Flush(This)
#else
/*** IUnknown methods ***/
static FORCEINLINE HRESULT IWMMetadataEditor_QueryInterface(IWMMetadataEditor* This,REFIID riid,void **ppvObject) {
    return This->lpVtbl->QueryInterface(This,riid,ppvObject);
}
static FORCEINLINE ULONG IWMMetadataEditor_AddRef(IWMMetadataEditor* This) {
    return This->lpVtbl->AddRef(This);
}
static FORCEINLINE ULONG IWMMetadataEditor_Release(IWMMetadataEditor* This) {
    return This->lpVtbl->Release(This);
}
/*** IWMMetadataEditor methods ***/
static FORCEINLINE HRESULT IWMMetadataEditor_Open(IWMMetadataEditor* This,const WCHAR *pwszFilename) {
    return This->lpVtbl->Open(This,pwszFilename);
}
static FORCEINLINE HRESULT IWMMetadataEditor_Close(IWMMetadataEditor* This) {
    return This->lpVtbl->Close(This);
}
static FORCEINLINE HRESULT IWMMetadataEditor_Flush(IWMMetadataEditor* This) {
    return This->lpVtbl->Flush(This);
}
#endif
#endif

#endif

HRESULT STDMETHODCALLTYPE IWMMetadataEditor_Open_Proxy(
    IWMMetadataEditor* This,
    const WCHAR *pwszFilename);
void __RPC_STUB IWMMetadataEditor_Open_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IWMMetadataEditor_Close_Proxy(
    IWMMetadataEditor* This);
void __RPC_STUB IWMMetadataEditor_Close_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IWMMetadataEditor_Flush_Proxy(
    IWMMetadataEditor* This);
void __RPC_STUB IWMMetadataEditor_Flush_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IWMMetadataEditor_INTERFACE_DEFINED__ */

/*****************************************************************************
 * IWMReader interface
 */
#ifndef __IWMReader_INTERFACE_DEFINED__
#define __IWMReader_INTERFACE_DEFINED__

DEFINE_GUID(IID_IWMReader, 0x96406bd6, 0x2b2b, 0x11d3, 0xb3,0x6b, 0x00,0xc0,0x4f,0x61,0x08,0xff);
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("96406bd6-2b2b-11d3-b36b-00c04f6108ff")
IWMReader : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE Open(
        const WCHAR *pwszURL,
        IWMReaderCallback *pCallback,
        void *pvContext) = 0;

    virtual HRESULT STDMETHODCALLTYPE Close(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetOutputCount(
        DWORD *pcOutputs) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetOutputProps(
        DWORD dwOutputNum,
        IWMOutputMediaProps **ppOutput) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetOutputProps(
        DWORD dwOutputNum,
        IWMOutputMediaProps *pOutput) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetOutputFormatCount(
        DWORD dwOutputNumber,
        DWORD *pcFormats) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetOutputFormat(
        DWORD dwOutputNumber,
        DWORD dwFormatNumber,
        IWMOutputMediaProps **ppProps) = 0;

    virtual HRESULT STDMETHODCALLTYPE Start(
        QWORD cnsStart,
        QWORD cnsDuration,
        float fRate,
        void *pvContext) = 0;

    virtual HRESULT STDMETHODCALLTYPE Stop(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE Pause(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE Resume(
        ) = 0;

};
#ifdef __CRT_UUID_DECL
__CRT_UUID_DECL(IWMReader, 0x96406bd6, 0x2b2b, 0x11d3, 0xb3,0x6b, 0x00,0xc0,0x4f,0x61,0x08,0xff)
#endif
#else
typedef struct IWMReaderVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IWMReader* This,
        REFIID riid,
        void **ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IWMReader* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IWMReader* This);

    /*** IWMReader methods ***/
    HRESULT (STDMETHODCALLTYPE *Open)(
        IWMReader* This,
        const WCHAR *pwszURL,
        IWMReaderCallback *pCallback,
        void *pvContext);

    HRESULT (STDMETHODCALLTYPE *Close)(
        IWMReader* This);

    HRESULT (STDMETHODCALLTYPE *GetOutputCount)(
        IWMReader* This,
        DWORD *pcOutputs);

    HRESULT (STDMETHODCALLTYPE *GetOutputProps)(
        IWMReader* This,
        DWORD dwOutputNum,
        IWMOutputMediaProps **ppOutput);

    HRESULT (STDMETHODCALLTYPE *SetOutputProps)(
        IWMReader* This,
        DWORD dwOutputNum,
        IWMOutputMediaProps *pOutput);

    HRESULT (STDMETHODCALLTYPE *GetOutputFormatCount)(
        IWMReader* This,
        DWORD dwOutputNumber,
        DWORD *pcFormats);

    HRESULT (STDMETHODCALLTYPE *GetOutputFormat)(
        IWMReader* This,
        DWORD dwOutputNumber,
        DWORD dwFormatNumber,
        IWMOutputMediaProps **ppProps);

    HRESULT (STDMETHODCALLTYPE *Start)(
        IWMReader* This,
        QWORD cnsStart,
        QWORD cnsDuration,
        float fRate,
        void *pvContext);

    HRESULT (STDMETHODCALLTYPE *Stop)(
        IWMReader* This);

    HRESULT (STDMETHODCALLTYPE *Pause)(
        IWMReader* This);

    HRESULT (STDMETHODCALLTYPE *Resume)(
        IWMReader* This);

    END_INTERFACE
} IWMReaderVtbl;
interface IWMReader {
    CONST_VTBL IWMReaderVtbl* lpVtbl;
};

#ifdef COBJMACROS
#ifndef WIDL_C_INLINE_WRAPPERS
/*** IUnknown methods ***/
#define IWMReader_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
#define IWMReader_AddRef(This) (This)->lpVtbl->AddRef(This)
#define IWMReader_Release(This) (This)->lpVtbl->Release(This)
/*** IWMReader methods ***/
#define IWMReader_Open(This,pwszURL,pCallback,pvContext) (This)->lpVtbl->Open(This,pwszURL,pCallback,pvContext)
#define IWMReader_Close(This) (This)->lpVtbl->Close(This)
#define IWMReader_GetOutputCount(This,pcOutputs) (This)->lpVtbl->GetOutputCount(This,pcOutputs)
#define IWMReader_GetOutputProps(This,dwOutputNum,ppOutput) (This)->lpVtbl->GetOutputProps(This,dwOutputNum,ppOutput)
#define IWMReader_SetOutputProps(This,dwOutputNum,pOutput) (This)->lpVtbl->SetOutputProps(This,dwOutputNum,pOutput)
#define IWMReader_GetOutputFormatCount(This,dwOutputNumber,pcFormats) (This)->lpVtbl->GetOutputFormatCount(This,dwOutputNumber,pcFormats)
#define IWMReader_GetOutputFormat(This,dwOutputNumber,dwFormatNumber,ppProps) (This)->lpVtbl->GetOutputFormat(This,dwOutputNumber,dwFormatNumber,ppProps)
#define IWMReader_Start(This,cnsStart,cnsDuration,fRate,pvContext) (This)->lpVtbl->Start(This,cnsStart,cnsDuration,fRate,pvContext)
#define IWMReader_Stop(This) (This)->lpVtbl->Stop(This)
#define IWMReader_Pause(This) (This)->lpVtbl->Pause(This)
#define IWMReader_Resume(This) (This)->lpVtbl->Resume(This)
#else
/*** IUnknown methods ***/
static FORCEINLINE HRESULT IWMReader_QueryInterface(IWMReader* This,REFIID riid,void **ppvObject) {
    return This->lpVtbl->QueryInterface(This,riid,ppvObject);
}
static FORCEINLINE ULONG IWMReader_AddRef(IWMReader* This) {
    return This->lpVtbl->AddRef(This);
}
static FORCEINLINE ULONG IWMReader_Release(IWMReader* This) {
    return This->lpVtbl->Release(This);
}
/*** IWMReader methods ***/
static FORCEINLINE HRESULT IWMReader_Open(IWMReader* This,const WCHAR *pwszURL,IWMReaderCallback *pCallback,void *pvContext) {
    return This->lpVtbl->Open(This,pwszURL,pCallback,pvContext);
}
static FORCEINLINE HRESULT IWMReader_Close(IWMReader* This) {
    return This->lpVtbl->Close(This);
}
static FORCEINLINE HRESULT IWMReader_GetOutputCount(IWMReader* This,DWORD *pcOutputs) {
    return This->lpVtbl->GetOutputCount(This,pcOutputs);
}
static FORCEINLINE HRESULT IWMReader_GetOutputProps(IWMReader* This,DWORD dwOutputNum,IWMOutputMediaProps **ppOutput) {
    return This->lpVtbl->GetOutputProps(This,dwOutputNum,ppOutput);
}
static FORCEINLINE HRESULT IWMReader_SetOutputProps(IWMReader* This,DWORD dwOutputNum,IWMOutputMediaProps *pOutput) {
    return This->lpVtbl->SetOutputProps(This,dwOutputNum,pOutput);
}
static FORCEINLINE HRESULT IWMReader_GetOutputFormatCount(IWMReader* This,DWORD dwOutputNumber,DWORD *pcFormats) {
    return This->lpVtbl->GetOutputFormatCount(This,dwOutputNumber,pcFormats);
}
static FORCEINLINE HRESULT IWMReader_GetOutputFormat(IWMReader* This,DWORD dwOutputNumber,DWORD dwFormatNumber,IWMOutputMediaProps **ppProps) {
    return This->lpVtbl->GetOutputFormat(This,dwOutputNumber,dwFormatNumber,ppProps);
}
static FORCEINLINE HRESULT IWMReader_Start(IWMReader* This,QWORD cnsStart,QWORD cnsDuration,float fRate,void *pvContext) {
    return This->lpVtbl->Start(This,cnsStart,cnsDuration,fRate,pvContext);
}
static FORCEINLINE HRESULT IWMReader_Stop(IWMReader* This) {
    return This->lpVtbl->Stop(This);
}
static FORCEINLINE HRESULT IWMReader_Pause(IWMReader* This) {
    return This->lpVtbl->Pause(This);
}
static FORCEINLINE HRESULT IWMReader_Resume(IWMReader* This) {
    return This->lpVtbl->Resume(This);
}
#endif
#endif

#endif

HRESULT STDMETHODCALLTYPE IWMReader_Open_Proxy(
    IWMReader* This,
    const WCHAR *pwszURL,
    IWMReaderCallback *pCallback,
    void *pvContext);
void __RPC_STUB IWMReader_Open_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IWMReader_Close_Proxy(
    IWMReader* This);
void __RPC_STUB IWMReader_Close_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IWMReader_GetOutputCount_Proxy(
    IWMReader* This,
    DWORD *pcOutputs);
void __RPC_STUB IWMReader_GetOutputCount_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IWMReader_GetOutputProps_Proxy(
    IWMReader* This,
    DWORD dwOutputNum,
    IWMOutputMediaProps **ppOutput);
void __RPC_STUB IWMReader_GetOutputProps_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IWMReader_SetOutputProps_Proxy(
    IWMReader* This,
    DWORD dwOutputNum,
    IWMOutputMediaProps *pOutput);
void __RPC_STUB IWMReader_SetOutputProps_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IWMReader_GetOutputFormatCount_Proxy(
    IWMReader* This,
    DWORD dwOutputNumber,
    DWORD *pcFormats);
void __RPC_STUB IWMReader_GetOutputFormatCount_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IWMReader_GetOutputFormat_Proxy(
    IWMReader* This,
    DWORD dwOutputNumber,
    DWORD dwFormatNumber,
    IWMOutputMediaProps **ppProps);
void __RPC_STUB IWMReader_GetOutputFormat_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IWMReader_Start_Proxy(
    IWMReader* This,
    QWORD cnsStart,
    QWORD cnsDuration,
    float fRate,
    void *pvContext);
void __RPC_STUB IWMReader_Start_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IWMReader_Stop_Proxy(
    IWMReader* This);
void __RPC_STUB IWMReader_Stop_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IWMReader_Pause_Proxy(
    IWMReader* This);
void __RPC_STUB IWMReader_Pause_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IWMReader_Resume_Proxy(
    IWMReader* This);
void __RPC_STUB IWMReader_Resume_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IWMReader_INTERFACE_DEFINED__ */

/*****************************************************************************
 * IWMSyncReader interface
 */
#ifndef __IWMSyncReader_INTERFACE_DEFINED__
#define __IWMSyncReader_INTERFACE_DEFINED__

DEFINE_GUID(IID_IWMSyncReader, 0x9397f121, 0x7705, 0x4dc9, 0xb0,0x49, 0x98,0xb6,0x98,0x18,0x84,0x14);
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("9397f121-7705-4dc9-b049-98b698188414")
IWMSyncReader : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE Open(
        const WCHAR *pwszFilename) = 0;

    virtual HRESULT STDMETHODCALLTYPE Close(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetRange(
        QWORD cnsStartTime,
        LONGLONG cnsDuration) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetRangeByFrame(
        WORD wStreamNum,
        QWORD qwFrameNumber,
        LONGLONG cFramesToRead) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetNextSample(
        WORD wStreamNum,
        INSSBuffer **ppSample,
        QWORD *pcnsSampleTime,
        QWORD *pcnsDuration,
        DWORD *pdwFlags,
        DWORD *pdwOutputNum,
        WORD *pwStreamNum) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetStreamsSelected(
        WORD cStreamCount,
        WORD *pwStreamNumbers,
        WMT_STREAM_SELECTION *pSelections) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetStreamSelected(
        WORD wStreamNum,
        WMT_STREAM_SELECTION *pSelection) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetReadStreamSamples(
        WORD wStreamNum,
        BOOL fCompressed) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetReadStreamSamples(
        WORD wStreamNum,
        BOOL *pfCompressed) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetOutputSetting(
        DWORD dwOutputNum,
        LPCWSTR pszName,
        WMT_ATTR_DATATYPE *pType,
        BYTE *pValue,
        WORD *pcbLength) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetOutputSetting(
        DWORD dwOutputNum,
        LPCWSTR pszName,
        WMT_ATTR_DATATYPE Type,
        const BYTE *pValue,
        WORD cbLength) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetOutputCount(
        DWORD *pcOutputs) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetOutputProps(
        DWORD dwOutputNum,
        IWMOutputMediaProps **ppOutput) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetOutputProps(
        DWORD dwOutputNum,
        IWMOutputMediaProps *pOutput) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetOutputFormatCount(
        DWORD dwOutputNum,
        DWORD *pcFormats) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetOutputFormat(
        DWORD dwOutputNum,
        DWORD dwFormatNum,
        IWMOutputMediaProps **ppProps) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetOutputNumberForStream(
        WORD wStreamNum,
        DWORD *pdwOutputNum) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetStreamNumberForOutput(
        DWORD dwOutputNum,
        WORD *pwStreamNum) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetMaxOutputSampleSize(
        DWORD dwOutput,
        DWORD *pcbMax) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetMaxStreamSampleSize(
        WORD wStream,
        DWORD *pcbMax) = 0;

    virtual HRESULT STDMETHODCALLTYPE OpenStream(
        IStream *pStream) = 0;

};
#ifdef __CRT_UUID_DECL
__CRT_UUID_DECL(IWMSyncReader, 0x9397f121, 0x7705, 0x4dc9, 0xb0,0x49, 0x98,0xb6,0x98,0x18,0x84,0x14)
#endif
#else
typedef struct IWMSyncReaderVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IWMSyncReader* This,
        REFIID riid,
        void **ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IWMSyncReader* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IWMSyncReader* This);

    /*** IWMSyncReader methods ***/
    HRESULT (STDMETHODCALLTYPE *Open)(
        IWMSyncReader* This,
        const WCHAR *pwszFilename);

    HRESULT (STDMETHODCALLTYPE *Close)(
        IWMSyncReader* This);

    HRESULT (STDMETHODCALLTYPE *SetRange)(
        IWMSyncReader* This,
        QWORD cnsStartTime,
        LONGLONG cnsDuration);

    HRESULT (STDMETHODCALLTYPE *SetRangeByFrame)(
        IWMSyncReader* This,
        WORD wStreamNum,
        QWORD qwFrameNumber,
        LONGLONG cFramesToRead);

    HRESULT (STDMETHODCALLTYPE *GetNextSample)(
        IWMSyncReader* This,
        WORD wStreamNum,
        INSSBuffer **ppSample,
        QWORD *pcnsSampleTime,
        QWORD *pcnsDuration,
        DWORD *pdwFlags,
        DWORD *pdwOutputNum,
        WORD *pwStreamNum);

    HRESULT (STDMETHODCALLTYPE *SetStreamsSelected)(
        IWMSyncReader* This,
        WORD cStreamCount,
        WORD *pwStreamNumbers,
        WMT_STREAM_SELECTION *pSelections);

    HRESULT (STDMETHODCALLTYPE *GetStreamSelected)(
        IWMSyncReader* This,
        WORD wStreamNum,
        WMT_STREAM_SELECTION *pSelection);

    HRESULT (STDMETHODCALLTYPE *SetReadStreamSamples)(
        IWMSyncReader* This,
        WORD wStreamNum,
        BOOL fCompressed);

    HRESULT (STDMETHODCALLTYPE *GetReadStreamSamples)(
        IWMSyncReader* This,
        WORD wStreamNum,
        BOOL *pfCompressed);

    HRESULT (STDMETHODCALLTYPE *GetOutputSetting)(
        IWMSyncReader* This,
        DWORD dwOutputNum,
        LPCWSTR pszName,
        WMT_ATTR_DATATYPE *pType,
        BYTE *pValue,
        WORD *pcbLength);

    HRESULT (STDMETHODCALLTYPE *SetOutputSetting)(
        IWMSyncReader* This,
        DWORD dwOutputNum,
        LPCWSTR pszName,
        WMT_ATTR_DATATYPE Type,
        const BYTE *pValue,
        WORD cbLength);

    HRESULT (STDMETHODCALLTYPE *GetOutputCount)(
        IWMSyncReader* This,
        DWORD *pcOutputs);

    HRESULT (STDMETHODCALLTYPE *GetOutputProps)(
        IWMSyncReader* This,
        DWORD dwOutputNum,
        IWMOutputMediaProps **ppOutput);

    HRESULT (STDMETHODCALLTYPE *SetOutputProps)(
        IWMSyncReader* This,
        DWORD dwOutputNum,
        IWMOutputMediaProps *pOutput);

    HRESULT (STDMETHODCALLTYPE *GetOutputFormatCount)(
        IWMSyncReader* This,
        DWORD dwOutputNum,
        DWORD *pcFormats);

    HRESULT (STDMETHODCALLTYPE *GetOutputFormat)(
        IWMSyncReader* This,
        DWORD dwOutputNum,
        DWORD dwFormatNum,
        IWMOutputMediaProps **ppProps);

    HRESULT (STDMETHODCALLTYPE *GetOutputNumberForStream)(
        IWMSyncReader* This,
        WORD wStreamNum,
        DWORD *pdwOutputNum);

    HRESULT (STDMETHODCALLTYPE *GetStreamNumberForOutput)(
        IWMSyncReader* This,
        DWORD dwOutputNum,
        WORD *pwStreamNum);

    HRESULT (STDMETHODCALLTYPE *GetMaxOutputSampleSize)(
        IWMSyncReader* This,
        DWORD dwOutput,
        DWORD *pcbMax);

    HRESULT (STDMETHODCALLTYPE *GetMaxStreamSampleSize)(
        IWMSyncReader* This,
        WORD wStream,
        DWORD *pcbMax);

    HRESULT (STDMETHODCALLTYPE *OpenStream)(
        IWMSyncReader* This,
        IStream *pStream);

    END_INTERFACE
} IWMSyncReaderVtbl;
interface IWMSyncReader {
    CONST_VTBL IWMSyncReaderVtbl* lpVtbl;
};

#ifdef COBJMACROS
#ifndef WIDL_C_INLINE_WRAPPERS
/*** IUnknown methods ***/
#define IWMSyncReader_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
#define IWMSyncReader_AddRef(This) (This)->lpVtbl->AddRef(This)
#define IWMSyncReader_Release(This) (This)->lpVtbl->Release(This)
/*** IWMSyncReader methods ***/
#define IWMSyncReader_Open(This,pwszFilename) (This)->lpVtbl->Open(This,pwszFilename)
#define IWMSyncReader_Close(This) (This)->lpVtbl->Close(This)
#define IWMSyncReader_SetRange(This,cnsStartTime,cnsDuration) (This)->lpVtbl->SetRange(This,cnsStartTime,cnsDuration)
#define IWMSyncReader_SetRangeByFrame(This,wStreamNum,qwFrameNumber,cFramesToRead) (This)->lpVtbl->SetRangeByFrame(This,wStreamNum,qwFrameNumber,cFramesToRead)
#define IWMSyncReader_GetNextSample(This,wStreamNum,ppSample,pcnsSampleTime,pcnsDuration,pdwFlags,pdwOutputNum,pwStreamNum) (This)->lpVtbl->GetNextSample(This,wStreamNum,ppSample,pcnsSampleTime,pcnsDuration,pdwFlags,pdwOutputNum,pwStreamNum)
#define IWMSyncReader_SetStreamsSelected(This,cStreamCount,pwStreamNumbers,pSelections) (This)->lpVtbl->SetStreamsSelected(This,cStreamCount,pwStreamNumbers,pSelections)
#define IWMSyncReader_GetStreamSelected(This,wStreamNum,pSelection) (This)->lpVtbl->GetStreamSelected(This,wStreamNum,pSelection)
#define IWMSyncReader_SetReadStreamSamples(This,wStreamNum,fCompressed) (This)->lpVtbl->SetReadStreamSamples(This,wStreamNum,fCompressed)
#define IWMSyncReader_GetReadStreamSamples(This,wStreamNum,pfCompressed) (This)->lpVtbl->GetReadStreamSamples(This,wStreamNum,pfCompressed)
#define IWMSyncReader_GetOutputSetting(This,dwOutputNum,pszName,pType,pValue,pcbLength) (This)->lpVtbl->GetOutputSetting(This,dwOutputNum,pszName,pType,pValue,pcbLength)
#define IWMSyncReader_SetOutputSetting(This,dwOutputNum,pszName,Type,pValue,cbLength) (This)->lpVtbl->SetOutputSetting(This,dwOutputNum,pszName,Type,pValue,cbLength)
#define IWMSyncReader_GetOutputCount(This,pcOutputs) (This)->lpVtbl->GetOutputCount(This,pcOutputs)
#define IWMSyncReader_GetOutputProps(This,dwOutputNum,ppOutput) (This)->lpVtbl->GetOutputProps(This,dwOutputNum,ppOutput)
#define IWMSyncReader_SetOutputProps(This,dwOutputNum,pOutput) (This)->lpVtbl->SetOutputProps(This,dwOutputNum,pOutput)
#define IWMSyncReader_GetOutputFormatCount(This,dwOutputNum,pcFormats) (This)->lpVtbl->GetOutputFormatCount(This,dwOutputNum,pcFormats)
#define IWMSyncReader_GetOutputFormat(This,dwOutputNum,dwFormatNum,ppProps) (This)->lpVtbl->GetOutputFormat(This,dwOutputNum,dwFormatNum,ppProps)
#define IWMSyncReader_GetOutputNumberForStream(This,wStreamNum,pdwOutputNum) (This)->lpVtbl->GetOutputNumberForStream(This,wStreamNum,pdwOutputNum)
#define IWMSyncReader_GetStreamNumberForOutput(This,dwOutputNum,pwStreamNum) (This)->lpVtbl->GetStreamNumberForOutput(This,dwOutputNum,pwStreamNum)
#define IWMSyncReader_GetMaxOutputSampleSize(This,dwOutput,pcbMax) (This)->lpVtbl->GetMaxOutputSampleSize(This,dwOutput,pcbMax)
#define IWMSyncReader_GetMaxStreamSampleSize(This,wStream,pcbMax) (This)->lpVtbl->GetMaxStreamSampleSize(This,wStream,pcbMax)
#define IWMSyncReader_OpenStream(This,pStream) (This)->lpVtbl->OpenStream(This,pStream)
#else
/*** IUnknown methods ***/
static FORCEINLINE HRESULT IWMSyncReader_QueryInterface(IWMSyncReader* This,REFIID riid,void **ppvObject) {
    return This->lpVtbl->QueryInterface(This,riid,ppvObject);
}
static FORCEINLINE ULONG IWMSyncReader_AddRef(IWMSyncReader* This) {
    return This->lpVtbl->AddRef(This);
}
static FORCEINLINE ULONG IWMSyncReader_Release(IWMSyncReader* This) {
    return This->lpVtbl->Release(This);
}
/*** IWMSyncReader methods ***/
static FORCEINLINE HRESULT IWMSyncReader_Open(IWMSyncReader* This,const WCHAR *pwszFilename) {
    return This->lpVtbl->Open(This,pwszFilename);
}
static FORCEINLINE HRESULT IWMSyncReader_Close(IWMSyncReader* This) {
    return This->lpVtbl->Close(This);
}
static FORCEINLINE HRESULT IWMSyncReader_SetRange(IWMSyncReader* This,QWORD cnsStartTime,LONGLONG cnsDuration) {
    return This->lpVtbl->SetRange(This,cnsStartTime,cnsDuration);
}
static FORCEINLINE HRESULT IWMSyncReader_SetRangeByFrame(IWMSyncReader* This,WORD wStreamNum,QWORD qwFrameNumber,LONGLONG cFramesToRead) {
    return This->lpVtbl->SetRangeByFrame(This,wStreamNum,qwFrameNumber,cFramesToRead);
}
static FORCEINLINE HRESULT IWMSyncReader_GetNextSample(IWMSyncReader* This,WORD wStreamNum,INSSBuffer **ppSample,QWORD *pcnsSampleTime,QWORD *pcnsDuration,DWORD *pdwFlags,DWORD *pdwOutputNum,WORD *pwStreamNum) {
    return This->lpVtbl->GetNextSample(This,wStreamNum,ppSample,pcnsSampleTime,pcnsDuration,pdwFlags,pdwOutputNum,pwStreamNum);
}
static FORCEINLINE HRESULT IWMSyncReader_SetStreamsSelected(IWMSyncReader* This,WORD cStreamCount,WORD *pwStreamNumbers,WMT_STREAM_SELECTION *pSelections) {
    return This->lpVtbl->SetStreamsSelected(This,cStreamCount,pwStreamNumbers,pSelections);
}
static FORCEINLINE HRESULT IWMSyncReader_GetStreamSelected(IWMSyncReader* This,WORD wStreamNum,WMT_STREAM_SELECTION *pSelection) {
    return This->lpVtbl->GetStreamSelected(This,wStreamNum,pSelection);
}
static FORCEINLINE HRESULT IWMSyncReader_SetReadStreamSamples(IWMSyncReader* This,WORD wStreamNum,BOOL fCompressed) {
    return This->lpVtbl->SetReadStreamSamples(This,wStreamNum,fCompressed);
}
static FORCEINLINE HRESULT IWMSyncReader_GetReadStreamSamples(IWMSyncReader* This,WORD wStreamNum,BOOL *pfCompressed) {
    return This->lpVtbl->GetReadStreamSamples(This,wStreamNum,pfCompressed);
}
static FORCEINLINE HRESULT IWMSyncReader_GetOutputSetting(IWMSyncReader* This,DWORD dwOutputNum,LPCWSTR pszName,WMT_ATTR_DATATYPE *pType,BYTE *pValue,WORD *pcbLength) {
    return This->lpVtbl->GetOutputSetting(This,dwOutputNum,pszName,pType,pValue,pcbLength);
}
static FORCEINLINE HRESULT IWMSyncReader_SetOutputSetting(IWMSyncReader* This,DWORD dwOutputNum,LPCWSTR pszName,WMT_ATTR_DATATYPE Type,const BYTE *pValue,WORD cbLength) {
    return This->lpVtbl->SetOutputSetting(This,dwOutputNum,pszName,Type,pValue,cbLength);
}
static FORCEINLINE HRESULT IWMSyncReader_GetOutputCount(IWMSyncReader* This,DWORD *pcOutputs) {
    return This->lpVtbl->GetOutputCount(This,pcOutputs);
}
static FORCEINLINE HRESULT IWMSyncReader_GetOutputProps(IWMSyncReader* This,DWORD dwOutputNum,IWMOutputMediaProps **ppOutput) {
    return This->lpVtbl->GetOutputProps(This,dwOutputNum,ppOutput);
}
static FORCEINLINE HRESULT IWMSyncReader_SetOutputProps(IWMSyncReader* This,DWORD dwOutputNum,IWMOutputMediaProps *pOutput) {
    return This->lpVtbl->SetOutputProps(This,dwOutputNum,pOutput);
}
static FORCEINLINE HRESULT IWMSyncReader_GetOutputFormatCount(IWMSyncReader* This,DWORD dwOutputNum,DWORD *pcFormats) {
    return This->lpVtbl->GetOutputFormatCount(This,dwOutputNum,pcFormats);
}
static FORCEINLINE HRESULT IWMSyncReader_GetOutputFormat(IWMSyncReader* This,DWORD dwOutputNum,DWORD dwFormatNum,IWMOutputMediaProps **ppProps) {
    return This->lpVtbl->GetOutputFormat(This,dwOutputNum,dwFormatNum,ppProps);
}
static FORCEINLINE HRESULT IWMSyncReader_GetOutputNumberForStream(IWMSyncReader* This,WORD wStreamNum,DWORD *pdwOutputNum) {
    return This->lpVtbl->GetOutputNumberForStream(This,wStreamNum,pdwOutputNum);
}
static FORCEINLINE HRESULT IWMSyncReader_GetStreamNumberForOutput(IWMSyncReader* This,DWORD dwOutputNum,WORD *pwStreamNum) {
    return This->lpVtbl->GetStreamNumberForOutput(This,dwOutputNum,pwStreamNum);
}
static FORCEINLINE HRESULT IWMSyncReader_GetMaxOutputSampleSize(IWMSyncReader* This,DWORD dwOutput,DWORD *pcbMax) {
    return This->lpVtbl->GetMaxOutputSampleSize(This,dwOutput,pcbMax);
}
static FORCEINLINE HRESULT IWMSyncReader_GetMaxStreamSampleSize(IWMSyncReader* This,WORD wStream,DWORD *pcbMax) {
    return This->lpVtbl->GetMaxStreamSampleSize(This,wStream,pcbMax);
}
static FORCEINLINE HRESULT IWMSyncReader_OpenStream(IWMSyncReader* This,IStream *pStream) {
    return This->lpVtbl->OpenStream(This,pStream);
}
#endif
#endif

#endif

HRESULT STDMETHODCALLTYPE IWMSyncReader_Open_Proxy(
    IWMSyncReader* This,
    const WCHAR *pwszFilename);
void __RPC_STUB IWMSyncReader_Open_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IWMSyncReader_Close_Proxy(
    IWMSyncReader* This);
void __RPC_STUB IWMSyncReader_Close_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IWMSyncReader_SetRange_Proxy(
    IWMSyncReader* This,
    QWORD cnsStartTime,
    LONGLONG cnsDuration);
void __RPC_STUB IWMSyncReader_SetRange_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IWMSyncReader_SetRangeByFrame_Proxy(
    IWMSyncReader* This,
    WORD wStreamNum,
    QWORD qwFrameNumber,
    LONGLONG cFramesToRead);
void __RPC_STUB IWMSyncReader_SetRangeByFrame_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IWMSyncReader_GetNextSample_Proxy(
    IWMSyncReader* This,
    WORD wStreamNum,
    INSSBuffer **ppSample,
    QWORD *pcnsSampleTime,
    QWORD *pcnsDuration,
    DWORD *pdwFlags,
    DWORD *pdwOutputNum,
    WORD *pwStreamNum);
void __RPC_STUB IWMSyncReader_GetNextSample_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IWMSyncReader_SetStreamsSelected_Proxy(
    IWMSyncReader* This,
    WORD cStreamCount,
    WORD *pwStreamNumbers,
    WMT_STREAM_SELECTION *pSelections);
void __RPC_STUB IWMSyncReader_SetStreamsSelected_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IWMSyncReader_GetStreamSelected_Proxy(
    IWMSyncReader* This,
    WORD wStreamNum,
    WMT_STREAM_SELECTION *pSelection);
void __RPC_STUB IWMSyncReader_GetStreamSelected_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IWMSyncReader_SetReadStreamSamples_Proxy(
    IWMSyncReader* This,
    WORD wStreamNum,
    BOOL fCompressed);
void __RPC_STUB IWMSyncReader_SetReadStreamSamples_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IWMSyncReader_GetReadStreamSamples_Proxy(
    IWMSyncReader* This,
    WORD wStreamNum,
    BOOL *pfCompressed);
void __RPC_STUB IWMSyncReader_GetReadStreamSamples_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IWMSyncReader_GetOutputSetting_Proxy(
    IWMSyncReader* This,
    DWORD dwOutputNum,
    LPCWSTR pszName,
    WMT_ATTR_DATATYPE *pType,
    BYTE *pValue,
    WORD *pcbLength);
void __RPC_STUB IWMSyncReader_GetOutputSetting_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IWMSyncReader_SetOutputSetting_Proxy(
    IWMSyncReader* This,
    DWORD dwOutputNum,
    LPCWSTR pszName,
    WMT_ATTR_DATATYPE Type,
    const BYTE *pValue,
    WORD cbLength);
void __RPC_STUB IWMSyncReader_SetOutputSetting_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IWMSyncReader_GetOutputCount_Proxy(
    IWMSyncReader* This,
    DWORD *pcOutputs);
void __RPC_STUB IWMSyncReader_GetOutputCount_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IWMSyncReader_GetOutputProps_Proxy(
    IWMSyncReader* This,
    DWORD dwOutputNum,
    IWMOutputMediaProps **ppOutput);
void __RPC_STUB IWMSyncReader_GetOutputProps_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IWMSyncReader_SetOutputProps_Proxy(
    IWMSyncReader* This,
    DWORD dwOutputNum,
    IWMOutputMediaProps *pOutput);
void __RPC_STUB IWMSyncReader_SetOutputProps_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IWMSyncReader_GetOutputFormatCount_Proxy(
    IWMSyncReader* This,
    DWORD dwOutputNum,
    DWORD *pcFormats);
void __RPC_STUB IWMSyncReader_GetOutputFormatCount_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IWMSyncReader_GetOutputFormat_Proxy(
    IWMSyncReader* This,
    DWORD dwOutputNum,
    DWORD dwFormatNum,
    IWMOutputMediaProps **ppProps);
void __RPC_STUB IWMSyncReader_GetOutputFormat_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IWMSyncReader_GetOutputNumberForStream_Proxy(
    IWMSyncReader* This,
    WORD wStreamNum,
    DWORD *pdwOutputNum);
void __RPC_STUB IWMSyncReader_GetOutputNumberForStream_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IWMSyncReader_GetStreamNumberForOutput_Proxy(
    IWMSyncReader* This,
    DWORD dwOutputNum,
    WORD *pwStreamNum);
void __RPC_STUB IWMSyncReader_GetStreamNumberForOutput_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IWMSyncReader_GetMaxOutputSampleSize_Proxy(
    IWMSyncReader* This,
    DWORD dwOutput,
    DWORD *pcbMax);
void __RPC_STUB IWMSyncReader_GetMaxOutputSampleSize_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IWMSyncReader_GetMaxStreamSampleSize_Proxy(
    IWMSyncReader* This,
    WORD wStream,
    DWORD *pcbMax);
void __RPC_STUB IWMSyncReader_GetMaxStreamSampleSize_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IWMSyncReader_OpenStream_Proxy(
    IWMSyncReader* This,
    IStream *pStream);
void __RPC_STUB IWMSyncReader_OpenStream_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IWMSyncReader_INTERFACE_DEFINED__ */

/* Begin additional prototypes for all interfaces */


/* End additional prototypes */

#ifdef __cplusplus
}
#endif

#endif /* __wmsdkidl_h__ */