/*** Autogenerated by WIDL 0.1 from mmstream.idl - Do not edit ***/
#include <rpc.h>
#include <rpcndr.h>

#ifndef __WIDL_MMSTREAM_H
#define __WIDL_MMSTREAM_H
#ifdef __cplusplus
extern "C" {
#endif
#include <unknwn.h>
#define MS_ERROR_CODE(x)                  MAKE_HRESULT(1, FACILITY_ITF, (x) + 0x400)
#define MS_SUCCESS_CODE(x)                MAKE_HRESULT(0, FACILITY_ITF, x)
#define MS_S_PENDING                      MS_SUCCESS_CODE(1)
#define MS_S_NOUPDATE                     MS_SUCCESS_CODE(2)
#define MS_S_ENDOFSTREAM                  MS_SUCCESS_CODE(3)
#define MS_E_SAMPLEALLOC                  MS_ERROR_CODE(1)
#define MS_E_PURPOSEID                    MS_ERROR_CODE(2)
#define MS_E_NOSTREAM                     MS_ERROR_CODE(3)
#define MS_E_NOSEEKING                    MS_ERROR_CODE(4)
#define MS_E_INCOMPATIBLE                 MS_ERROR_CODE(5)
#define MS_E_BUSY                         MS_ERROR_CODE(6)
#define MS_E_NOTINIT                      MS_ERROR_CODE(7)
#define MS_E_SOURCEALREADYDEFINED         MS_ERROR_CODE(8)
#define MS_E_INVALIDSTREAMTYPE            MS_ERROR_CODE(9)
#define MS_E_NOTRUNNING                   MS_ERROR_CODE(10)
DEFINE_GUID(MSPID_PrimaryVideo,  0xa35ff56a, 0x9fda, 0x11d0, 0x8f, 0xdf, 0x0, 0xc0, 0x4f, 0xd9, 0x18, 0x9d);
DEFINE_GUID(MSPID_PrimaryAudio,  0xa35ff56b, 0x9fda, 0x11d0, 0x8f, 0xdf, 0x0, 0xc0, 0x4f, 0xd9, 0x18, 0x9d);
#if 0
typedef void *PAPCFUNC;

#endif
typedef LONGLONG STREAM_TIME;

typedef GUID MSPID;

typedef REFGUID REFMSPID;

typedef enum {
    STREAMTYPE_READ = 0,
    STREAMTYPE_WRITE = 1,
    STREAMTYPE_TRANSFORM = 2
} STREAM_TYPE;

typedef enum {
    STREAMSTATE_STOP = 0,
    STREAMSTATE_RUN = 1
} STREAM_STATE;

typedef enum {
    COMPSTAT_NOUPDATEOK = 0x1,
    COMPSTAT_WAIT = 0x2,
    COMPSTAT_ABORT = 0x4
} COMPLETION_STATUS_FLAGS;

enum {
    MMSSF_HASCLOCK = 0x1,
    MMSSF_SUPPORTSEEK = 0x2,
    MMSSF_ASYNCHRONOUS = 0x4
};

enum {
    SSUPDATE_ASYNC = 0x1,
    SSUPDATE_CONTINUOUS = 0x2
};

#ifndef __IMultiMediaStream_FWD_DEFINED__
#define __IMultiMediaStream_FWD_DEFINED__
typedef struct IMultiMediaStream IMultiMediaStream;
#endif

#ifndef __IMediaStream_FWD_DEFINED__
#define __IMediaStream_FWD_DEFINED__
typedef struct IMediaStream IMediaStream;
#endif

#ifndef __IStreamSample_FWD_DEFINED__
#define __IStreamSample_FWD_DEFINED__
typedef struct IStreamSample IStreamSample;
#endif

/*****************************************************************************
 * IMultiMediaStream interface
 */
#ifndef __IMultiMediaStream_INTERFACE_DEFINED__
#define __IMultiMediaStream_INTERFACE_DEFINED__

DEFINE_GUID(IID_IMultiMediaStream, 0xb502d1bc, 0x9a57, 0x11d0, 0x8f,0xde, 0x00,0xc0,0x4f,0xd9,0x18,0x9d);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IMultiMediaStream : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE GetInformation(
        char* pdwFlags,
        STREAM_TYPE* pStreamType) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetMediaStream(
        REFMSPID idPurpose,
        IMediaStream** ppMediaStream) = 0;

    virtual HRESULT STDMETHODCALLTYPE EnumMediaStreams(
        long Index,
        IMediaStream** ppMediaStream) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetState(
        STREAM_STATE* pCurrentState) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetState(
        STREAM_STATE NewState) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetTime(
        STREAM_TIME* pCurrentTime) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetDuration(
        STREAM_TIME* pDuration) = 0;

    virtual HRESULT STDMETHODCALLTYPE Seek(
        STREAM_TIME SeekTime) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetEndOfStreamEventHandle(
        HANDLE* phEOS) = 0;

};
#else
typedef struct IMultiMediaStreamVtbl IMultiMediaStreamVtbl;
struct IMultiMediaStream {
    const IMultiMediaStreamVtbl* lpVtbl;
};
struct IMultiMediaStreamVtbl {
    BEGIN_INTERFACE

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

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

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

