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

#ifndef __WIDL_AMSTREAM_H
#define __WIDL_AMSTREAM_H
#ifdef __cplusplus
extern "C" {
#endif
#include <unknwn.h>
#include <mmstream.h>
#include <strmif.h>
#include <ddraw.h>
#include <mmsystem.h>
#include <mmstream.h>
#include <ddstream.h>
#include <austream.h>
#if 0
#ifndef __IDirectDraw_FWD_DEFINED__
#define __IDirectDraw_FWD_DEFINED__
typedef struct IDirectDraw IDirectDraw;
#endif

#ifndef __IDirectDrawSurface_FWD_DEFINED__
#define __IDirectDrawSurface_FWD_DEFINED__
typedef struct IDirectDrawSurface IDirectDrawSurface;
#endif

#endif
#ifndef __IAMMultiMediaStream_FWD_DEFINED__
#define __IAMMultiMediaStream_FWD_DEFINED__
typedef struct IAMMultiMediaStream IAMMultiMediaStream;
#endif

#ifndef __IAMMediaStream_FWD_DEFINED__
#define __IAMMediaStream_FWD_DEFINED__
typedef struct IAMMediaStream IAMMediaStream;
#endif

#ifndef __IMediaStreamFilter_FWD_DEFINED__
#define __IMediaStreamFilter_FWD_DEFINED__
typedef struct IMediaStreamFilter IMediaStreamFilter;
#endif

#ifndef __IAMMediaTypeStream_FWD_DEFINED__
#define __IAMMediaTypeStream_FWD_DEFINED__
typedef struct IAMMediaTypeStream IAMMediaTypeStream;
#endif

#ifndef __IAMMediaTypeSample_FWD_DEFINED__
#define __IAMMediaTypeSample_FWD_DEFINED__
typedef struct IAMMediaTypeSample IAMMediaTypeSample;
#endif

enum {
    AMMSF_NOGRAPHTHREAD = 0x1
};

enum {
    AMMSF_ADDDEFAULTRENDERER = 0x1,
    AMMSF_CREATEPEER = 0x2
};

enum {
    AMMSF_RENDERTYPEMASK = 0x3,
    AMMSF_RENDERTOEXISTING = 0x0,
    AMMSF_RENDERALLSTREAMS = 0x1,
    AMMSF_NORENDER = 0x2,
    AMMSF_NOCLOCK = 0x4,
    AMMSF_RUN = 0x8
};

typedef enum {
    Disabled = 0,
    ReadData = 1,
    RenderData = 2
} OUTPUT_STATE;

/*****************************************************************************
 * IAMMultiMediaStream interface
 */
#ifndef __IAMMultiMediaStream_INTERFACE_DEFINED__
#define __IAMMultiMediaStream_INTERFACE_DEFINED__

DEFINE_GUID(IID_IAMMultiMediaStream, 0xbebe595c, 0x9a6f, 0x11d0, 0x8f,0xde, 0x00,0xc0,0x4f,0xd9,0x18,0x9d);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IAMMultiMediaStream : public IMultiMediaStream
{
    virtual HRESULT STDMETHODCALLTYPE Initialize(
        STREAM_TYPE StreamType,
        DWORD dwFlags,
        IGraphBuilder* pFilterGraph) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetFilterGraph(
        IGraphBuilder** ppGraphBuilder) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetFilter(
        IMediaStreamFilter** ppFilter) = 0;

    virtual HRESULT STDMETHODCALLTYPE AddMediaStream(
        IUnknown* pStreamObject,
        const MSPID* PurposeId,
        DWORD dwFlags,
        IMediaStream** ppNewStream) = 0;

    virtual HRESULT STDMETHODCALLTYPE OpenFile(
        LPCWSTR pszFileName,
        DWORD dwFlags) = 0;

    virtual HRESULT STDMETHODCALLTYPE OpenMoniker(
        IBindCtx* pCtx,
        IMoniker* pMoniker,
        DWORD dwFlags) = 0;

    virtual HRESULT STDMETHODCALLTYPE Render(
        DWORD dwFlags) = 0;

};
#else
typedef struct IAMMultiMediaStreamVtbl IAMMultiMediaStreamVtbl;
struct IAMMultiMediaStream {
    const IAMMultiMediaStreamVtbl* lpVtbl;
};
struct IAMMultiMediaStreamVtbl {
    BEGIN_INTERFACE

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

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

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

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

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

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

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

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

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

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

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

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

    /*** IAMMultiMediaStream methods ***/
    HRESULT (STDMETHODCALLTYPE *Initialize)(
        IAMMultiMediaStream* This,
        STREAM_TYPE StreamType,
        DWORD dwFlags,
        IGraphBuilder* pFilterGraph);

    HRESULT (STDMETHODCALLTYPE *GetFilterGraph)(
        IAMMultiMediaStream* This,
        IGraphBuilder** ppGraphBuilder);

    HRESULT (STDMETHODCALLTYPE *GetFilter)(
        IAMMultiMediaStream* This,
        IMediaStreamFilter** ppFilter);

    HRESULT (STDMETHODCALLTYPE *AddMediaStream)(
        IAMMultiMediaStream* This,
        IUnknown* pStreamObject,
        const MSPID* PurposeId,
        DWORD dwFlags,
        IMediaStream** ppNewStream);

    HRESULT (STDMETHODCALLTYPE *OpenFile)(
        IAMMultiMediaStream* This,
        LPCWSTR pszFileName,
        DWORD dwFlags);

    HRESULT (STDMETHODCALLTYPE *OpenMoniker)(
        IAMMultiMediaStream* This,
        IBindCtx* pCtx,
        IMoniker* pMoniker,
        DWORD dwFlags);

    HRESULT (STDMETHODCALLTYPE *Render)(
        IAMMultiMediaStream* This,
        DWORD dwFlags);

    END_INTERFACE
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IAMMultiMediaStream_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IAMMultiMediaStream_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IAMMultiMediaStream_Release(p) (p)->lpVtbl->Release(p)
/*** IMultiMediaStream methods ***/
#define IAMMultiMediaStream_GetInformation(p,a,b) (p)->lpVtbl->GetInformation(p,a,b)
#define IAMMultiMediaStream_GetMediaStream(p,a,b) (p)->lpVtbl->GetMediaStream(p,a,b)
#define IAMMultiMediaStream_EnumMediaStreams(p,a,b) (p)->lpVtbl->EnumMediaStreams(p,a,b)
#define IAMMultiMediaStream_GetState(p,a) (p)->lpVtbl->GetState(p,a)
#define IAMMultiMediaStream_SetState(p,a) (p)->lpVtbl->SetState(p,a)
#define IAMMultiMediaStream_GetTime(p,a) (p)->lpVtbl->GetTime(p,a)
#define IAMMultiMediaStream_GetDuration(p,a) (p)->lpVtbl->GetDuration(p,a)
#define IAMMultiMediaStream_Seek(p,a) (p)->lpVtbl->Seek(p,a)
#define IAMMultiMediaStream_GetEndOfStreamEventHandle(p,a) (p)->lpVtbl->GetEndOfStreamEventHandle(p,a)
/*** IAMMultiMediaStream methods ***/
#define IAMMultiMediaStream_Initialize(p,a,b,c) (p)->lpVtbl->Initialize(p,a,b,c)
#define IAMMultiMediaStream_GetFilterGraph(p,a) (p)->lpVtbl->GetFilterGraph(p,a)
#define IAMMultiMediaStream_GetFilter(p,a) (p)->lpVtbl->GetFilter(p,a)
#define IAMMultiMediaStream_AddMediaStream(p,a,b,c,d) (p)->lpVtbl->AddMediaStream(p,a,b,c,d)
#define IAMMultiMediaStream_OpenFile(p,a,b) (p)->lpVtbl->OpenFile(p,a,b)
#define IAMMultiMediaStream_OpenMoniker(p,a,b,c) (p)->lpVtbl->OpenMoniker(p,a,b,c)
#define IAMMultiMediaStream_Render(p,a) (p)->lpVtbl->Render(p,a)
#endif

#endif

HRESULT CALLBACK IAMMultiMediaStream_Initialize_Proxy(
    IAMMultiMediaStream* This,
    STREAM_TYPE StreamType,
    DWORD dwFlags,
    IGraphBuilder* pFilterGraph);
void __RPC_STUB IAMMultiMediaStream_Initialize_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IAMMultiMediaStream_GetFilterGraph_Proxy(
    IAMMultiMediaStream* This,
    IGraphBuilder** ppGraphBuilder);
void __RPC_STUB IAMMultiMediaStream_GetFilterGraph_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IAMMultiMediaStream_GetFilter_Proxy(
    IAMMultiMediaStream* This,
    IMediaStreamFilter** ppFilter);
void __RPC_STUB IAMMultiMediaStream_GetFilter_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IAMMultiMediaStream_AddMediaStream_Proxy(
    IAMMultiMediaStream* This,
    IUnknown* pStreamObject,
    const MSPID* PurposeId,
    DWORD dwFlags,
    IMediaStream** ppNewStream);
void __RPC_STUB IAMMultiMediaStream_AddMediaStream_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IAMMultiMediaStream_OpenFile_Proxy(
    IAMMultiMediaStream* This,
    LPCWSTR pszFileName,
    DWORD dwFlags);
void __RPC_STUB IAMMultiMediaStream_OpenFile_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IAMMultiMediaStream_OpenMoniker_Proxy(
    IAMMultiMediaStream* This,
    IBindCtx* pCtx,
    IMoniker* pMoniker,
    DWORD dwFlags);
void __RPC_STUB IAMMultiMediaStream_OpenMoniker_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IAMMultiMediaStream_Render_Proxy(
    IAMMultiMediaStream* This,
    DWORD dwFlags);
void __RPC_STUB IAMMultiMediaStream_Render_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IAMMultiMediaStream_INTERFACE_DEFINED__ */

/*****************************************************************************
 * IAMMediaStream interface
 */
#ifndef __IAMMediaStream_INTERFACE_DEFINED__
#define __IAMMediaStream_INTERFACE_DEFINED__

DEFINE_GUID(IID_IAMMediaStream, 0xbebe595d, 0x9a6f, 0x11d0, 0x8f,0xde, 0x00,0xc0,0x4f,0xd9,0x18,0x9d);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IAMMediaStream : public IMediaStream
{
    virtual HRESULT STDMETHODCALLTYPE Initialize(
        IUnknown* pSourceObject,
        DWORD dwFlags,
        REFMSPID PurposeId,
        const STREAM_TYPE StreamType) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetState(
        FILTER_STATE State) = 0;

    virtual HRESULT STDMETHODCALLTYPE JoinAMMultiMediaStream(
        IAMMultiMediaStream* pAMMultiMediaStream) = 0;

    virtual HRESULT STDMETHODCALLTYPE JoinFilter(
        IMediaStreamFilter* pMediaStreamFilter) = 0;

    virtual HRESULT STDMETHODCALLTYPE JoinFilterGraph(
        IFilterGraph* pFilterGraph) = 0;

};
#else
typedef struct IAMMediaStreamVtbl IAMMediaStreamVtbl;
struct IAMMediaStream {
    const IAMMediaStreamVtbl* lpVtbl;
};
struct IAMMediaStreamVtbl {
    BEGIN_INTERFACE

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

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

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

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

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

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

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

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

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

    /*** IAMMediaStream methods ***/
    HRESULT (STDMETHODCALLTYPE *Initialize)(
        IAMMediaStream* This,
        IUnknown* pSourceObject,
        DWORD dwFlags,
        REFMSPID PurposeId,
        const STREAM_TYPE StreamType);

    HRESULT (STDMETHODCALLTYPE *SetState)(
        IAMMediaStream* This,
        FILTER_STATE State);

    HRESULT (STDMETHODCALLTYPE *JoinAMMultiMediaStream)(
        IAMMediaStream* This,
        IAMMultiMediaStream* pAMMultiMediaStream);

    HRESULT (STDMETHODCALLTYPE *JoinFilter)(
        IAMMediaStream* This,
        IMediaStreamFilter* pMediaStreamFilter);

    HRESULT (STDMETHODCALLTYPE *JoinFilterGraph)(
        IAMMediaStream* This,
        IFilterGraph* pFilterGraph);

    END_INTERFACE
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IAMMediaStream_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IAMMediaStream_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IAMMediaStream_Release(p) (p)->lpVtbl->Release(p)
/*** IMediaStream methods ***/
#define IAMMediaStream_GetMultiMediaStream(p,a) (p)->lpVtbl->GetMultiMediaStream(p,a)
#define IAMMediaStream_GetInformation(p,a,b) (p)->lpVtbl->GetInformation(p,a,b)
#define IAMMediaStream_SetSameFormat(p,a,b) (p)->lpVtbl->SetSameFormat(p,a,b)
#define IAMMediaStream_AllocateSample(p,a,b) (p)->lpVtbl->AllocateSample(p,a,b)
#define IAMMediaStream_CreateSharedSample(p,a,b,c) (p)->lpVtbl->CreateSharedSample(p,a,b,c)
#define IAMMediaStream_SendEndOfStream(p,a) (p)->lpVtbl->SendEndOfStream(p,a)
/*** IAMMediaStream methods ***/
#define IAMMediaStream_Initialize(p,a,b,c,d) (p)->lpVtbl->Initialize(p,a,b,c,d)
#define IAMMediaStream_SetState(p,a) (p)->lpVtbl->SetState(p,a)
#define IAMMediaStream_JoinAMMultiMediaStream(p,a) (p)->lpVtbl->JoinAMMultiMediaStream(p,a)
#define IAMMediaStream_JoinFilter(p,a) (p)->lpVtbl->JoinFilter(p,a)
#define IAMMediaStream_JoinFilterGraph(p,a) (p)->lpVtbl->JoinFilterGraph(p,a)
#endif

#endif

HRESULT CALLBACK IAMMediaStream_Initialize_Proxy(
    IAMMediaStream* This,
    IUnknown* pSourceObject,
    DWORD dwFlags,
    REFMSPID PurposeId,
    const STREAM_TYPE StreamType);
void __RPC_STUB IAMMediaStream_Initialize_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IAMMediaStream_SetState_Proxy(
    IAMMediaStream* This,
    FILTER_STATE State);
void __RPC_STUB IAMMediaStream_SetState_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IAMMediaStream_JoinAMMultiMediaStream_Proxy(
    IAMMediaStream* This,
    IAMMultiMediaStream* pAMMultiMediaStream);
void __RPC_STUB IAMMediaStream_JoinAMMultiMediaStream_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IAMMediaStream_JoinFilter_Proxy(
    IAMMediaStream* This,
    IMediaStreamFilter* pMediaStreamFilter);
void __RPC_STUB IAMMediaStream_JoinFilter_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IAMMediaStream_JoinFilterGraph_Proxy(
    IAMMediaStream* This,
    IFilterGraph* pFilterGraph);
void __RPC_STUB IAMMediaStream_JoinFilterGraph_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IAMMediaStream_INTERFACE_DEFINED__ */

/*****************************************************************************
 * IMediaStreamFilter interface
 */
#ifndef __IMediaStreamFilter_INTERFACE_DEFINED__
#define __IMediaStreamFilter_INTERFACE_DEFINED__

DEFINE_GUID(IID_IMediaStreamFilter, 0xbebe595e, 0x9a6f, 0x11d0, 0x8f,0xde, 0x00,0xc0,0x4f,0xd9,0x18,0x9d);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IMediaStreamFilter : public IBaseFilter
{
    virtual HRESULT STDMETHODCALLTYPE AddMediaStream(
        IAMMediaStream* pAMMediaStream) = 0;

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

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

    virtual HRESULT STDMETHODCALLTYPE SupportSeeking(
        BOOL bRenderer) = 0;

    virtual HRESULT STDMETHODCALLTYPE ReferenceTimeToStreamTime(
        REFERENCE_TIME* pTime) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetCurrentStreamTime(
        REFERENCE_TIME* pCurrentStreamTime) = 0;

    virtual HRESULT STDMETHODCALLTYPE WaitUntil(
        REFERENCE_TIME WaitStreamTime) = 0;

    virtual HRESULT STDMETHODCALLTYPE Flush(
        BOOL bCancelEOS) = 0;

    virtual HRESULT STDMETHODCALLTYPE EndOfStream(
        ) = 0;

};
#else
typedef struct IMediaStreamFilterVtbl IMediaStreamFilterVtbl;
struct IMediaStreamFilter {
    const IMediaStreamFilterVtbl* lpVtbl;
};
struct IMediaStreamFilterVtbl {
    BEGIN_INTERFACE

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

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

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

    /*** IPersist methods ***/
    HRESULT (STDMETHODCALLTYPE *GetClassID)(
        IMediaStreamFilter* This,
        CLSID* pClassID);

    /*** IMediaFilter methods ***/
    HRESULT (STDMETHODCALLTYPE *Stop)(
        IMediaStreamFilter* This);

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

    HRESULT (STDMETHODCALLTYPE *Run)(
        IMediaStreamFilter* This,
        REFERENCE_TIME tStart);

    HRESULT (STDMETHODCALLTYPE *GetState)(
        IMediaStreamFilter* This,
        DWORD dwMilliSecsTimeout,
        FILTER_STATE* State);

    HRESULT (STDMETHODCALLTYPE *SetSyncSource)(
        IMediaStreamFilter* This,
        IReferenceClock* pClock);

    HRESULT (STDMETHODCALLTYPE *GetSyncSource)(
        IMediaStreamFilter* This,
        IReferenceClock** pClock);

    /*** IBaseFilter methods ***/
    HRESULT (STDMETHODCALLTYPE *EnumPins)(
        IMediaStreamFilter* This,
        IEnumPins** ppEnum);

    HRESULT (STDMETHODCALLTYPE *FindPin)(
        IMediaStreamFilter* This,
        LPCWSTR Id,
        IPin** ppPin);

    HRESULT (STDMETHODCALLTYPE *QueryFilterInfo)(
        IMediaStreamFilter* This,
        FILTER_INFO* pInfo);

    HRESULT (STDMETHODCALLTYPE *JoinFilterGraph)(
        IMediaStreamFilter* This,
        IFilterGraph* pGraph,
        LPCWSTR pName);

    HRESULT (STDMETHODCALLTYPE *QueryVendorInfo)(
        IMediaStreamFilter* This,
        LPWSTR* pVendorInfo);

    /*** IMediaStreamFilter methods ***/
    HRESULT (STDMETHODCALLTYPE *AddMediaStream)(
        IMediaStreamFilter* This,
        IAMMediaStream* pAMMediaStream);

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

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

    HRESULT (STDMETHODCALLTYPE *SupportSeeking)(
        IMediaStreamFilter* This,
        BOOL bRenderer);

    HRESULT (STDMETHODCALLTYPE *ReferenceTimeToStreamTime)(
        IMediaStreamFilter* This,
        REFERENCE_TIME* pTime);

    HRESULT (STDMETHODCALLTYPE *GetCurrentStreamTime)(
        IMediaStreamFilter* This,
        REFERENCE_TIME* pCurrentStreamTime);

    HRESULT (STDMETHODCALLTYPE *WaitUntil)(
        IMediaStreamFilter* This,
        REFERENCE_TIME WaitStreamTime);

    HRESULT (STDMETHODCALLTYPE *Flush)(
        IMediaStreamFilter* This,
        BOOL bCancelEOS);

    HRESULT (STDMETHODCALLTYPE *EndOfStream)(
        IMediaStreamFilter* This);

    END_INTERFACE
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IMediaStreamFilter_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IMediaStreamFilter_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IMediaStreamFilter_Release(p) (p)->lpVtbl->Release(p)
/*** IPersist methods ***/
#define IMediaStreamFilter_GetClassID(p,a) (p)->lpVtbl->GetClassID(p,a)
/*** IMediaFilter methods ***/
#define IMediaStreamFilter_Stop(p) (p)->lpVtbl->Stop(p)
#define IMediaStreamFilter_Pause(p) (p)->lpVtbl->Pause(p)
#define IMediaStreamFilter_Run(p,a) (p)->lpVtbl->Run(p,a)
#define IMediaStreamFilter_GetState(p,a,b) (p)->lpVtbl->GetState(p,a,b)
#define IMediaStreamFilter_SetSyncSource(p,a) (p)->lpVtbl->SetSyncSource(p,a)
#define IMediaStreamFilter_GetSyncSource(p,a) (p)->lpVtbl->GetSyncSource(p,a)
/*** IBaseFilter methods ***/
#define IMediaStreamFilter_EnumPins(p,a) (p)->lpVtbl->EnumPins(p,a)
#define IMediaStreamFilter_FindPin(p,a,b) (p)->lpVtbl->FindPin(p,a,b)
#define IMediaStreamFilter_QueryFilterInfo(p,a) (p)->lpVtbl->QueryFilterInfo(p,a)
#define IMediaStreamFilter_JoinFilterGraph(p,a,b) (p)->lpVtbl->JoinFilterGraph(p,a,b)
#define IMediaStreamFilter_QueryVendorInfo(p,a) (p)->lpVtbl->QueryVendorInfo(p,a)
/*** IMediaStreamFilter methods ***/
#define IMediaStreamFilter_AddMediaStream(p,a) (p)->lpVtbl->AddMediaStream(p,a)
#define IMediaStreamFilter_GetMediaStream(p,a,b) (p)->lpVtbl->GetMediaStream(p,a,b)
#define IMediaStreamFilter_EnumMediaStreams(p,a,b) (p)->lpVtbl->EnumMediaStreams(p,a,b)
#define IMediaStreamFilter_SupportSeeking(p,a) (p)->lpVtbl->SupportSeeking(p,a)
#define IMediaStreamFilter_ReferenceTimeToStreamTime(p,a) (p)->lpVtbl->ReferenceTimeToStreamTime(p,a)
#define IMediaStreamFilter_GetCurrentStreamTime(p,a) (p)->lpVtbl->GetCurrentStreamTime(p,a)
#define IMediaStreamFilter_WaitUntil(p,a) (p)->lpVtbl->WaitUntil(p,a)
#define IMediaStreamFilter_Flush(p,a) (p)->lpVtbl->Flush(p,a)
#define IMediaStreamFilter_EndOfStream(p) (p)->lpVtbl->EndOfStream(p)
#endif

#endif

HRESULT CALLBACK IMediaStreamFilter_AddMediaStream_Proxy(
    IMediaStreamFilter* This,
    IAMMediaStream* pAMMediaStream);
void __RPC_STUB IMediaStreamFilter_AddMediaStream_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMediaStreamFilter_GetMediaStream_Proxy(
    IMediaStreamFilter* This,
    REFMSPID idPurpose,
    IMediaStream** ppMediaStream);
void __RPC_STUB IMediaStreamFilter_GetMediaStream_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMediaStreamFilter_EnumMediaStreams_Proxy(
    IMediaStreamFilter* This,
    long Index,
    IMediaStream** ppMediaStream);
void __RPC_STUB IMediaStreamFilter_EnumMediaStreams_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMediaStreamFilter_SupportSeeking_Proxy(
    IMediaStreamFilter* This,
    BOOL bRenderer);
void __RPC_STUB IMediaStreamFilter_SupportSeeking_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMediaStreamFilter_ReferenceTimeToStreamTime_Proxy(
    IMediaStreamFilter* This,
    REFERENCE_TIME* pTime);
void __RPC_STUB IMediaStreamFilter_ReferenceTimeToStreamTime_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMediaStreamFilter_GetCurrentStreamTime_Proxy(
    IMediaStreamFilter* This,
    REFERENCE_TIME* pCurrentStreamTime);
void __RPC_STUB IMediaStreamFilter_GetCurrentStreamTime_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMediaStreamFilter_WaitUntil_Proxy(
    IMediaStreamFilter* This,
    REFERENCE_TIME WaitStreamTime);
void __RPC_STUB IMediaStreamFilter_WaitUntil_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMediaStreamFilter_Flush_Proxy(
    IMediaStreamFilter* This,
    BOOL bCancelEOS);
void __RPC_STUB IMediaStreamFilter_Flush_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMediaStreamFilter_EndOfStream_Proxy(
    IMediaStreamFilter* This);
void __RPC_STUB IMediaStreamFilter_EndOfStream_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IMediaStreamFilter_INTERFACE_DEFINED__ */

#ifndef __IDirectDrawMediaSampleAllocator_FWD_DEFINED__
#define __IDirectDrawMediaSampleAllocator_FWD_DEFINED__
typedef struct IDirectDrawMediaSampleAllocator IDirectDrawMediaSampleAllocator;
#endif

/*****************************************************************************
 * IDirectDrawMediaSampleAllocator interface
 */
#ifndef __IDirectDrawMediaSampleAllocator_INTERFACE_DEFINED__
#define __IDirectDrawMediaSampleAllocator_INTERFACE_DEFINED__

DEFINE_GUID(IID_IDirectDrawMediaSampleAllocator, 0xab6b4afc, 0xf6e4, 0x11d0, 0x90,0x0d, 0x00,0xc0,0x4f,0xd9,0x18,0x9d);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IDirectDrawMediaSampleAllocator : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE GetDirectDraw(
        IDirectDraw** ppDirectDraw) = 0;

};
#else
typedef struct IDirectDrawMediaSampleAllocatorVtbl IDirectDrawMediaSampleAllocatorVtbl;
struct IDirectDrawMediaSampleAllocator {
    const IDirectDrawMediaSampleAllocatorVtbl* lpVtbl;
};
struct IDirectDrawMediaSampleAllocatorVtbl {
    BEGIN_INTERFACE

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

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

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

    /*** IDirectDrawMediaSampleAllocator methods ***/
    HRESULT (STDMETHODCALLTYPE *GetDirectDraw)(
        IDirectDrawMediaSampleAllocator* This,
        IDirectDraw** ppDirectDraw);

    END_INTERFACE
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IDirectDrawMediaSampleAllocator_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IDirectDrawMediaSampleAllocator_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IDirectDrawMediaSampleAllocator_Release(p) (p)->lpVtbl->Release(p)
/*** IDirectDrawMediaSampleAllocator methods ***/
#define IDirectDrawMediaSampleAllocator_GetDirectDraw(p,a) (p)->lpVtbl->GetDirectDraw(p,a)
#endif

#endif

HRESULT CALLBACK IDirectDrawMediaSampleAllocator_GetDirectDraw_Proxy(
    IDirectDrawMediaSampleAllocator* This,
    IDirectDraw** ppDirectDraw);
void __RPC_STUB IDirectDrawMediaSampleAllocator_GetDirectDraw_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IDirectDrawMediaSampleAllocator_INTERFACE_DEFINED__ */

#ifndef __IDirectDrawMediaSample_FWD_DEFINED__
#define __IDirectDrawMediaSample_FWD_DEFINED__
typedef struct IDirectDrawMediaSample IDirectDrawMediaSample;
#endif

/*****************************************************************************
 * IDirectDrawMediaSample interface
 */
#ifndef __IDirectDrawMediaSample_INTERFACE_DEFINED__
#define __IDirectDrawMediaSample_INTERFACE_DEFINED__

DEFINE_GUID(IID_IDirectDrawMediaSample, 0xab6b4afe, 0xf6e4, 0x11d0, 0x90,0x0d, 0x00,0xc0,0x4f,0xd9,0x18,0x9d);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IDirectDrawMediaSample : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE GetSurfaceAndReleaseLock(
        IDirectDrawSurface** ppDirectDrawSurface,
        RECT* pRect) = 0;

    virtual HRESULT STDMETHODCALLTYPE LockMediaSamplePointer(
        ) = 0;

};
#else
typedef struct IDirectDrawMediaSampleVtbl IDirectDrawMediaSampleVtbl;
struct IDirectDrawMediaSample {
    const IDirectDrawMediaSampleVtbl* lpVtbl;
};
struct IDirectDrawMediaSampleVtbl {
    BEGIN_INTERFACE

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

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

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

    /*** IDirectDrawMediaSample methods ***/
    HRESULT (STDMETHODCALLTYPE *GetSurfaceAndReleaseLock)(
        IDirectDrawMediaSample* This,
        IDirectDrawSurface** ppDirectDrawSurface,
        RECT* pRect);

    HRESULT (STDMETHODCALLTYPE *LockMediaSamplePointer)(
        IDirectDrawMediaSample* This);

    END_INTERFACE
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IDirectDrawMediaSample_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IDirectDrawMediaSample_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IDirectDrawMediaSample_Release(p) (p)->lpVtbl->Release(p)
/*** IDirectDrawMediaSample methods ***/
#define IDirectDrawMediaSample_GetSurfaceAndReleaseLock(p,a,b) (p)->lpVtbl->GetSurfaceAndReleaseLock(p,a,b)
#define IDirectDrawMediaSample_LockMediaSamplePointer(p) (p)->lpVtbl->LockMediaSamplePointer(p)
#endif

#endif

HRESULT CALLBACK IDirectDrawMediaSample_GetSurfaceAndReleaseLock_Proxy(
    IDirectDrawMediaSample* This,
    IDirectDrawSurface** ppDirectDrawSurface,
    RECT* pRect);
void __RPC_STUB IDirectDrawMediaSample_GetSurfaceAndReleaseLock_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IDirectDrawMediaSample_LockMediaSamplePointer_Proxy(
    IDirectDrawMediaSample* This);
void __RPC_STUB IDirectDrawMediaSample_LockMediaSamplePointer_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IDirectDrawMediaSample_INTERFACE_DEFINED__ */

/*****************************************************************************
 * IAMMediaTypeStream interface
 */
#ifndef __IAMMediaTypeStream_INTERFACE_DEFINED__
#define __IAMMediaTypeStream_INTERFACE_DEFINED__

DEFINE_GUID(IID_IAMMediaTypeStream, 0xab6b4afa, 0xf6e4, 0x11d0, 0x90,0x0d, 0x00,0xc0,0x4f,0xd9,0x18,0x9d);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IAMMediaTypeStream : public IMediaStream
{
    virtual HRESULT STDMETHODCALLTYPE GetFormat(
        AM_MEDIA_TYPE* pMediaType,
        DWORD dwFlags) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetFormat(
        AM_MEDIA_TYPE* pMediaType,
        DWORD dwFlags) = 0;

    virtual HRESULT STDMETHODCALLTYPE CreateSample(
        long lSampleSize,
        BYTE* pbBuffer,
        DWORD dwFlags,
        IUnknown* pUnkOuter,
        IAMMediaTypeSample** ppAMMediaTypeSample) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetStreamAllocatorRequirements(
        ALLOCATOR_PROPERTIES* pProps) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetStreamAllocatorRequirements(
        ALLOCATOR_PROPERTIES* pProps) = 0;

};
#else
typedef struct IAMMediaTypeStreamVtbl IAMMediaTypeStreamVtbl;
struct IAMMediaTypeStream {
    const IAMMediaTypeStreamVtbl* lpVtbl;
};
struct IAMMediaTypeStreamVtbl {
    BEGIN_INTERFACE

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

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

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

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

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

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

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

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

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

    /*** IAMMediaTypeStream methods ***/
    HRESULT (STDMETHODCALLTYPE *GetFormat)(
        IAMMediaTypeStream* This,
        AM_MEDIA_TYPE* pMediaType,
        DWORD dwFlags);

    HRESULT (STDMETHODCALLTYPE *SetFormat)(
        IAMMediaTypeStream* This,
        AM_MEDIA_TYPE* pMediaType,
        DWORD dwFlags);

    HRESULT (STDMETHODCALLTYPE *CreateSample)(
        IAMMediaTypeStream* This,
        long lSampleSize,
        BYTE* pbBuffer,
        DWORD dwFlags,
        IUnknown* pUnkOuter,
        IAMMediaTypeSample** ppAMMediaTypeSample);

    HRESULT (STDMETHODCALLTYPE *GetStreamAllocatorRequirements)(
        IAMMediaTypeStream* This,
        ALLOCATOR_PROPERTIES* pProps);

    HRESULT (STDMETHODCALLTYPE *SetStreamAllocatorRequirements)(
        IAMMediaTypeStream* This,
        ALLOCATOR_PROPERTIES* pProps);

    END_INTERFACE
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IAMMediaTypeStream_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IAMMediaTypeStream_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IAMMediaTypeStream_Release(p) (p)->lpVtbl->Release(p)
/*** IMediaStream methods ***/
#define IAMMediaTypeStream_GetMultiMediaStream(p,a) (p)->lpVtbl->GetMultiMediaStream(p,a)
#define IAMMediaTypeStream_GetInformation(p,a,b) (p)->lpVtbl->GetInformation(p,a,b)
#define IAMMediaTypeStream_SetSameFormat(p,a,b) (p)->lpVtbl->SetSameFormat(p,a,b)
#define IAMMediaTypeStream_AllocateSample(p,a,b) (p)->lpVtbl->AllocateSample(p,a,b)
#define IAMMediaTypeStream_CreateSharedSample(p,a,b,c) (p)->lpVtbl->CreateSharedSample(p,a,b,c)
#define IAMMediaTypeStream_SendEndOfStream(p,a) (p)->lpVtbl->SendEndOfStream(p,a)
/*** IAMMediaTypeStream methods ***/
#define IAMMediaTypeStream_GetFormat(p,a,b) (p)->lpVtbl->GetFormat(p,a,b)
#define IAMMediaTypeStream_SetFormat(p,a,b) (p)->lpVtbl->SetFormat(p,a,b)
#define IAMMediaTypeStream_CreateSample(p,a,b,c,d,e) (p)->lpVtbl->CreateSample(p,a,b,c,d,e)
#define IAMMediaTypeStream_GetStreamAllocatorRequirements(p,a) (p)->lpVtbl->GetStreamAllocatorRequirements(p,a)
#define IAMMediaTypeStream_SetStreamAllocatorRequirements(p,a) (p)->lpVtbl->SetStreamAllocatorRequirements(p,a)
#endif

#endif

HRESULT CALLBACK IAMMediaTypeStream_GetFormat_Proxy(
    IAMMediaTypeStream* This,
    AM_MEDIA_TYPE* pMediaType,
    DWORD dwFlags);
void __RPC_STUB IAMMediaTypeStream_GetFormat_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IAMMediaTypeStream_SetFormat_Proxy(
    IAMMediaTypeStream* This,
    AM_MEDIA_TYPE* pMediaType,
    DWORD dwFlags);
void __RPC_STUB IAMMediaTypeStream_SetFormat_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IAMMediaTypeStream_CreateSample_Proxy(
    IAMMediaTypeStream* This,
    long lSampleSize,
    BYTE* pbBuffer,
    DWORD dwFlags,
    IUnknown* pUnkOuter,
    IAMMediaTypeSample** ppAMMediaTypeSample);
void __RPC_STUB IAMMediaTypeStream_CreateSample_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IAMMediaTypeStream_GetStreamAllocatorRequirements_Proxy(
    IAMMediaTypeStream* This,
    ALLOCATOR_PROPERTIES* pProps);
void __RPC_STUB IAMMediaTypeStream_GetStreamAllocatorRequirements_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IAMMediaTypeStream_SetStreamAllocatorRequirements_Proxy(
    IAMMediaTypeStream* This,
    ALLOCATOR_PROPERTIES* pProps);
void __RPC_STUB IAMMediaTypeStream_SetStreamAllocatorRequirements_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IAMMediaTypeStream_INTERFACE_DEFINED__ */

/*****************************************************************************
 * IAMMediaTypeSample interface
 */
#ifndef __IAMMediaTypeSample_INTERFACE_DEFINED__
#define __IAMMediaTypeSample_INTERFACE_DEFINED__

DEFINE_GUID(IID_IAMMediaTypeSample, 0xab6b4afb, 0xf6e4, 0x11d0, 0x90,0x0d, 0x00,0xc0,0x4f,0xd9,0x18,0x9d);
#if defined(__cplusplus) && !defined(CINTERFACE)
struct IAMMediaTypeSample : public IStreamSample
{
    virtual HRESULT STDMETHODCALLTYPE SetPointer(
        BYTE* pBuffer,
        long lSize) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetPointer(
        BYTE** ppBuffer) = 0;

    virtual long STDMETHODCALLTYPE GetSize(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetTime(
        REFERENCE_TIME* pTimeStart,
        REFERENCE_TIME* pTimeEnd) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetTime(
        REFERENCE_TIME* pTimeStart,
        REFERENCE_TIME* pTimeEnd) = 0;

    virtual HRESULT STDMETHODCALLTYPE IsSyncPoint(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetSyncPoint(
        BOOL bIsSyncPoint) = 0;

    virtual HRESULT STDMETHODCALLTYPE IsPreroll(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetPreroll(
        BOOL bIsPreroll) = 0;

    virtual long STDMETHODCALLTYPE GetActualDataLength(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetActualDataLength(
        long Len) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetMediaType(
        AM_MEDIA_TYPE** ppMediaType) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetMediaType(
        AM_MEDIA_TYPE* pMediaType) = 0;

    virtual HRESULT STDMETHODCALLTYPE IsDiscontinuity(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetDiscontinuity(
        BOOL bDiscontinuity) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetMediaTime(
        LONGLONG* pTimeStart,
        LONGLONG* pTimeEnd) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetMediaTime(
        LONGLONG* pTimeStart,
        LONGLONG* pTimeEnd) = 0;

};
#else
typedef struct IAMMediaTypeSampleVtbl IAMMediaTypeSampleVtbl;
struct IAMMediaTypeSample {
    const IAMMediaTypeSampleVtbl* lpVtbl;
};
struct IAMMediaTypeSampleVtbl {
    BEGIN_INTERFACE

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

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

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

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

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

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

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

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

    /*** IAMMediaTypeSample methods ***/
    HRESULT (STDMETHODCALLTYPE *SetPointer)(
        IAMMediaTypeSample* This,
        BYTE* pBuffer,
        long lSize);

    HRESULT (STDMETHODCALLTYPE *GetPointer)(
        IAMMediaTypeSample* This,
        BYTE** ppBuffer);

    long (STDMETHODCALLTYPE *GetSize)(
        IAMMediaTypeSample* This);

    HRESULT (STDMETHODCALLTYPE *GetTime)(
        IAMMediaTypeSample* This,
        REFERENCE_TIME* pTimeStart,
        REFERENCE_TIME* pTimeEnd);

    HRESULT (STDMETHODCALLTYPE *SetTime)(
        IAMMediaTypeSample* This,
        REFERENCE_TIME* pTimeStart,
        REFERENCE_TIME* pTimeEnd);

    HRESULT (STDMETHODCALLTYPE *IsSyncPoint)(
        IAMMediaTypeSample* This);

    HRESULT (STDMETHODCALLTYPE *SetSyncPoint)(
        IAMMediaTypeSample* This,
        BOOL bIsSyncPoint);

    HRESULT (STDMETHODCALLTYPE *IsPreroll)(
        IAMMediaTypeSample* This);

    HRESULT (STDMETHODCALLTYPE *SetPreroll)(
        IAMMediaTypeSample* This,
        BOOL bIsPreroll);

    long (STDMETHODCALLTYPE *GetActualDataLength)(
        IAMMediaTypeSample* This);

    HRESULT (STDMETHODCALLTYPE *SetActualDataLength)(
        IAMMediaTypeSample* This,
        long Len);

    HRESULT (STDMETHODCALLTYPE *GetMediaType)(
        IAMMediaTypeSample* This,
        AM_MEDIA_TYPE** ppMediaType);

    HRESULT (STDMETHODCALLTYPE *SetMediaType)(
        IAMMediaTypeSample* This,
        AM_MEDIA_TYPE* pMediaType);

    HRESULT (STDMETHODCALLTYPE *IsDiscontinuity)(
        IAMMediaTypeSample* This);

    HRESULT (STDMETHODCALLTYPE *SetDiscontinuity)(
        IAMMediaTypeSample* This,
        BOOL bDiscontinuity);

    HRESULT (STDMETHODCALLTYPE *GetMediaTime)(
        IAMMediaTypeSample* This,
        LONGLONG* pTimeStart,
        LONGLONG* pTimeEnd);

    HRESULT (STDMETHODCALLTYPE *SetMediaTime)(
        IAMMediaTypeSample* This,
        LONGLONG* pTimeStart,
        LONGLONG* pTimeEnd);

    END_INTERFACE
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IAMMediaTypeSample_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IAMMediaTypeSample_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IAMMediaTypeSample_Release(p) (p)->lpVtbl->Release(p)
/*** IStreamSample methods ***/
#define IAMMediaTypeSample_GetMediaStream(p,a) (p)->lpVtbl->GetMediaStream(p,a)
#define IAMMediaTypeSample_GetSampleTimes(p,a,b,c) (p)->lpVtbl->GetSampleTimes(p,a,b,c)
#define IAMMediaTypeSample_SetSampleTimes(p,a,b) (p)->lpVtbl->SetSampleTimes(p,a,b)
#define IAMMediaTypeSample_Update(p,a,b,c,d) (p)->lpVtbl->Update(p,a,b,c,d)
#define IAMMediaTypeSample_CompletionStatus(p,a,b) (p)->lpVtbl->CompletionStatus(p,a,b)
/*** IAMMediaTypeSample methods ***/
#define IAMMediaTypeSample_SetPointer(p,a,b) (p)->lpVtbl->SetPointer(p,a,b)
#define IAMMediaTypeSample_GetPointer(p,a) (p)->lpVtbl->GetPointer(p,a)
#define IAMMediaTypeSample_GetSize(p) (p)->lpVtbl->GetSize(p)
#define IAMMediaTypeSample_GetTime(p,a,b) (p)->lpVtbl->GetTime(p,a,b)
#define IAMMediaTypeSample_SetTime(p,a,b) (p)->lpVtbl->SetTime(p,a,b)
#define IAMMediaTypeSample_IsSyncPoint(p) (p)->lpVtbl->IsSyncPoint(p)
#define IAMMediaTypeSample_SetSyncPoint(p,a) (p)->lpVtbl->SetSyncPoint(p,a)
#define IAMMediaTypeSample_IsPreroll(p) (p)->lpVtbl->IsPreroll(p)
#define IAMMediaTypeSample_SetPreroll(p,a) (p)->lpVtbl->SetPreroll(p,a)
#define IAMMediaTypeSample_GetActualDataLength(p) (p)->lpVtbl->GetActualDataLength(p)
#define IAMMediaTypeSample_SetActualDataLength(p,a) (p)->lpVtbl->SetActualDataLength(p,a)
#define IAMMediaTypeSample_GetMediaType(p,a) (p)->lpVtbl->GetMediaType(p,a)
#define IAMMediaTypeSample_SetMediaType(p,a) (p)->lpVtbl->SetMediaType(p,a)
#define IAMMediaTypeSample_IsDiscontinuity(p) (p)->lpVtbl->IsDiscontinuity(p)
#define IAMMediaTypeSample_SetDiscontinuity(p,a) (p)->lpVtbl->SetDiscontinuity(p,a)
#define IAMMediaTypeSample_GetMediaTime(p,a,b) (p)->lpVtbl->GetMediaTime(p,a,b)
#define IAMMediaTypeSample_SetMediaTime(p,a,b) (p)->lpVtbl->SetMediaTime(p,a,b)
#endif

#endif

HRESULT CALLBACK IAMMediaTypeSample_SetPointer_Proxy(
    IAMMediaTypeSample* This,
    BYTE* pBuffer,
    long lSize);
void __RPC_STUB IAMMediaTypeSample_SetPointer_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IAMMediaTypeSample_GetPointer_Proxy(
    IAMMediaTypeSample* This,
    BYTE** ppBuffer);
void __RPC_STUB IAMMediaTypeSample_GetPointer_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
long CALLBACK IAMMediaTypeSample_GetSize_Proxy(
    IAMMediaTypeSample* This);
void __RPC_STUB IAMMediaTypeSample_GetSize_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IAMMediaTypeSample_GetTime_Proxy(
    IAMMediaTypeSample* This,
    REFERENCE_TIME* pTimeStart,
    REFERENCE_TIME* pTimeEnd);
void __RPC_STUB IAMMediaTypeSample_GetTime_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IAMMediaTypeSample_SetTime_Proxy(
    IAMMediaTypeSample* This,
    REFERENCE_TIME* pTimeStart,
    REFERENCE_TIME* pTimeEnd);
void __RPC_STUB IAMMediaTypeSample_SetTime_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IAMMediaTypeSample_IsSyncPoint_Proxy(
    IAMMediaTypeSample* This);
void __RPC_STUB IAMMediaTypeSample_IsSyncPoint_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IAMMediaTypeSample_SetSyncPoint_Proxy(
    IAMMediaTypeSample* This,
    BOOL bIsSyncPoint);
void __RPC_STUB IAMMediaTypeSample_SetSyncPoint_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IAMMediaTypeSample_IsPreroll_Proxy(
    IAMMediaTypeSample* This);
void __RPC_STUB IAMMediaTypeSample_IsPreroll_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IAMMediaTypeSample_SetPreroll_Proxy(
    IAMMediaTypeSample* This,
    BOOL bIsPreroll);
void __RPC_STUB IAMMediaTypeSample_SetPreroll_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
long CALLBACK IAMMediaTypeSample_GetActualDataLength_Proxy(
    IAMMediaTypeSample* This);
void __RPC_STUB IAMMediaTypeSample_GetActualDataLength_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IAMMediaTypeSample_SetActualDataLength_Proxy(
    IAMMediaTypeSample* This,
    long Len);
void __RPC_STUB IAMMediaTypeSample_SetActualDataLength_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IAMMediaTypeSample_GetMediaType_Proxy(
    IAMMediaTypeSample* This,
    AM_MEDIA_TYPE** ppMediaType);
void __RPC_STUB IAMMediaTypeSample_GetMediaType_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IAMMediaTypeSample_SetMediaType_Proxy(
    IAMMediaTypeSample* This,
    AM_MEDIA_TYPE* pMediaType);
void __RPC_STUB IAMMediaTypeSample_SetMediaType_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IAMMediaTypeSample_IsDiscontinuity_Proxy(
    IAMMediaTypeSample* This);
void __RPC_STUB IAMMediaTypeSample_IsDiscontinuity_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IAMMediaTypeSample_SetDiscontinuity_Proxy(
    IAMMediaTypeSample* This,
    BOOL bDiscontinuity);
void __RPC_STUB IAMMediaTypeSample_SetDiscontinuity_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IAMMediaTypeSample_GetMediaTime_Proxy(
    IAMMediaTypeSample* This,
    LONGLONG* pTimeStart,
    LONGLONG* pTimeEnd);
void __RPC_STUB IAMMediaTypeSample_GetMediaTime_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IAMMediaTypeSample_SetMediaTime_Proxy(
    IAMMediaTypeSample* This,
    LONGLONG* pTimeStart,
    LONGLONG* pTimeEnd);
void __RPC_STUB IAMMediaTypeSample_SetMediaTime_Stub(
    struct IRpcStubBuffer* This,
    struct IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IAMMediaTypeSample_INTERFACE_DEFINED__ */

DEFINE_GUID(CLSID_AMMultiMediaStream,  0x49c47ce5, 0x9ba4, 0x11d0, 0x82, 0x12, 0x00, 0xc0, 0x4f, 0xc3, 0x2c, 0x45);
DEFINE_GUID(CLSID_AMDirectDrawStream,  0x49c47ce4, 0x9ba4, 0x11d0, 0x82, 0x12, 0x00, 0xc0, 0x4f, 0xc3, 0x2c, 0x45);
DEFINE_GUID(CLSID_AMAudioStream,       0x8496e040, 0xaf4c, 0x11d0, 0x82, 0x12, 0x00, 0xc0, 0x4f, 0xc3, 0x2c, 0x45);
DEFINE_GUID(CLSID_AMAudioData,         0xf2468580, 0xaf8a, 0x11d0, 0x82, 0x12, 0x00, 0xc0, 0x4f, 0xc3, 0x2c, 0x45);
DEFINE_GUID(CLSID_AMMediaTypeStream,   0xcf0f2f7c, 0xf7bf, 0x11d0, 0x90, 0x0d, 0x00, 0xc0, 0x4f, 0xd9, 0x18, 0x9d);
#ifdef __cplusplus
}
#endif
#endif /* __WIDL_AMSTREAM_H */
