/*** Autogenerated by WIDL 11.0 from /home/runner/.termux-build/wine-stable/src/include/mfplay.idl - Do not edit ***/

#ifdef _WIN32
#ifndef __REQUIRED_RPCNDR_H_VERSION__
#define __REQUIRED_RPCNDR_H_VERSION__ 475
#endif
#include <rpc.h>
#include <rpcndr.h>
#endif

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

#ifndef __mfplay_h__
#define __mfplay_h__

/* Forward declarations */

#ifndef __IMFPMediaPlayerCallback_FWD_DEFINED__
#define __IMFPMediaPlayerCallback_FWD_DEFINED__
typedef interface IMFPMediaPlayerCallback IMFPMediaPlayerCallback;
#ifdef __cplusplus
interface IMFPMediaPlayerCallback;
#endif /* __cplusplus */
#endif

#ifndef __IMFPMediaPlayer_FWD_DEFINED__
#define __IMFPMediaPlayer_FWD_DEFINED__
typedef interface IMFPMediaPlayer IMFPMediaPlayer;
#ifdef __cplusplus
interface IMFPMediaPlayer;
#endif /* __cplusplus */
#endif

#ifndef __IMFPMediaItem_FWD_DEFINED__
#define __IMFPMediaItem_FWD_DEFINED__
typedef interface IMFPMediaItem IMFPMediaItem;
#ifdef __cplusplus
interface IMFPMediaItem;
#endif /* __cplusplus */
#endif

/* Headers for imported files */

#include <unknwn.h>
#include <propsys.h>
#include <evr.h>