    /*** IMultiMediaStream methods ***/
    HRESULT (STDMETHODCALLTYPE *GetInformation)(
        IMultiMediaStream* This,
        char* pdwFlags,
        STREAM_TYPE* pStreamType);

    HRESULT (STDMETHODCALLTYPE *GetMediaStream)(
        IMultiMediaStream* This,
        REFMSPID idPurpose,
        IMediaStream** ppMediaStream);

    HRESULT (STDMETHODCALLTYPE *EnumMediaStreams)(
        IMultiMediaStream* This,
        long Index,
        IMediaStream** ppMediaStream);

    HRESULT (STDMETHODCALLTYPE *GetState)(
        IMultiMediaStream* This,
        STREAM_STATE* pCurrentState);

    HRESULT (STDMETHODCALLTYPE *SetState)(
        IMultiMediaStream* This,
        STREAM_STATE NewState);

    HRESULT (STDMETHODCALLTYPE *GetTime)(
        IMultiMediaStream* This,
        STREAM_TIME* pCurrentTime);

    HRESULT (STDMETHODCALLTYPE *GetDuration)(
        IMultiMediaStream* This,
        STREAM_TIME* pDuration);

    HRESULT (STDMETHODCALLTYPE *Seek)(
        IMultiMediaStream* This,
        STREAM_TIME SeekTime);

    HRESULT (STDMETHODCALLTYPE *GetEndOfStreamEventHandle)(
        IMultiMediaStream* This,
        HANDLE* phEOS);

