/*** Autogenerated by WIDL 1.6 from direct-x/include/dmodshow.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 __dmodshow_h__
#define __dmodshow_h__

/* Forward declarations */

#ifndef __IDMOWrapperFilter_FWD_DEFINED__
#define __IDMOWrapperFilter_FWD_DEFINED__
typedef interface IDMOWrapperFilter IDMOWrapperFilter;
#endif

/* Headers for imported files */

#include <unknwn.h>

#ifdef __cplusplus
extern "C" {
#endif

DEFINE_GUID(CLSID_DMOWrapperFilter,  0x94297043, 0xbd82, 0x4dfd, 0xb0, 0xde, 0x81, 0x77, 0x73, 0x9c, 0x6d, 0x20);
/*****************************************************************************
 * IDMOWrapperFilter interface
 */
#ifndef __IDMOWrapperFilter_INTERFACE_DEFINED__
#define __IDMOWrapperFilter_INTERFACE_DEFINED__

DEFINE_GUID(IID_IDMOWrapperFilter, 0x52d6f586, 0x9f0f, 0x4824, 0x8f,0xc8, 0xe3,0x2c,0xa0,0x49,0x30,0xc2);
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("52d6f586-9f0f-4824-8fc8-e32ca04930c2")
IDMOWrapperFilter : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE Init(
        REFCLSID clsidDMO,
        REFCLSID catDMO) = 0;

};
#ifdef __CRT_UUID_DECL
__CRT_UUID_DECL(IDMOWrapperFilter, 0x52d6f586, 0x9f0f, 0x4824, 0x8f,0xc8, 0xe3,0x2c,0xa0,0x49,0x30,0xc2)
#endif
#else
typedef struct IDMOWrapperFilterVtbl {
    BEGIN_INTERFACE

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

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

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

    /*** IDMOWrapperFilter methods ***/
    HRESULT (STDMETHODCALLTYPE *Init)(
        IDMOWrapperFilter* This,
        REFCLSID clsidDMO,
        REFCLSID catDMO);

    END_INTERFACE
} IDMOWrapperFilterVtbl;
interface IDMOWrapperFilter {
    CONST_VTBL IDMOWrapperFilterVtbl* lpVtbl;
};

#ifdef COBJMACROS
#ifndef WIDL_C_INLINE_WRAPPERS
/*** IUnknown methods ***/
#define IDMOWrapperFilter_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
#define IDMOWrapperFilter_AddRef(This) (This)->lpVtbl->AddRef(This)
#define IDMOWrapperFilter_Release(This) (This)->lpVtbl->Release(This)
/*** IDMOWrapperFilter methods ***/
#define IDMOWrapperFilter_Init(This,clsidDMO,catDMO) (This)->lpVtbl->Init(This,clsidDMO,catDMO)
#else
/*** IUnknown methods ***/
static FORCEINLINE HRESULT IDMOWrapperFilter_QueryInterface(IDMOWrapperFilter* This,REFIID riid,void **ppvObject) {
    return This->lpVtbl->QueryInterface(This,riid,ppvObject);
}
static FORCEINLINE ULONG IDMOWrapperFilter_AddRef(IDMOWrapperFilter* This) {
    return This->lpVtbl->AddRef(This);
}
static FORCEINLINE ULONG IDMOWrapperFilter_Release(IDMOWrapperFilter* This) {
    return This->lpVtbl->Release(This);
}
/*** IDMOWrapperFilter methods ***/
static FORCEINLINE HRESULT IDMOWrapperFilter_Init(IDMOWrapperFilter* This,REFCLSID clsidDMO,REFCLSID catDMO) {
    return This->lpVtbl->Init(This,clsidDMO,catDMO);
}
#endif
#endif

#endif

HRESULT STDMETHODCALLTYPE IDMOWrapperFilter_Init_Proxy(
    IDMOWrapperFilter* This,
    REFCLSID clsidDMO,
    REFCLSID catDMO);
void __RPC_STUB IDMOWrapperFilter_Init_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IDMOWrapperFilter_INTERFACE_DEFINED__ */

/* Begin additional prototypes for all interfaces */


/* End additional prototypes */

#ifdef __cplusplus
}
#endif

#endif /* __dmodshow_h__ */