#ifdef __cplusplus
extern "C" {
#endif

#ifndef __IMFNetCredential_FWD_DEFINED__
#define __IMFNetCredential_FWD_DEFINED__
typedef interface IMFNetCredential IMFNetCredential;
#ifdef __cplusplus
interface IMFNetCredential;
#endif /* __cplusplus */
#endif

typedef UINT32 MFP_CREATION_OPTIONS;
typedef enum _MFP_CREATION_OPTIONS {
    MFP_OPTION_NONE = 0,
    MFP_OPTION_FREE_THREADED_CALLBACK = 0x1,
    MFP_OPTION_NO_MMCSS = 0x2,
    MFP_OPTION_NO_REMOTE_DESKTOP_OPTIMIZATION = 0x4
} _MFP_CREATION_OPTIONS;
typedef enum MFP_MEDIAPLAYER_STATE {
    MFP_MEDIAPLAYER_STATE_EMPTY = 0,
    MFP_MEDIAPLAYER_STATE_STOPPED = 1,
    MFP_MEDIAPLAYER_STATE_PLAYING = 2,
    MFP_MEDIAPLAYER_STATE_PAUSED = 3,
    MFP_MEDIAPLAYER_STATE_SHUTDOWN = 4
} MFP_MEDIAPLAYER_STATE;
typedef enum MFP_EVENT_TYPE {
    MFP_EVENT_TYPE_PLAY = 0,
    MFP_EVENT_TYPE_PAUSE = 1,
    MFP_EVENT_TYPE_STOP = 2,
    MFP_EVENT_TYPE_POSITION_SET = 3,
    MFP_EVENT_TYPE_RATE_SET = 4,
    MFP_EVENT_TYPE_MEDIAITEM_CREATED = 5,
    MFP_EVENT_TYPE_MEDIAITEM_SET = 6,
    MFP_EVENT_TYPE_FRAME_STEP = 7,
    MFP_EVENT_TYPE_MEDIAITEM_CLEARED = 8,
    MFP_EVENT_TYPE_MF = 9,
    MFP_EVENT_TYPE_ERROR = 10,
    MFP_EVENT_TYPE_PLAYBACK_ENDED = 11,
    MFP_EVENT_TYPE_ACQUIRE_USER_CREDENTIAL = 12
} MFP_EVENT_TYPE;
typedef UINT32 MFP_MEDIAITEM_CHARACTERISTICS;
typedef enum _MFP_MEDIAITEM_CHARACTERISTICS {
    MFP_MEDIAITEM_IS_LIVE = 0x1,
    MFP_MEDIAITEM_CAN_SEEK = 0x2,
    MFP_MEDIAITEM_CAN_PAUSE = 0x4,
    MFP_MEDIAITEM_HAS_SLOW_SEEK = 0x8
} _MFP_MEDIAITEM_CHARACTERISTICS;
typedef UINT32 MFP_CREDENTIAL_FLAGS;
typedef enum _MFP_CREDENTIAL_FLAGS {
    MFP_CREDENTIAL_PROMPT = 0x1,
    MFP_CREDENTIAL_SAVE = 0x2,
    MFP_CREDENTIAL_DO_NOT_CACHE = 0x4,
    MFP_CREDENTIAL_CLEAR_TEXT = 0x8,
    MFP_CREDENTIAL_PROXY = 0x10,
    MFP_CREDENTIAL_LOGGED_ON_USER = 0x20
} _MFP_CREDENTIAL_FLAGS;
#ifndef __IMFPMediaPlayer_FWD_DEFINED__
#define __IMFPMediaPlayer_FWD_DEFINED__
typedef interface IMFPMediaPlayer IMFPMediaPlayer;
#ifdef __cplusplus
interface IMFPMediaPlayer;
#endif /* __cplusplus */
#endif

#ifndef __IMFPMediaItem_FWD_DEFINED__
#define __IMFPMediaItem_FWD_DEFINED__
typedef interface IMFPMediaItem IMFPMediaItem;
#ifdef __cplusplus
interface IMFPMediaItem;
#endif /* __cplusplus */
#endif

typedef struct MFP_EVENT_HEADER {
    MFP_EVENT_TYPE eEventType;
    HRESULT hrEvent;
    IMFPMediaPlayer *pMediaPlayer;
    MFP_MEDIAPLAYER_STATE eState;
    IPropertyStore *pPropertyStore;
} MFP_EVENT_HEADER;
typedef struct MFP_PLAY_EVENT {
    MFP_EVENT_HEADER header;
    IMFPMediaItem *pMediaItem;
} MFP_PLAY_EVENT;
typedef struct MFP_PAUSE_EVENT {
    MFP_EVENT_HEADER header;
    IMFPMediaItem *pMediaItem;
} MFP_PAUSE_EVENT;
typedef struct MFP_STOP_EVENT {
    MFP_EVENT_HEADER header;
    IMFPMediaItem *pMediaItem;
} MFP_STOP_EVENT;
typedef struct MFP_POSITION_SET_EVENT {
    MFP_EVENT_HEADER header;
    IMFPMediaItem *pMediaItem;
} MFP_POSITION_SET_EVENT;
typedef struct MFP_RATE_SET_EVENT {
    MFP_EVENT_HEADER header;
    IMFPMediaItem *pMediaItem;
    float flRate;
} MFP_RATE_SET_EVENT;
typedef struct MFP_MEDIAITEM_CREATED_EVENT {
    MFP_EVENT_HEADER header;
    IMFPMediaItem *pMediaItem;
    DWORD_PTR dwUserData;
} MFP_MEDIAITEM_CREATED_EVENT;
typedef struct MFP_MEDIAITEM_SET_EVENT {
    MFP_EVENT_HEADER header;
    IMFPMediaItem *pMediaItem;
} MFP_MEDIAITEM_SET_EVENT;
typedef struct MFP_FRAME_STEP_EVENT {
    MFP_EVENT_HEADER header;
    IMFPMediaItem *pMediaItem;
} MFP_FRAME_STEP_EVENT;
typedef struct MFP_MEDIAITEM_CLEARED_EVENT {
    MFP_EVENT_HEADER header;
    IMFPMediaItem *pMediaItem;
} MFP_MEDIAITEM_CLEARED_EVENT;
typedef struct MFP_MF_EVENT {
    MFP_EVENT_HEADER header;
    MediaEventType MFEventType;
    IMFMediaEvent *pMFMediaEvent;
    IMFPMediaItem *pMediaItem;
} MFP_MF_EVENT;
typedef struct MFP_ERROR_EVENT {
    MFP_EVENT_HEADER header;
} MFP_ERROR_EVENT;
typedef struct MFP_PLAYBACK_ENDED_EVENT {
    MFP_EVENT_HEADER header;
    IMFPMediaItem *pMediaItem;
} MFP_PLAYBACK_ENDED_EVENT;
typedef struct MFP_ACQUIRE_USER_CREDENTIAL_EVENT {
    MFP_EVENT_HEADER header;
    DWORD_PTR dwUserData;
    BOOL fProceedWithAuthentication;
    HRESULT hrAuthenticationStatus;
    LPCWSTR pwszURL;
    LPCWSTR pwszSite;
    LPCWSTR pwszRealm;
    LPCWSTR pwszPackage;
    LONG nRetries;
    MFP_CREDENTIAL_FLAGS flags;
    IMFNetCredential *pCredential;
} MFP_ACQUIRE_USER_CREDENTIAL_EVENT;
#define __MFP_CAST_EVENT(hdr, tag)                 (((hdr)->eEventType == MFP_EVENT_TYPE_##tag) ? (MFP_##Tag##_EVENT *)(hdr) : NULL)
#define MFP_GET_PLAY_EVENT(hdr)                    __MFP_CAST_EVENT(hdr, PLAY)
#define MFP_GET_PAUSE_EVENT(hdr)                   __MFP_CAST_EVENT(hdr, PAUSE)
#define MFP_GET_STOP_EVENT(hdr)                    __MFP_CAST_EVENT(hdr, STOP)
#define MFP_GET_POSITION_SET_EVENT(hdr)            __MFP_CAST_EVENT(hdr, POSITION_SET)
#define MFP_GET_RATE_SET_EVENT(hdr)                __MFP_CAST_EVENT(hdr, RATE_SET)
#define MFP_GET_MEDIAITEM_CREATED_EVENT(hdr)       __MFP_CAST_EVENT(hdr, MEDIAITEM_CREATED)
#define MFP_GET_MEDIAITEM_SET_EVENT(hdr)           __MFP_CAST_EVENT(hdr, MEDIAITEM_SET)
#define MFP_GET_FRAME_STEP_EVENT(hdr)              __MFP_CAST_EVENT(hdr, FRAME_STEP)
#define MFP_GET_MEDIAITEM_CLEARED_EVENT(hdr)       __MFP_CAST_EVENT(hdr, MEDIAITEM_CLEARED)
#define MFP_GET_MF_EVENT(hdr)                      __MFP_CAST_EVENT(hdr, MF)
#define MFP_GET_ERROR_EVENT(hdr)                   __MFP_CAST_EVENT(hdr, ERROR)
#define MFP_GET_PLAYBACK_ENDED_EVENT(hdr)          __MFP_CAST_EVENT(hdr, PLAYBACK_ENDED)
#define MFP_GET_ACQUIRE_USER_CREDENTIAL_EVENT(hdr) __MFP_CAST_EVENT(hdr, ACQUIRE_USER_CREDENTIAL)
EXTERN_GUID(MFP_POSITIONTYPE_100NS, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0);
/*****************************************************************************
 * IMFPMediaPlayerCallback interface
 */
#ifndef __IMFPMediaPlayerCallback_INTERFACE_DEFINED__
#define __IMFPMediaPlayerCallback_INTERFACE_DEFINED__

DEFINE_GUID(IID_IMFPMediaPlayerCallback, 0x766c8ffb, 0x5fdb, 0x4fea, 0xa2,0x8d, 0xb9,0x12,0x99,0x6f,0x51,0xbd);
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("766c8ffb-5fdb-4fea-a28d-b912996f51bd")
IMFPMediaPlayerCallback : public IUnknown
{
    virtual void STDMETHODCALLTYPE OnMediaPlayerEvent(
        MFP_EVENT_HEADER *event_header) = 0;

};
#ifdef __CRT_UUID_DECL
__CRT_UUID_DECL(IMFPMediaPlayerCallback, 0x766c8ffb, 0x5fdb, 0x4fea, 0xa2,0x8d, 0xb9,0x12,0x99,0x6f,0x51,0xbd)
#endif
#else
typedef struct IMFPMediaPlayerCallbackVtbl {
    BEGIN_INTERFACE

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

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

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

    /*** IMFPMediaPlayerCallback methods ***/
    void (STDMETHODCALLTYPE *OnMediaPlayerEvent)(
        IMFPMediaPlayerCallback *This,
        MFP_EVENT_HEADER *event_header);

    END_INTERFACE
} IMFPMediaPlayerCallbackVtbl;

interface IMFPMediaPlayerCallback {
    CONST_VTBL IMFPMediaPlayerCallbackVtbl* lpVtbl;
};

#ifdef COBJMACROS
#ifndef WIDL_C_INLINE_WRAPPERS
/*** IUnknown methods ***/
#define IMFPMediaPlayerCallback_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
#define IMFPMediaPlayerCallback_AddRef(This) (This)->lpVtbl->AddRef(This)
#define IMFPMediaPlayerCallback_Release(This) (This)->lpVtbl->Release(This)
/*** IMFPMediaPlayerCallback methods ***/
#define IMFPMediaPlayerCallback_OnMediaPlayerEvent(This,event_header) (This)->lpVtbl->OnMediaPlayerEvent(This,event_header)
#else
/*** IUnknown methods ***/
static inline HRESULT IMFPMediaPlayerCallback_QueryInterface(IMFPMediaPlayerCallback* This,REFIID riid,void **ppvObject) {
    return This->lpVtbl->QueryInterface(This,riid,ppvObject);
}
static inline ULONG IMFPMediaPlayerCallback_AddRef(IMFPMediaPlayerCallback* This) {
    return This->lpVtbl->AddRef(This);
}
static inline ULONG IMFPMediaPlayerCallback_Release(IMFPMediaPlayerCallback* This) {
    return This->lpVtbl->Release(This);
}
/*** IMFPMediaPlayerCallback methods ***/
static inline void IMFPMediaPlayerCallback_OnMediaPlayerEvent(IMFPMediaPlayerCallback* This,MFP_EVENT_HEADER *event_header) {
    This->lpVtbl->OnMediaPlayerEvent(This,event_header);
}
#endif
#endif

#endif


#endif  /* __IMFPMediaPlayerCallback_INTERFACE_DEFINED__ */

/*****************************************************************************
 * IMFPMediaPlayer interface
 */
#ifndef __IMFPMediaPlayer_INTERFACE_DEFINED__
#define __IMFPMediaPlayer_INTERFACE_DEFINED__

DEFINE_GUID(IID_IMFPMediaPlayer, 0xa714590a, 0x58af, 0x430a, 0x85,0xbf, 0x44,0xf5,0xec,0x83,0x8d,0x85);
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("a714590a-58af-430a-85bf-44f5ec838d85")
IMFPMediaPlayer : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE Play(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE Pause(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE Stop(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE FrameStep(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetPosition(
        REFGUID position_type,
        const PROPVARIANT *position) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetPosition(
        REFGUID position_type,
        PROPVARIANT *position) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetDuration(
        REFGUID position_type,
        PROPVARIANT *duration) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetRate(
        float rate) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetRate(
        float *rate) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetSupportedRates(
        BOOL forward,
        float *slowest_rate,
        float *fastest_rate) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetState(
        MFP_MEDIAPLAYER_STATE *state) = 0;

    virtual HRESULT STDMETHODCALLTYPE CreateMediaItemFromURL(
        const WCHAR *url,
        BOOL sync,
        DWORD_PTR user_data,
        IMFPMediaItem **item) = 0;

    virtual HRESULT STDMETHODCALLTYPE CreateMediaItemFromObject(
        IUnknown *object,
        BOOL sync,
        DWORD_PTR user_data,
        IMFPMediaItem **item) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetMediaItem(
        IMFPMediaItem *item) = 0;

    virtual HRESULT STDMETHODCALLTYPE ClearMediaItem(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetMediaItem(
        IMFPMediaItem **item) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetVolume(
        float *volume) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetVolume(
        float volume) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetBalance(
        float *balance) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetBalance(
        float balance) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetMute(
        BOOL *mute) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetMute(
        BOOL mute) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetNativeVideoSize(
        SIZE *video,
        SIZE *arvideo) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetIdealVideoSize(
        SIZE *min_size,
        SIZE *max_size) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetVideoSourceRect(
        const MFVideoNormalizedRect *rect) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetVideoSourceRect(
        MFVideoNormalizedRect *rect) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetAspectRatioMode(
        DWORD mode) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetAspectRatioMode(
        DWORD *mode) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetVideoWindow(
        HWND *hwnd) = 0;

    virtual HRESULT STDMETHODCALLTYPE UpdateVideo(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetBorderColor(
        COLORREF color) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetBorderColor(
        COLORREF *color) = 0;

    virtual HRESULT STDMETHODCALLTYPE InsertEffect(
        IUnknown *effect,
        BOOL optional) = 0;

    virtual HRESULT STDMETHODCALLTYPE RemoveEffect(
        IUnknown *effect) = 0;

    virtual HRESULT STDMETHODCALLTYPE RemoveAllEffects(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE Shutdown(
        ) = 0;

};
#ifdef __CRT_UUID_DECL
__CRT_UUID_DECL(IMFPMediaPlayer, 0xa714590a, 0x58af, 0x430a, 0x85,0xbf, 0x44,0xf5,0xec,0x83,0x8d,0x85)
#endif
#else
typedef struct IMFPMediaPlayerVtbl {
    BEGIN_INTERFACE

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

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

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

    /*** IMFPMediaPlayer methods ***/
    HRESULT (STDMETHODCALLTYPE *Play)(
        IMFPMediaPlayer *This);

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

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

    HRESULT (STDMETHODCALLTYPE *FrameStep)(
        IMFPMediaPlayer *This);

    HRESULT (STDMETHODCALLTYPE *SetPosition)(
        IMFPMediaPlayer *This,
        REFGUID position_type,
        const PROPVARIANT *position);

    HRESULT (STDMETHODCALLTYPE *GetPosition)(
        IMFPMediaPlayer *This,
        REFGUID position_type,
        PROPVARIANT *position);

    HRESULT (STDMETHODCALLTYPE *GetDuration)(
        IMFPMediaPlayer *This,
        REFGUID position_type,
        PROPVARIANT *duration);

    HRESULT (STDMETHODCALLTYPE *SetRate)(
        IMFPMediaPlayer *This,
        float rate);

    HRESULT (STDMETHODCALLTYPE *GetRate)(
        IMFPMediaPlayer *This,
        float *rate);

    HRESULT (STDMETHODCALLTYPE *GetSupportedRates)(
        IMFPMediaPlayer *This,
        BOOL forward,
        float *slowest_rate,
        float *fastest_rate);

    HRESULT (STDMETHODCALLTYPE *GetState)(
        IMFPMediaPlayer *This,
        MFP_MEDIAPLAYER_STATE *state);

    HRESULT (STDMETHODCALLTYPE *CreateMediaItemFromURL)(
        IMFPMediaPlayer *This,
        const WCHAR *url,
        BOOL sync,
        DWORD_PTR user_data,
        IMFPMediaItem **item);

    HRESULT (STDMETHODCALLTYPE *CreateMediaItemFromObject)(
        IMFPMediaPlayer *This,
        IUnknown *object,
        BOOL sync,
        DWORD_PTR user_data,
        IMFPMediaItem **item);

    HRESULT (STDMETHODCALLTYPE *SetMediaItem)(
        IMFPMediaPlayer *This,
        IMFPMediaItem *item);

    HRESULT (STDMETHODCALLTYPE *ClearMediaItem)(
        IMFPMediaPlayer *This);

    HRESULT (STDMETHODCALLTYPE *GetMediaItem)(
        IMFPMediaPlayer *This,
        IMFPMediaItem **item);

    HRESULT (STDMETHODCALLTYPE *GetVolume)(
        IMFPMediaPlayer *This,
        float *volume);

    HRESULT (STDMETHODCALLTYPE *SetVolume)(
        IMFPMediaPlayer *This,
        float volume);

    HRESULT (STDMETHODCALLTYPE *GetBalance)(
        IMFPMediaPlayer *This,
        float *balance);

    HRESULT (STDMETHODCALLTYPE *SetBalance)(
        IMFPMediaPlayer *This,
        float balance);

    HRESULT (STDMETHODCALLTYPE *GetMute)(
        IMFPMediaPlayer *This,
        BOOL *mute);

    HRESULT (STDMETHODCALLTYPE *SetMute)(
        IMFPMediaPlayer *This,
        BOOL mute);

    HRESULT (STDMETHODCALLTYPE *GetNativeVideoSize)(
        IMFPMediaPlayer *This,
        SIZE *video,
        SIZE *arvideo);

    HRESULT (STDMETHODCALLTYPE *GetIdealVideoSize)(
        IMFPMediaPlayer *This,
        SIZE *min_size,
        SIZE *max_size);

    HRESULT (STDMETHODCALLTYPE *SetVideoSourceRect)(
        IMFPMediaPlayer *This,
        const MFVideoNormalizedRect *rect);

    HRESULT (STDMETHODCALLTYPE *GetVideoSourceRect)(
        IMFPMediaPlayer *This,
        MFVideoNormalizedRect *rect);

    HRESULT (STDMETHODCALLTYPE *SetAspectRatioMode)(
        IMFPMediaPlayer *This,
        DWORD mode);

    HRESULT (STDMETHODCALLTYPE *GetAspectRatioMode)(
        IMFPMediaPlayer *This,
        DWORD *mode);

    HRESULT (STDMETHODCALLTYPE *GetVideoWindow)(
        IMFPMediaPlayer *This,
        HWND *hwnd);

    HRESULT (STDMETHODCALLTYPE *UpdateVideo)(
        IMFPMediaPlayer *This);

    HRESULT (STDMETHODCALLTYPE *SetBorderColor)(
        IMFPMediaPlayer *This,
        COLORREF color);

    HRESULT (STDMETHODCALLTYPE *GetBorderColor)(
        IMFPMediaPlayer *This,
        COLORREF *color);

    HRESULT (STDMETHODCALLTYPE *InsertEffect)(
        IMFPMediaPlayer *This,
        IUnknown *effect,
        BOOL optional);

    HRESULT (STDMETHODCALLTYPE *RemoveEffect)(
        IMFPMediaPlayer *This,
        IUnknown *effect);

    HRESULT (STDMETHODCALLTYPE *RemoveAllEffects)(
        IMFPMediaPlayer *This);

    HRESULT (STDMETHODCALLTYPE *Shutdown)(
        IMFPMediaPlayer *This);

    END_INTERFACE
} IMFPMediaPlayerVtbl;

interface IMFPMediaPlayer {
    CONST_VTBL IMFPMediaPlayerVtbl* lpVtbl;
};

#ifdef COBJMACROS
#ifndef WIDL_C_INLINE_WRAPPERS
/*** IUnknown methods ***/
#define IMFPMediaPlayer_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
#define IMFPMediaPlayer_AddRef(This) (This)->lpVtbl->AddRef(This)
#define IMFPMediaPlayer_Release(This) (This)->lpVtbl->Release(This)
/*** IMFPMediaPlayer methods ***/
#define IMFPMediaPlayer_Play(This) (This)->lpVtbl->Play(This)
#define IMFPMediaPlayer_Pause(This) (This)->lpVtbl->Pause(This)
#define IMFPMediaPlayer_Stop(This) (This)->lpVtbl->Stop(This)
#define IMFPMediaPlayer_FrameStep(This) (This)->lpVtbl->FrameStep(This)
#define IMFPMediaPlayer_SetPosition(This,position_type,position) (This)->lpVtbl->SetPosition(This,position_type,position)
#define IMFPMediaPlayer_GetPosition(This,position_type,position) (This)->lpVtbl->GetPosition(This,position_type,position)
#define IMFPMediaPlayer_GetDuration(This,position_type,duration) (This)->lpVtbl->GetDuration(This,position_type,duration)
#define IMFPMediaPlayer_SetRate(This,rate) (This)->lpVtbl->SetRate(This,rate)
#define IMFPMediaPlayer_GetRate(This,rate) (This)->lpVtbl->GetRate(This,rate)
#define IMFPMediaPlayer_GetSupportedRates(This,forward,slowest_rate,fastest_rate) (This)->lpVtbl->GetSupportedRates(This,forward,slowest_rate,fastest_rate)
#define IMFPMediaPlayer_GetState(This,state) (This)->lpVtbl->GetState(This,state)
#define IMFPMediaPlayer_CreateMediaItemFromURL(This,url,sync,user_data,item) (This)->lpVtbl->CreateMediaItemFromURL(This,url,sync,user_data,item)
#define IMFPMediaPlayer_CreateMediaItemFromObject(This,object,sync,user_data,item) (This)->lpVtbl->CreateMediaItemFromObject(This,object,sync,user_data,item)
#define IMFPMediaPlayer_SetMediaItem(This,item) (This)->lpVtbl->SetMediaItem(This,item)
#define IMFPMediaPlayer_ClearMediaItem(This) (This)->lpVtbl->ClearMediaItem(This)
#define IMFPMediaPlayer_GetMediaItem(This,item) (This)->lpVtbl->GetMediaItem(This,item)
#define IMFPMediaPlayer_GetVolume(This,volume) (This)->lpVtbl->GetVolume(This,volume)
#define IMFPMediaPlayer_SetVolume(This,volume) (This)->lpVtbl->SetVolume(This,volume)
#define IMFPMediaPlayer_GetBalance(This,balance) (This)->lpVtbl->GetBalance(This,balance)
#define IMFPMediaPlayer_SetBalance(This,balance) (This)->lpVtbl->SetBalance(This,balance)
#define IMFPMediaPlayer_GetMute(This,mute) (This)->lpVtbl->GetMute(This,mute)
#define IMFPMediaPlayer_SetMute(This,mute) (This)->lpVtbl->SetMute(This,mute)
#define IMFPMediaPlayer_GetNativeVideoSize(This,video,arvideo) (This)->lpVtbl->GetNativeVideoSize(This,video,arvideo)
#define IMFPMediaPlayer_GetIdealVideoSize(This,min_size,max_size) (This)->lpVtbl->GetIdealVideoSize(This,min_size,max_size)
#define IMFPMediaPlayer_SetVideoSourceRect(This,rect) (This)->lpVtbl->SetVideoSourceRect(This,rect)
#define IMFPMediaPlayer_GetVideoSourceRect(This,rect) (This)->lpVtbl->GetVideoSourceRect(This,rect)
#define IMFPMediaPlayer_SetAspectRatioMode(This,mode) (This)->lpVtbl->SetAspectRatioMode(This,mode)
#define IMFPMediaPlayer_GetAspectRatioMode(This,mode) (This)->lpVtbl->GetAspectRatioMode(This,mode)
#define IMFPMediaPlayer_GetVideoWindow(This,hwnd) (This)->lpVtbl->GetVideoWindow(This,hwnd)
#define IMFPMediaPlayer_UpdateVideo(This) (This)->lpVtbl->UpdateVideo(This)
#define IMFPMediaPlayer_SetBorderColor(This,color) (This)->lpVtbl->SetBorderColor(This,color)
#define IMFPMediaPlayer_GetBorderColor(This,color) (This)->lpVtbl->GetBorderColor(This,color)
#define IMFPMediaPlayer_InsertEffect(This,effect,optional) (This)->lpVtbl->InsertEffect(This,effect,optional)
#define IMFPMediaPlayer_RemoveEffect(This,effect) (This)->lpVtbl->RemoveEffect(This,effect)
#define IMFPMediaPlayer_RemoveAllEffects(This) (This)->lpVtbl->RemoveAllEffects(This)
#define IMFPMediaPlayer_Shutdown(This) (This)->lpVtbl->Shutdown(This)
#else
/*** IUnknown methods ***/
static inline HRESULT IMFPMediaPlayer_QueryInterface(IMFPMediaPlayer* This,REFIID riid,void **ppvObject) {
    return This->lpVtbl->QueryInterface(This,riid,ppvObject);
}
static inline ULONG IMFPMediaPlayer_AddRef(IMFPMediaPlayer* This) {
    return This->lpVtbl->AddRef(This);
}
static inline ULONG IMFPMediaPlayer_Release(IMFPMediaPlayer* This) {
    return This->lpVtbl->Release(This);
}
/*** IMFPMediaPlayer methods ***/
static inline HRESULT IMFPMediaPlayer_Play(IMFPMediaPlayer* This) {
    return This->lpVtbl->Play(This);
}
static inline HRESULT IMFPMediaPlayer_Pause(IMFPMediaPlayer* This) {
    return This->lpVtbl->Pause(This);
}
static inline HRESULT IMFPMediaPlayer_Stop(IMFPMediaPlayer* This) {
    return This->lpVtbl->Stop(This);
}
static inline HRESULT IMFPMediaPlayer_FrameStep(IMFPMediaPlayer* This) {
    return This->lpVtbl->FrameStep(This);
}
static inline HRESULT IMFPMediaPlayer_SetPosition(IMFPMediaPlayer* This,REFGUID position_type,const PROPVARIANT *position) {
    return This->lpVtbl->SetPosition(This,position_type,position);
}
static inline HRESULT IMFPMediaPlayer_GetPosition(IMFPMediaPlayer* This,REFGUID position_type,PROPVARIANT *position) {
    return This->lpVtbl->GetPosition(This,position_type,position);
}
static inline HRESULT IMFPMediaPlayer_GetDuration(IMFPMediaPlayer* This,REFGUID position_type,PROPVARIANT *duration) {
    return This->lpVtbl->GetDuration(This,position_type,duration);
}
static inline HRESULT IMFPMediaPlayer_SetRate(IMFPMediaPlayer* This,float rate) {
    return This->lpVtbl->SetRate(This,rate);
}
static inline HRESULT IMFPMediaPlayer_GetRate(IMFPMediaPlayer* This,float *rate) {
    return This->lpVtbl->GetRate(This,rate);
}
static inline HRESULT IMFPMediaPlayer_GetSupportedRates(IMFPMediaPlayer* This,BOOL forward,float *slowest_rate,float *fastest_rate) {
    return This->lpVtbl->GetSupportedRates(This,forward,slowest_rate,fastest_rate);
}
static inline HRESULT IMFPMediaPlayer_GetState(IMFPMediaPlayer* This,MFP_MEDIAPLAYER_STATE *state) {
    return This->lpVtbl->GetState(This,state);
}
static inline HRESULT IMFPMediaPlayer_CreateMediaItemFromURL(IMFPMediaPlayer* This,const WCHAR *url,BOOL sync,DWORD_PTR user_data,IMFPMediaItem **item) {
    return This->lpVtbl->CreateMediaItemFromURL(This,url,sync,user_data,item);
}
static inline HRESULT IMFPMediaPlayer_CreateMediaItemFromObject(IMFPMediaPlayer* This,IUnknown *object,BOOL sync,DWORD_PTR user_data,IMFPMediaItem **item) {
    return This->lpVtbl->CreateMediaItemFromObject(This,object,sync,user_data,item);
}
static inline HRESULT IMFPMediaPlayer_SetMediaItem(IMFPMediaPlayer* This,IMFPMediaItem *item) {
    return This->lpVtbl->SetMediaItem(This,item);
}
static inline HRESULT IMFPMediaPlayer_ClearMediaItem(IMFPMediaPlayer* This) {
    return This->lpVtbl->ClearMediaItem(This);
}
static inline HRESULT IMFPMediaPlayer_GetMediaItem(IMFPMediaPlayer* This,IMFPMediaItem **item) {
    return This->lpVtbl->GetMediaItem(This,item);
}
static inline HRESULT IMFPMediaPlayer_GetVolume(IMFPMediaPlayer* This,float *volume) {
    return This->lpVtbl->GetVolume(This,volume);
}
static inline HRESULT IMFPMediaPlayer_SetVolume(IMFPMediaPlayer* This,float volume) {
    return This->lpVtbl->SetVolume(This,volume);
}
static inline HRESULT IMFPMediaPlayer_GetBalance(IMFPMediaPlayer* This,float *balance) {
    return This->lpVtbl->GetBalance(This,balance);
}
static inline HRESULT IMFPMediaPlayer_SetBalance(IMFPMediaPlayer* This,float balance) {
    return This->lpVtbl->SetBalance(This,balance);
}
static inline HRESULT IMFPMediaPlayer_GetMute(IMFPMediaPlayer* This,BOOL *mute) {
    return This->lpVtbl->GetMute(This,mute);
}
static inline HRESULT IMFPMediaPlayer_SetMute(IMFPMediaPlayer* This,BOOL mute) {
    return This->lpVtbl->SetMute(This,mute);
}
static inline HRESULT IMFPMediaPlayer_GetNativeVideoSize(IMFPMediaPlayer* This,SIZE *video,SIZE *arvideo) {
    return This->lpVtbl->GetNativeVideoSize(This,video,arvideo);
}
static inline HRESULT IMFPMediaPlayer_GetIdealVideoSize(IMFPMediaPlayer* This,SIZE *min_size,SIZE *max_size) {
    return This->lpVtbl->GetIdealVideoSize(This,min_size,max_size);
}
static inline HRESULT IMFPMediaPlayer_SetVideoSourceRect(IMFPMediaPlayer* This,const MFVideoNormalizedRect *rect) {
    return This->lpVtbl->SetVideoSourceRect(This,rect);
}
static inline HRESULT IMFPMediaPlayer_GetVideoSourceRect(IMFPMediaPlayer* This,MFVideoNormalizedRect *rect) {
    return This->lpVtbl->GetVideoSourceRect(This,rect);
}
static inline HRESULT IMFPMediaPlayer_SetAspectRatioMode(IMFPMediaPlayer* This,DWORD mode) {
    return This->lpVtbl->SetAspectRatioMode(This,mode);
}
static inline HRESULT IMFPMediaPlayer_GetAspectRatioMode(IMFPMediaPlayer* This,DWORD *mode) {
    return This->lpVtbl->GetAspectRatioMode(This,mode);
}
static inline HRESULT IMFPMediaPlayer_GetVideoWindow(IMFPMediaPlayer* This,HWND *hwnd) {
    return This->lpVtbl->GetVideoWindow(This,hwnd);
}
static inline HRESULT IMFPMediaPlayer_UpdateVideo(IMFPMediaPlayer* This) {
    return This->lpVtbl->UpdateVideo(This);
}
static inline HRESULT IMFPMediaPlayer_SetBorderColor(IMFPMediaPlayer* This,COLORREF color) {
    return This->lpVtbl->SetBorderColor(This,color);
}
static inline HRESULT IMFPMediaPlayer_GetBorderColor(IMFPMediaPlayer* This,COLORREF *color) {
    return This->lpVtbl->GetBorderColor(This,color);
}
static inline HRESULT IMFPMediaPlayer_InsertEffect(IMFPMediaPlayer* This,IUnknown *effect,BOOL optional) {
    return This->lpVtbl->InsertEffect(This,effect,optional);
}
static inline HRESULT IMFPMediaPlayer_RemoveEffect(IMFPMediaPlayer* This,IUnknown *effect) {
    return This->lpVtbl->RemoveEffect(This,effect);
}
static inline HRESULT IMFPMediaPlayer_RemoveAllEffects(IMFPMediaPlayer* This) {
    return This->lpVtbl->RemoveAllEffects(This);
}
static inline HRESULT IMFPMediaPlayer_Shutdown(IMFPMediaPlayer* This) {
    return This->lpVtbl->Shutdown(This);
}
#endif
#endif

#endif


#endif  /* __IMFPMediaPlayer_INTERFACE_DEFINED__ */

/*****************************************************************************
 * IMFPMediaItem interface
 */
#ifndef __IMFPMediaItem_INTERFACE_DEFINED__
#define __IMFPMediaItem_INTERFACE_DEFINED__

DEFINE_GUID(IID_IMFPMediaItem, 0x90eb3e6b, 0xecbf, 0x45cc, 0xb1,0xda, 0xc6,0xfe,0x3e,0xa7,0x0d,0x57);
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("90eb3e6b-ecbf-45cc-b1da-c6fe3ea70d57")
IMFPMediaItem : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE GetMediaPlayer(
        IMFPMediaPlayer **player) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetURL(
        LPWSTR *url) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetObject(
        IUnknown **obj) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetUserData(
        DWORD_PTR *user_data) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetUserData(
        DWORD_PTR user_data) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetStartStopPosition(
        GUID *start_format,
        PROPVARIANT *start_position,
        GUID *stop_format,
        PROPVARIANT *stop_position) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetStartStopPosition(
        const GUID *start_format,
        const PROPVARIANT *start_position,
        const GUID *stop_format,
        const PROPVARIANT *stop_position) = 0;

    virtual HRESULT STDMETHODCALLTYPE HasVideo(
        BOOL *has_video,
        BOOL *selected) = 0;

    virtual HRESULT STDMETHODCALLTYPE HasAudio(
        BOOL *has_audio,
        BOOL *selected) = 0;

    virtual HRESULT STDMETHODCALLTYPE IsProtected(
        BOOL *protected) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetDuration(
        REFGUID format,
        PROPVARIANT *value) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetNumberOfStreams(
        DWORD *count) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetStreamSelection(
        DWORD index,
        BOOL *enabled) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetStreamSelection(
        DWORD index,
        BOOL enabled) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetStreamAttribute(
        DWORD index,
        REFGUID key,
        PROPVARIANT *value) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetPresentationAttribute(
        REFGUID key,
        PROPVARIANT *value) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetCharacteristics(
        MFP_MEDIAITEM_CHARACTERISTICS *flags) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetStreamSink(
        DWORD index,
        IUnknown *sink) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetMetadata(
        IPropertyStore **metadata) = 0;

};
#ifdef __CRT_UUID_DECL
__CRT_UUID_DECL(IMFPMediaItem, 0x90eb3e6b, 0xecbf, 0x45cc, 0xb1,0xda, 0xc6,0xfe,0x3e,0xa7,0x0d,0x57)
#endif
#else
typedef struct IMFPMediaItemVtbl {
    BEGIN_INTERFACE

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

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

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

    /*** IMFPMediaItem methods ***/
    HRESULT (STDMETHODCALLTYPE *GetMediaPlayer)(
        IMFPMediaItem *This,
        IMFPMediaPlayer **player);

    HRESULT (STDMETHODCALLTYPE *GetURL)(
        IMFPMediaItem *This,
        LPWSTR *url);

    HRESULT (STDMETHODCALLTYPE *GetObject)(
        IMFPMediaItem *This,
        IUnknown **obj);

    HRESULT (STDMETHODCALLTYPE *GetUserData)(
        IMFPMediaItem *This,
        DWORD_PTR *user_data);

    HRESULT (STDMETHODCALLTYPE *SetUserData)(
        IMFPMediaItem *This,
        DWORD_PTR user_data);

    HRESULT (STDMETHODCALLTYPE *GetStartStopPosition)(
        IMFPMediaItem *This,
        GUID *start_format,
        PROPVARIANT *start_position,
        GUID *stop_format,
        PROPVARIANT *stop_position);

    HRESULT (STDMETHODCALLTYPE *SetStartStopPosition)(
        IMFPMediaItem *This,
        const GUID *start_format,
        const PROPVARIANT *start_position,
        const GUID *stop_format,
        const PROPVARIANT *stop_position);

    HRESULT (STDMETHODCALLTYPE *HasVideo)(
        IMFPMediaItem *This,
        BOOL *has_video,
        BOOL *selected);

    HRESULT (STDMETHODCALLTYPE *HasAudio)(
        IMFPMediaItem *This,
        BOOL *has_audio,
        BOOL *selected);

    HRESULT (STDMETHODCALLTYPE *IsProtected)(
        IMFPMediaItem *This,
        BOOL *protected);

    HRESULT (STDMETHODCALLTYPE *GetDuration)(
        IMFPMediaItem *This,
        REFGUID format,
        PROPVARIANT *value);

    HRESULT (STDMETHODCALLTYPE *GetNumberOfStreams)(
        IMFPMediaItem *This,
        DWORD *count);

    HRESULT (STDMETHODCALLTYPE *GetStreamSelection)(
        IMFPMediaItem *This,
        DWORD index,
        BOOL *enabled);

    HRESULT (STDMETHODCALLTYPE *SetStreamSelection)(
        IMFPMediaItem *This,
        DWORD index,
        BOOL enabled);

    HRESULT (STDMETHODCALLTYPE *GetStreamAttribute)(
        IMFPMediaItem *This,
        DWORD index,
        REFGUID key,
        PROPVARIANT *value);

    HRESULT (STDMETHODCALLTYPE *GetPresentationAttribute)(
        IMFPMediaItem *This,
        REFGUID key,
        PROPVARIANT *value);

    HRESULT (STDMETHODCALLTYPE *GetCharacteristics)(
        IMFPMediaItem *This,
        MFP_MEDIAITEM_CHARACTERISTICS *flags);

    HRESULT (STDMETHODCALLTYPE *SetStreamSink)(
        IMFPMediaItem *This,
        DWORD index,
        IUnknown *sink);

    HRESULT (STDMETHODCALLTYPE *GetMetadata)(
        IMFPMediaItem *This,
        IPropertyStore **metadata);

    END_INTERFACE
} IMFPMediaItemVtbl;

interface IMFPMediaItem {
    CONST_VTBL IMFPMediaItemVtbl* lpVtbl;
};

#ifdef COBJMACROS
#ifndef WIDL_C_INLINE_WRAPPERS
/*** IUnknown methods ***/
#define IMFPMediaItem_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
#define IMFPMediaItem_AddRef(This) (This)->lpVtbl->AddRef(This)
#define IMFPMediaItem_Release(This) (This)->lpVtbl->Release(This)
/*** IMFPMediaItem methods ***/
#define IMFPMediaItem_GetMediaPlayer(This,player) (This)->lpVtbl->GetMediaPlayer(This,player)
#define IMFPMediaItem_GetURL(This,url) (This)->lpVtbl->GetURL(This,url)
#define IMFPMediaItem_GetObject(This,obj) (This)->lpVtbl->GetObject(This,obj)
#define IMFPMediaItem_GetUserData(This,user_data) (This)->lpVtbl->GetUserData(This,user_data)
#define IMFPMediaItem_SetUserData(This,user_data) (This)->lpVtbl->SetUserData(This,user_data)
#define IMFPMediaItem_GetStartStopPosition(This,start_format,start_position,stop_format,stop_position) (This)->lpVtbl->GetStartStopPosition(This,start_format,start_position,stop_format,stop_position)
#define IMFPMediaItem_SetStartStopPosition(This,start_format,start_position,stop_format,stop_position) (This)->lpVtbl->SetStartStopPosition(This,start_format,start_position,stop_format,stop_position)
#define IMFPMediaItem_HasVideo(This,has_video,selected) (This)->lpVtbl->HasVideo(This,has_video,selected)
#define IMFPMediaItem_HasAudio(This,has_audio,selected) (This)->lpVtbl->HasAudio(This,has_audio,selected)
#define IMFPMediaItem_IsProtected(This,protected) (This)->lpVtbl->IsProtected(This,protected)
#define IMFPMediaItem_GetDuration(This,format,value) (This)->lpVtbl->GetDuration(This,format,value)
#define IMFPMediaItem_GetNumberOfStreams(This,count) (This)->lpVtbl->GetNumberOfStreams(This,count)
#define IMFPMediaItem_GetStreamSelection(This,index,enabled) (This)->lpVtbl->GetStreamSelection(This,index,enabled)
#define IMFPMediaItem_SetStreamSelection(This,index,enabled) (This)->lpVtbl->SetStreamSelection(This,index,enabled)
#define IMFPMediaItem_GetStreamAttribute(This,index,key,value) (This)->lpVtbl->GetStreamAttribute(This,index,key,value)
#define IMFPMediaItem_GetPresentationAttribute(This,key,value) (This)->lpVtbl->GetPresentationAttribute(This,key,value)
#define IMFPMediaItem_GetCharacteristics(This,flags) (This)->lpVtbl->GetCharacteristics(This,flags)
#define IMFPMediaItem_SetStreamSink(This,index,sink) (This)->lpVtbl->SetStreamSink(This,index,sink)
#define IMFPMediaItem_GetMetadata(This,metadata) (This)->lpVtbl->GetMetadata(This,metadata)
#else
/*** IUnknown methods ***/
static inline HRESULT IMFPMediaItem_QueryInterface(IMFPMediaItem* This,REFIID riid,void **ppvObject) {
    return This->lpVtbl->QueryInterface(This,riid,ppvObject);
}
static inline ULONG IMFPMediaItem_AddRef(IMFPMediaItem* This) {
    return This->lpVtbl->AddRef(This);
}
static inline ULONG IMFPMediaItem_Release(IMFPMediaItem* This) {
    return This->lpVtbl->Release(This);
}
/*** IMFPMediaItem methods ***/
static inline HRESULT IMFPMediaItem_GetMediaPlayer(IMFPMediaItem* This,IMFPMediaPlayer **player) {
    return This->lpVtbl->GetMediaPlayer(This,player);
}
static inline HRESULT IMFPMediaItem_GetURL(IMFPMediaItem* This,LPWSTR *url) {
    return This->lpVtbl->GetURL(This,url);
}
static inline HRESULT IMFPMediaItem_GetObject(IMFPMediaItem* This,IUnknown **obj) {
    return This->lpVtbl->GetObject(This,obj);
}
static inline HRESULT IMFPMediaItem_GetUserData(IMFPMediaItem* This,DWORD_PTR *user_data) {
    return This->lpVtbl->GetUserData(This,user_data);
}
static inline HRESULT IMFPMediaItem_SetUserData(IMFPMediaItem* This,DWORD_PTR user_data) {
    return This->lpVtbl->SetUserData(This,user_data);
}
static inline HRESULT IMFPMediaItem_GetStartStopPosition(IMFPMediaItem* This,GUID *start_format,PROPVARIANT *start_position,GUID *stop_format,PROPVARIANT *stop_position) {
    return This->lpVtbl->GetStartStopPosition(This,start_format,start_position,stop_format,stop_position);
}
static inline HRESULT IMFPMediaItem_SetStartStopPosition(IMFPMediaItem* This,const GUID *start_format,const PROPVARIANT *start_position,const GUID *stop_format,const PROPVARIANT *stop_position) {
    return This->lpVtbl->SetStartStopPosition(This,start_format,start_position,stop_format,stop_position);
}
static inline HRESULT IMFPMediaItem_HasVideo(IMFPMediaItem* This,BOOL *has_video,BOOL *selected) {
    return This->lpVtbl->HasVideo(This,has_video,selected);
}
static inline HRESULT IMFPMediaItem_HasAudio(IMFPMediaItem* This,BOOL *has_audio,BOOL *selected) {
    return This->lpVtbl->HasAudio(This,has_audio,selected);
}
static inline HRESULT IMFPMediaItem_IsProtected(IMFPMediaItem* This,BOOL *protected) {
    return This->lpVtbl->IsProtected(This,protected);
}
static inline HRESULT IMFPMediaItem_GetDuration(IMFPMediaItem* This,REFGUID format,PROPVARIANT *value) {
    return This->lpVtbl->GetDuration(This,format,value);
}
static inline HRESULT IMFPMediaItem_GetNumberOfStreams(IMFPMediaItem* This,DWORD *count) {
    return This->lpVtbl->GetNumberOfStreams(This,count);
}
static inline HRESULT IMFPMediaItem_GetStreamSelection(IMFPMediaItem* This,DWORD index,BOOL *enabled) {
    return This->lpVtbl->GetStreamSelection(This,index,enabled);
}
static inline HRESULT IMFPMediaItem_SetStreamSelection(IMFPMediaItem* This,DWORD index,BOOL enabled) {
    return This->lpVtbl->SetStreamSelection(This,index,enabled);
}
static inline HRESULT IMFPMediaItem_GetStreamAttribute(IMFPMediaItem* This,DWORD index,REFGUID key,PROPVARIANT *value) {
    return This->lpVtbl->GetStreamAttribute(This,index,key,value);
}
static inline HRESULT IMFPMediaItem_GetPresentationAttribute(IMFPMediaItem* This,REFGUID key,PROPVARIANT *value) {
    return This->lpVtbl->GetPresentationAttribute(This,key,value);
}
static inline HRESULT IMFPMediaItem_GetCharacteristics(IMFPMediaItem* This,MFP_MEDIAITEM_CHARACTERISTICS *flags) {
    return This->lpVtbl->GetCharacteristics(This,flags);
}
static inline HRESULT IMFPMediaItem_SetStreamSink(IMFPMediaItem* This,DWORD index,IUnknown *sink) {
    return This->lpVtbl->SetStreamSink(This,index,sink);
}
static inline HRESULT IMFPMediaItem_GetMetadata(IMFPMediaItem* This,IPropertyStore **metadata) {
    return This->lpVtbl->GetMetadata(This,metadata);
}
#endif
#endif

#endif


#endif  /* __IMFPMediaItem_INTERFACE_DEFINED__ */

HRESULT WINAPI MFPCreateMediaPlayer(const WCHAR *url, BOOL start_playback, MFP_CREATION_OPTIONS options, 
        IMFPMediaPlayerCallback *callback, HWND hwnd, IMFPMediaPlayer **player);
/* Begin additional prototypes for all interfaces */


/* End additional prototypes */

#ifdef __cplusplus
}
#endif

#endif /* __mfplay_h__ */