    END_INTERFACE
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IMultiMediaStream_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IMultiMediaStream_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IMultiMediaStream_Release(p) (p)->lpVtbl->Release(p)
/*** IMultiMediaStream methods ***/
#define IMultiMediaStream_GetInformation(p,a,b) (p)->lpVtbl->GetInformation(p,a,b)
#define IMultiMediaStream_GetMediaStream(p,a,b) (p)->lpVtbl->GetMediaStream(p,a,b)
#define IMultiMediaStream_EnumMediaStreams(p,a,b) (p)->lpVtbl->EnumMediaStreams(p,a,b)
#define IMultiMediaStream_GetState(p,a) (p)->lpVtbl->GetState(p,a)
#define IMultiMediaStream_SetState(p,a) (p)->lpVtbl->SetState(p,a)
#define IMultiMediaStream_GetTime(p,a) (p)->lpVtbl->GetTime(p,a)
#define IMultiMediaStream_GetDuration(p,a) (p)->lpVtbl->GetDuration(p,a)
#define IMultiMediaStream_Seek(p,a) (p)->lpVtbl->Seek(p,a)
#define IMultiMediaStream_GetEndOfStreamEventHandle(p,a) (p)->lpVtbl->GetEndOfStreamEventHandle(p,a)
#endif

#endif

#define IMultiMediaStream_METHODS \
    /*** IUnknown methods ***/ \
    STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \
    STDMETHOD_(ULONG,AddRef)(THIS) PURE; \
    STDMETHOD_(ULONG,Release)(THIS) PURE; \
    /*** IMultiMediaStream methods ***/ \
    STDMETHOD_(HRESULT,GetInformation)(THIS_ char* pdwFlags, STREAM_TYPE* pStreamType) PURE; \
    STDMETHOD_(HRESULT,GetMediaStream)(THIS_ REFMSPID idPurpose, IMediaStream** ppMediaStream) PURE; \
    STDMETHOD_(HRESULT,EnumMediaStreams)(THIS_ long Index, IMediaStream** ppMediaStream) PURE; \
    STDMETHOD_(HRESULT,GetState)(THIS_ STREAM_STATE* pCurrentState) PURE; \
    STDMETHOD_(HRESULT,SetState)(THIS_ STREAM_STATE NewState) PURE; \
    STDMETHOD_(HRESULT,GetTime)(THIS_ STREAM_TIME* pCurrentTime) PURE; \
    STDMETHOD_(HRESULT,GetDuration)(THIS_ STREAM_TIME* pDuration) PURE; \
    STDMETHOD_(HRESULT,Seek)(THIS_ STREAM_TIME SeekTime) PURE; \
    STDMETHOD_(HRESULT,GetEndOfStreamEventHandle)(THIS_ HANDLE* phEOS) PURE;

HRESULT CALLBACK IMultiMediaStream_GetInformation_Proxy(
    IMultiMediaStream* This,
    char* pdwFlags,
    STREAM_TYPE* pStreamType);
void __RPC_STUB IMultiMediaStream_GetInformation_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMultiMediaStream_GetMediaStream_Proxy(
    IMultiMediaStream* This,
    REFMSPID idPurpose,
    IMediaStream** ppMediaStream);
void __RPC_STUB IMultiMediaStream_GetMediaStream_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMultiMediaStream_EnumMediaStreams_Proxy(
    IMultiMediaStream* This,
    long Index,
    IMediaStream** ppMediaStream);
void __RPC_STUB IMultiMediaStream_EnumMediaStreams_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMultiMediaStream_GetState_Proxy(
    IMultiMediaStream* This,
    STREAM_STATE* pCurrentState);
void __RPC_STUB IMultiMediaStream_GetState_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMultiMediaStream_SetState_Proxy(
    IMultiMediaStream* This,
    STREAM_STATE NewState);
void __RPC_STUB IMultiMediaStream_SetState_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMultiMediaStream_GetTime_Proxy(
    IMultiMediaStream* This,
    STREAM_TIME* pCurrentTime);
void __RPC_STUB IMultiMediaStream_GetTime_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMultiMediaStream_GetDuration_Proxy(
    IMultiMediaStream* This,
    STREAM_TIME* pDuration);
void __RPC_STUB IMultiMediaStream_GetDuration_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMultiMediaStream_Seek_Proxy(
    IMultiMediaStream* This,
    STREAM_TIME SeekTime);
void __RPC_STUB IMultiMediaStream_Seek_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMultiMediaStream_GetEndOfStreamEventHandle_Proxy(
    IMultiMediaStream* This,
    HANDLE* phEOS);
void __RPC_STUB IMultiMediaStream_GetEndOfStreamEventHandle_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IMultiMediaStream_INTERFACE_DEFINED__ */

/*****************************************************************************
 * IMediaStream interface
 */
#ifndef __IMediaStream_INTERFACE_DEFINED__
#define __IMediaStream_INTERFACE_DEFINED__

DEFINE_GUID(IID_IMediaStream, 0xb502d1bd, 0x9a57, 0x11d0, 0x8f,0xde, 0x00,0xc0,0x4f,0xd9,0x18,0x9d);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IMediaStream : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE GetMultiMediaStream(
        IMultiMediaStream** ppMultiMediaStream) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetInformation(
        MSPID* pPurposeId,
        STREAM_TYPE* pType) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetSameFormat(
        IMediaStream* pStreamThatHasDesiredFormat,
        DWORD dwFlags) = 0;

    virtual HRESULT STDMETHODCALLTYPE AllocateSample(
        DWORD dwFlags,
        IStreamSample** ppSample) = 0;

    virtual HRESULT STDMETHODCALLTYPE CreateSharedSample(
        IStreamSample* pExistingSample,
        DWORD dwFlags,
        IStreamSample** ppNewSample) = 0;

    virtual HRESULT STDMETHODCALLTYPE SendEndOfStream(
        DWORD dwFlags) = 0;

};
#else
typedef struct IMediaStreamVtbl IMediaStreamVtbl;
struct IMediaStream {
    const IMediaStreamVtbl* lpVtbl;
};
struct IMediaStreamVtbl {
    BEGIN_INTERFACE

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

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

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

    /*** IMediaStream methods ***/
    HRESULT (STDMETHODCALLTYPE *GetMultiMediaStream)(
        IMediaStream* This,
        IMultiMediaStream** ppMultiMediaStream);

    HRESULT (STDMETHODCALLTYPE *GetInformation)(
        IMediaStream* This,
        MSPID* pPurposeId,
        STREAM_TYPE* pType);

    HRESULT (STDMETHODCALLTYPE *SetSameFormat)(
        IMediaStream* This,
        IMediaStream* pStreamThatHasDesiredFormat,
        DWORD dwFlags);

    HRESULT (STDMETHODCALLTYPE *AllocateSample)(
        IMediaStream* This,
        DWORD dwFlags,
        IStreamSample** ppSample);

    HRESULT (STDMETHODCALLTYPE *CreateSharedSample)(
        IMediaStream* This,
        IStreamSample* pExistingSample,
        DWORD dwFlags,
        IStreamSample** ppNewSample);

    HRESULT (STDMETHODCALLTYPE *SendEndOfStream)(
        IMediaStream* This,
        DWORD dwFlags);

    END_INTERFACE
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IMediaStream_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IMediaStream_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IMediaStream_Release(p) (p)->lpVtbl->Release(p)
/*** IMediaStream methods ***/
#define IMediaStream_GetMultiMediaStream(p,a) (p)->lpVtbl->GetMultiMediaStream(p,a)
#define IMediaStream_GetInformation(p,a,b) (p)->lpVtbl->GetInformation(p,a,b)
#define IMediaStream_SetSameFormat(p,a,b) (p)->lpVtbl->SetSameFormat(p,a,b)
#define IMediaStream_AllocateSample(p,a,b) (p)->lpVtbl->AllocateSample(p,a,b)
#define IMediaStream_CreateSharedSample(p,a,b,c) (p)->lpVtbl->CreateSharedSample(p,a,b,c)
#define IMediaStream_SendEndOfStream(p,a) (p)->lpVtbl->SendEndOfStream(p,a)
#endif

#endif

#define IMediaStream_METHODS \
    /*** IUnknown methods ***/ \
    STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \
    STDMETHOD_(ULONG,AddRef)(THIS) PURE; \
    STDMETHOD_(ULONG,Release)(THIS) PURE; \
    /*** IMediaStream methods ***/ \
    STDMETHOD_(HRESULT,GetMultiMediaStream)(THIS_ IMultiMediaStream** ppMultiMediaStream) PURE; \
    STDMETHOD_(HRESULT,GetInformation)(THIS_ MSPID* pPurposeId, STREAM_TYPE* pType) PURE; \
    STDMETHOD_(HRESULT,SetSameFormat)(THIS_ IMediaStream* pStreamThatHasDesiredFormat, DWORD dwFlags) PURE; \
    STDMETHOD_(HRESULT,AllocateSample)(THIS_ DWORD dwFlags, IStreamSample** ppSample) PURE; \
    STDMETHOD_(HRESULT,CreateSharedSample)(THIS_ IStreamSample* pExistingSample, DWORD dwFlags, IStreamSample** ppNewSample) PURE; \
    STDMETHOD_(HRESULT,SendEndOfStream)(THIS_ DWORD dwFlags) PURE;

HRESULT CALLBACK IMediaStream_GetMultiMediaStream_Proxy(
    IMediaStream* This,
    IMultiMediaStream** ppMultiMediaStream);
void __RPC_STUB IMediaStream_GetMultiMediaStream_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMediaStream_GetInformation_Proxy(
    IMediaStream* This,
    MSPID* pPurposeId,
    STREAM_TYPE* pType);
void __RPC_STUB IMediaStream_GetInformation_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMediaStream_SetSameFormat_Proxy(
    IMediaStream* This,
    IMediaStream* pStreamThatHasDesiredFormat,
    DWORD dwFlags);
void __RPC_STUB IMediaStream_SetSameFormat_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMediaStream_AllocateSample_Proxy(
    IMediaStream* This,
    DWORD dwFlags,
    IStreamSample** ppSample);
void __RPC_STUB IMediaStream_AllocateSample_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMediaStream_CreateSharedSample_Proxy(
    IMediaStream* This,
    IStreamSample* pExistingSample,
    DWORD dwFlags,
    IStreamSample** ppNewSample);
void __RPC_STUB IMediaStream_CreateSharedSample_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMediaStream_SendEndOfStream_Proxy(
    IMediaStream* This,
    DWORD dwFlags);
void __RPC_STUB IMediaStream_SendEndOfStream_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IMediaStream_INTERFACE_DEFINED__ */

/*****************************************************************************
 * IStreamSample interface
 */
#ifndef __IStreamSample_INTERFACE_DEFINED__
#define __IStreamSample_INTERFACE_DEFINED__

DEFINE_GUID(IID_IStreamSample, 0xb502d1be, 0x9a57, 0x11d0, 0x8f,0xde, 0x00,0xc0,0x4f,0xd9,0x18,0x9d);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IStreamSample : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE GetMediaStream(
        IMediaStream** ppMediaStream) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetSampleTimes(
        STREAM_TIME* pStartTime,
        STREAM_TIME* pEndTime,
        STREAM_TIME* pCurrentTime) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetSampleTimes(
        const STREAM_TIME* pStartTime,
        const STREAM_TIME* pEndTime) = 0;

    virtual HRESULT STDMETHODCALLTYPE Update(
        DWORD dwFlags,
        HANDLE hEvent,
        PAPCFUNC pfnAPC,
        DWORD dwAPCData) = 0;

    virtual HRESULT STDMETHODCALLTYPE CompletionStatus(
        DWORD dwFlags,
        DWORD dwMilliseconds) = 0;

};
#else
typedef struct IStreamSampleVtbl IStreamSampleVtbl;
struct IStreamSample {
    const IStreamSampleVtbl* lpVtbl;
};
struct IStreamSampleVtbl {
    BEGIN_INTERFACE

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

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

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

    /*** IStreamSample methods ***/
    HRESULT (STDMETHODCALLTYPE *GetMediaStream)(
        IStreamSample* This,
        IMediaStream** ppMediaStream);

    HRESULT (STDMETHODCALLTYPE *GetSampleTimes)(
        IStreamSample* This,
        STREAM_TIME* pStartTime,
        STREAM_TIME* pEndTime,
        STREAM_TIME* pCurrentTime);

    HRESULT (STDMETHODCALLTYPE *SetSampleTimes)(
        IStreamSample* This,
        const STREAM_TIME* pStartTime,
        const STREAM_TIME* pEndTime);

    HRESULT (STDMETHODCALLTYPE *Update)(
        IStreamSample* This,
        DWORD dwFlags,
        HANDLE hEvent,
        PAPCFUNC pfnAPC,
        DWORD dwAPCData);

    HRESULT (STDMETHODCALLTYPE *CompletionStatus)(
        IStreamSample* This,
        DWORD dwFlags,
        DWORD dwMilliseconds);

    END_INTERFACE
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IStreamSample_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IStreamSample_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IStreamSample_Release(p) (p)->lpVtbl->Release(p)
/*** IStreamSample methods ***/
#define IStreamSample_GetMediaStream(p,a) (p)->lpVtbl->GetMediaStream(p,a)
#define IStreamSample_GetSampleTimes(p,a,b,c) (p)->lpVtbl->GetSampleTimes(p,a,b,c)
#define IStreamSample_SetSampleTimes(p,a,b) (p)->lpVtbl->SetSampleTimes(p,a,b)
#define IStreamSample_Update(p,a,b,c,d) (p)->lpVtbl->Update(p,a,b,c,d)
#define IStreamSample_CompletionStatus(p,a,b) (p)->lpVtbl->CompletionStatus(p,a,b)
#endif

#endif

#define IStreamSample_METHODS \
    /*** IUnknown methods ***/ \
    STDMETHOD_(HRESULT,QueryInterface)(THIS_ REFIID riid, void** ppvObject) PURE; \
    STDMETHOD_(ULONG,AddRef)(THIS) PURE; \
    STDMETHOD_(ULONG,Release)(THIS) PURE; \
    /*** IStreamSample methods ***/ \
    STDMETHOD_(HRESULT,GetMediaStream)(THIS_ IMediaStream** ppMediaStream) PURE; \
    STDMETHOD_(HRESULT,GetSampleTimes)(THIS_ STREAM_TIME* pStartTime, STREAM_TIME* pEndTime, STREAM_TIME* pCurrentTime) PURE; \
    STDMETHOD_(HRESULT,SetSampleTimes)(THIS_ const STREAM_TIME* pStartTime, const STREAM_TIME* pEndTime) PURE; \
    STDMETHOD_(HRESULT,Update)(THIS_ DWORD dwFlags, HANDLE hEvent, PAPCFUNC pfnAPC, DWORD dwAPCData) PURE; \
    STDMETHOD_(HRESULT,CompletionStatus)(THIS_ DWORD dwFlags, DWORD dwMilliseconds) PURE;

HRESULT CALLBACK IStreamSample_GetMediaStream_Proxy(
    IStreamSample* This,
    IMediaStream** ppMediaStream);
void __RPC_STUB IStreamSample_GetMediaStream_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IStreamSample_GetSampleTimes_Proxy(
    IStreamSample* This,
    STREAM_TIME* pStartTime,
    STREAM_TIME* pEndTime,
    STREAM_TIME* pCurrentTime);
void __RPC_STUB IStreamSample_GetSampleTimes_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IStreamSample_SetSampleTimes_Proxy(
    IStreamSample* This,
    const STREAM_TIME* pStartTime,
    const STREAM_TIME* pEndTime);
void __RPC_STUB IStreamSample_SetSampleTimes_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IStreamSample_Update_Proxy(
    IStreamSample* This,
    DWORD dwFlags,
    HANDLE hEvent,
    PAPCFUNC pfnAPC,
    DWORD dwAPCData);
void __RPC_STUB IStreamSample_Update_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IStreamSample_CompletionStatus_Proxy(
    IStreamSample* This,
    DWORD dwFlags,
    DWORD dwMilliseconds);
void __RPC_STUB IStreamSample_CompletionStatus_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IStreamSample_INTERFACE_DEFINED__ */

#ifdef __cplusplus
}
#endif
#endif /* __WIDL_MMSTREAM_H */