# Makefile.in --
#
#	This file is a Makefile for Sample TEA Extension.  If it has the name
#	"Makefile.in" then it is a template for a Makefile;  to generate the
#	actual Makefile, run "./configure", which is a configuration script
#	generated by the "autoconf" program (constructs like "@foo@" will get
#	replaced in the actual Makefile.
#
# Copyright (c) 1999 Scriptics Corporation.
# Copyright (c) 2003-2008 ActiveState Software
#
# See the file "license.terms" for information on usage and redistribution
# of this file, and for a DISCLAIMER OF ALL WARRANTIES.

#========================================================================
# Nothing of the variables below this line need to be changed.  Please
# check the TARGETS section below to make sure the make targets are
# correct.
#========================================================================

#========================================================================
# The names of the source files is defined in the configure script.
# The object files are used for linking into the final library.
# This will be used when a dist target is added to the Makefile.
# It is not important to specify the directory, as long as it is the
# $(srcdir) subdirectory.
#========================================================================

PKG_SOURCES	= @PKG_SOURCES@
PKG_OBJECTS	= @PKG_OBJECTS@

#========================================================================
# PKG_TCL_SOURCES identifies Tcl runtime files that are associated with
# this package that need to be installed, if any.
#========================================================================

PKG_TCL_SOURCES = @PKG_TCL_SOURCES@

#========================================================================
# This is a list of public header files to be installed, if any.
#========================================================================

PKG_HEADERS	= @PKG_HEADERS@

PKG_EXTRA_FILES =

PKG_MAN_PAGES	=

#========================================================================
# "PKG_LIB_FILE" refers to the library (dynamic or static as per
# configuration options) composed of the named objects.
#========================================================================

PKG_LIB_FILE	= @PKG_LIB_FILE@
PKG_STUB_LIB_FILE = @PKG_STUB_LIB_FILE@

lib_BINARIES	= $(PKG_LIB_FILE)
BINARIES	= $(lib_BINARIES)

SHELL		= @SHELL@

srcdir		= @srcdir@
prefix		= @prefix@
exec_prefix	= @exec_prefix@

bindir		= @bindir@
libdir		= @libdir@
datadir		= @datadir@
mandir		= @mandir@
includedir	= @includedir@

DESTDIR		=

PKG_DIR		= $(PACKAGE_NAME)$(PACKAGE_VERSION)
pkgdatadir	= $(datadir)/$(PKG_DIR)
pkglibdir	= $(libdir)/$(PKG_DIR)
pkgincludedir	= $(includedir)/$(PKG_DIR)

top_builddir	= .

INSTALL		= @INSTALL@
INSTALL_PROGRAM	= @INSTALL_PROGRAM@
INSTALL_DATA	= @INSTALL_DATA@
INSTALL_SCRIPT	= @INSTALL_SCRIPT@

PACKAGE_NAME	= @PACKAGE_NAME@
PACKAGE_VERSION	= @PACKAGE_VERSION@
CC		= @CC@
CFLAGS_DEFAULT	= @CFLAGS_DEFAULT@
CFLAGS_WARNING	= @CFLAGS_WARNING@
CLEANFILES	= @CLEANFILES@
EXEEXT		= @EXEEXT@
LDFLAGS_DEFAULT	= @LDFLAGS_DEFAULT@
MAKE_LIB	= @MAKE_LIB@
MAKE_SHARED_LIB	= @MAKE_SHARED_LIB@
MAKE_STATIC_LIB	= @MAKE_STATIC_LIB@
MAKE_STUB_LIB	= @MAKE_STUB_LIB@
OBJEXT		= @OBJEXT@
RANLIB		= @RANLIB@
RANLIB_STUB	= @RANLIB_STUB@
SHLIB_CFLAGS	= @SHLIB_CFLAGS@
SHLIB_LD	= @SHLIB_LD@
SHLIB_LD_LIBS	= @SHLIB_LD_LIBS@
STLIB_LD	= @STLIB_LD@
TCL_DEFS	= @TCL_DEFS@
TCL_SRC_DIR	= @TCL_SRC_DIR@
TCL_BIN_DIR	= @TCL_BIN_DIR@
TK_SRC_DIR	= @TK_SRC_DIR@
TK_BIN_DIR	= @TK_BIN_DIR@

# Not used by sample, but retained for reference of what Tcl required
TCL_LIBS	= @TCL_LIBS@
#TK_LIBS	= @TK_LIBS@
# TK_LIBS currently not required
TK_LIBS		=

#========================================================================
# TCLLIBPATH seeds the auto_path in Tcl's init.tcl so we can test our
# package without installing.  The other environment variables allow us
# to test against an uninstalled Tcl.  Add special env vars that you
# require for testing here (like TCLX_LIBRARY).
#========================================================================

EXTRA_PATH	= $(top_builddir):$(TCL_BIN_DIR):$(TK_BIN_DIR)
TCLSH_ENV	= TCL_LIBRARY=`@CYGPATH@ $(TCL_SRC_DIR)/library` \
		  TK_LIBRARY=`@CYGPATH@ $(TK_SRC_DIR)/library` \
		  @LD_LIBRARY_PATH_VAR@="$(EXTRA_PATH):$(@LD_LIBRARY_PATH_VAR@)" \
		  PATH="$(EXTRA_PATH):$(PATH)" \
		  TCLLIBPATH="$(top_builddir)"
TCLSH_PROG	= @TCLSH_PROG@
WISH_PROG	= @WISH_PROG@
TCLSH		= $(TCLSH_ENV) $(TCLSH_PROG)
WISH		= $(TCLSH_ENV) $(WISH_PROG)

# The local includes must come first, because the TK_XINCLUDES can be
# just a comment
INCLUDES	= @PKG_INCLUDES@ -Icompat \
		  @TCL_INCLUDES@ @TK_INCLUDES@ @TK_XINCLUDES@

PKG_CFLAGS	= @PKG_CFLAGS@

DEFS		= @DEFS@ $(PKG_CFLAGS)

CONFIG_CLEAN_FILES = Makefile

CPPFLAGS	= @CPPFLAGS@
LIBS		= @PKG_LIBS@ @LIBS@
AR		= @AR@
CFLAGS		= @CFLAGS@
COMPILE		= $(CC) $(DEFS) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)

#========================================================================
# Start of user-definable TARGETS section
#========================================================================

#========================================================================
# TEA TARGETS.  Please note that the "libraries:" target refers to platform
# independent files, and the "binaries:" target inclues executable programs and
# platform-dependent libraries.  Modify these targets so that they install
# the various pieces of your package.  The make and install rules
# for the BINARIES that you specified above have already been done.
#========================================================================

all: binaries libraries doc

#========================================================================
# The binaries target builds executable programs, Windows .dll's, unix
# shared/static libraries, and any other platform-dependent files.
# The list of targets to build for "binaries:" is specified at the top
# of the Makefile, in the "BINARIES" variable.
#========================================================================

binaries: $(BINARIES) pkgIndex.tcl

libraries:

doc:

install: all install-binaries install-libraries install-doc

install-binaries: binaries install-lib-binaries install-bin-binaries
	@mkdir -p $(DESTDIR)$(pkglibdir)
	$(INSTALL_DATA) pkgIndex.tcl $(DESTDIR)$(pkglibdir)
	@list='$(PKG_EXTRA_FILES)'; for p in $$list; do \
	  if test -f $(srcdir)/$$p; then \
	    destp=`basename $$p`; \
	    echo " Install $$destp $(DESTDIR)$(pkglibdir)/$$destp"; \
	    $(INSTALL_DATA) $(srcdir)/$$p $(DESTDIR)$(pkglibdir)/$$destp; \
	  fi; \
	done

#========================================================================
# This rule installs platform-independent files, such as header files.
#========================================================================

install-libraries: libraries

#========================================================================
# Install documentation.  Unix manpages should go in the $(mandir)
# directory.
#========================================================================

install-doc: doc
	@mkdir -p $(DESTDIR)$(mandir)/mann
	@echo "Installing documentation in $(DESTDIR)$(mandir)"
	@list='$(srcdir)/doc/*.n'; for i in $$list; do \
	  echo "Installing $$i"; \
	  rm -f $(DESTDIR)$(mandir)/mann/`basename $$i`; \
	  $(INSTALL_DATA) $$i $(DESTDIR)$(mandir)/mann ; \
	done

test:

shell: binaries libraries
	@$(TCLSH) $(SCRIPT)

gdb:
	$(TCLSH_ENV) gdb $(TCLSH_PROG) $(SCRIPT)

depend:

#========================================================================
# $(PKG_LIB_FILE) should be listed as part of the BINARIES variable
# mentioned above.  That will ensure that this target is built when you
# run "make binaries".
#
# The $(PKG_OBJECTS) objects are created and linked into the final
# library.  In most cases these object files will correspond to the
# source files above.
#========================================================================

$(PKG_LIB_FILE): $(PKG_OBJECTS)
	-rm -f $(PKG_LIB_FILE)
	${MAKE_LIB}
	$(RANLIB) $(PKG_LIB_FILE)

#========================================================================
# In the following lines, $(srcdir) refers to the toplevel directory
# containing your extension.  If your sources are in a subdirectory,
# you will have to modify the paths to reflect this:
#
# tkpkg.$(OBJEXT): $(srcdir)/tkpkg.c
# 	$(COMPILE) -c `@CYGPATH@ $(srcdir)/tkpkg.c` -o $@
#
# Setting the VPATH variable to a list of paths will cause the
# makefile to look into these paths when resolving .c to .obj
# dependencies.
#========================================================================

# I added leading $(srcdir) because autoconf 2.53 strips it off
VPATH = $(srcdir)

.SUFFIXES: .c .$(OBJEXT)

.c.@OBJEXT@:
	$(COMPILE) -c `@CYGPATH@ $<` -o $@

pkgIndex.tcl:
	echo 'package ifneeded $(PACKAGE_NAME) $(PACKAGE_VERSION) \
	    [list load [file join $$dir $(PKG_LIB_FILE)] $(PACKAGE_NAME)]' \
	  > pkgIndex.tcl

#========================================================================
# End of user-definable section
#========================================================================

#========================================================================
# Don't modify the file to clean here.  Instead, set the "CLEANFILES"
# variable in configure.in
#========================================================================

clean:
	-test -z "$(BINARIES)" || rm -f $(BINARIES)
	-rm -f *.$(OBJEXT) core *.core *~
	-test -z "$(CLEANFILES)" || rm -f $(CLEANFILES)

distclean: clean
	-rm -f *.tab.c
	-rm -f $(CONFIG_CLEAN_FILES)
	-rm -f config.cache config.log config.status

#========================================================================
# Install binary object libraries.  On Windows this includes both .dll and
# .lib files.  Because the .lib files are not explicitly listed anywhere,
# we need to deduce their existence from the .dll file of the same name.
#
# You should not have to modify this target.
#========================================================================

install-lib-binaries:
	@mkdir -p $(DESTDIR)$(pkglibdir)
	@list='$(lib_BINARIES)'; for p in $$list; do \
	  if test -f $$p; then \
	    echo " $(INSTALL_PROGRAM) $$p $(DESTDIR)$(pkglibdir)/$$p"; \
	    $(INSTALL_PROGRAM) $$p $(DESTDIR)$(pkglibdir)/$$p; \
	    echo " $(RANLIB) $(DESTDIR)$(pkglibdir)/$$p"; \
	    $(RANLIB) $(DESTDIR)$(pkglibdir)/$$p; \
	    ext=`echo $$p|sed -e "s/.*\.//"`; \
	    if test "x$$ext" = "xdll"; then \
		lib=`basename $$p|sed -e 's/.[^.]*$$//'`.lib; \
		if test -f $$lib; then \
		    echo " $(INSTALL_DATA) $$lib $(DESTDIR)$(pkglibdir)/$$lib"; \
	            $(INSTALL_DATA) $$lib $(DESTDIR)$(pkglibdir)/$$lib; \
		fi; \
	    fi; \
	  fi; \
	done
	@list='$(PKG_TCL_SOURCES)'; for p in $$list; do \
	  if test -f $(srcdir)/$$p; then \
	    destp=`basename $$p`; \
	    echo " Install $$destp $(DESTDIR)$(pkglibdir)/$$destp"; \
	    $(INSTALL_DATA) $(srcdir)/$$p $(DESTDIR)$(pkglibdir)/$$destp; \
	  fi; \
	done

#========================================================================
# Install binary executables (e.g. .exe files)
#
# You should not have to modify this target.
#========================================================================

install-bin-binaries:
	@mkdir -p $(DESTDIR)$(bindir)
	@list='$(bin_BINARIES)'; for p in $$list; do \
	  if test -f $$p; then \
	    echo " $(INSTALL_PROGRAM) $$p $(DESTDIR)$(bindir)/$$p"; \
	    $(INSTALL_PROGRAM) $$p $(DESTDIR)$(bindir)/$$p; \
	  fi; \
	done

Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
	cd $(top_builddir) \
	  && CONFIG_FILES=$@ CONFIG_HEADERS= $(SHELL) ./config.status

uninstall-binaries:
	list='$(lib_BINARIES)'; for p in $$list; do \
	  rm -f $(DESTDIR)$(pkglibdir)/$$p; \
	done
	list='$(PKG_TCL_SOURCES)'; for p in $$list; do \
	  p=`basename $$p`; \
	  rm -f $(DESTDIR)$(pkglibdir)/$$p; \
	done
	list='$(bin_BINARIES)'; for p in $$list; do \
	  rm -f $(DESTDIR)$(bindir)/$$p; \
	done

#========================================================================
# Distribution creation
# You should not have to modify this target.
#========================================================================

TAR		= tar
#COMPRESS	= $(TAR) cvf $(PKG_DIR).tar $(PKG_DIR); compress $(PKG_DIR).tar
COMPRESS	= $(TAR) zcvf $(PKG_DIR).tar.gz $(PKG_DIR)
DIST_ROOT	= /tmp/dist
DIST_DIR	= $(DIST_ROOT)/$(PKG_DIR)

dist-clean:
	rm -rf $(DIST_DIR) $(DIST_ROOT)/$(PKG_DIR).tar.*

dist: dist-clean
	mkdir -p $(DIST_DIR)
	cp -p $(srcdir)/license.terms \
		$(srcdir)/Makefile.in $(srcdir)/aclocal.m4 \
		$(srcdir)/configure $(srcdir)/configure.in  $(DIST_DIR)/
	chmod 664 $(DIST_DIR)/Makefile.in $(DIST_DIR)/aclocal.m4
	chmod 775 $(DIST_DIR)/configure $(DIST_DIR)/configure.in
	mkdir -p $(DIST_DIR)/tclconfig
	cp $(srcdir)/tclconfig/install-sh $(srcdir)/tclconfig/tcl.m4 \
		$(DIST_DIR)/tclconfig/
	chmod 664 $(DIST_DIR)/tclconfig/tcl.m4
	chmod +x $(DIST_DIR)/tclconfig/install-sh
	mkdir -p $(DIST_DIR)/demos
	cp -p $(srcdir)/demos/*.tcl $(DIST_DIR)/demos/
	mkdir -p $(DIST_DIR)/doc
	cp -p $(srcdir)/doc/*.n $(DIST_DIR)/doc/
	mkdir -p $(DIST_DIR)
	cp -p $(srcdir)/*.[ch] $(DIST_DIR)
	(cd $(DIST_ROOT); $(COMPRESS);)

.PHONY: all binaries clean depend distclean doc install libraries test

# Tell versions [3.59,3.63) of GNU make to not export all variables.
# Otherwise a system limit (for SysV at least) may be exceeded.
.NOEXPORT:

#
# Include the TEA standard macro set
#

builtin(include,tclconfig/tcl.m4)

#
# Add here whatever m4 macros you want to define for your package
#

/**
 * This file is part of the mingw-w64 runtime package.
 * No warranty is given; refer to the file DISCLAIMER within this package.
 */

#include <winapifamily.h>

#ifndef __MFAPI_H__
#define __MFAPI_H__

#include <mfobjects.h>
#include <mmreg.h>
#include <avrt.h>

#ifndef AVRT_DATA
#define AVRT_DATA
#endif

#ifndef AVRT_BSS
#define AVRT_BSS
#endif

#ifndef MF_VERSION
#if WINVER < 0x0601
#define MF_SDK_VERSION 0x1
#else
#define MF_SDK_VERSION 0x2
#endif

#define MF_API_VERSION 0x0070
#define MF_VERSION (MF_SDK_VERSION << 16 | MF_API_VERSION)
#endif

/*ksmedia.h needs fixing about "multi-character character constant"*/
typedef struct _MFT_REGISTRATION_INFO MFT_REGISTRATION_INFO;
typedef struct IMFActivate IMFActivate;

#define MFSTARTUP_NOSOCKET 0x1
#define MFSTARTUP_LITE (MFSTARTUP_NOSOCKET)
#define MFSTARTUP_FULL 0

#if defined (__cplusplus)
extern "C" {
#endif

#if WINAPI_FAMILY_PARTITION (WINAPI_PARTITION_APP)
  typedef unsigned __int64 MFWORKITEM_KEY;

#if defined (__cplusplus) && !defined (CINTERFACE)
  typedef struct tagMFASYNCRESULT : public IMFAsyncResult {
    OVERLAPPED overlapped;
    IMFAsyncCallback *pCallback;
    HRESULT hrStatusResult;
    DWORD dwBytesTransferred;
    HANDLE hEvent;
  } MFASYNCRESULT;
#else
  typedef struct tagMFASYNCRESULT {
    IMFAsyncResult AsyncResult;
    OVERLAPPED overlapped;
    IMFAsyncCallback *pCallback;
    HRESULT hrStatusResult;
    DWORD dwBytesTransferred;
    HANDLE hEvent;
  } MFASYNCRESULT;
#endif

  STDAPI MFStartup (ULONG Version, DWORD dwFlags
#if defined (__cplusplus)
    = MFSTARTUP_FULL
#endif
    );

  STDAPI MFShutdown ();
  STDAPI MFLockPlatform ();
  STDAPI MFUnlockPlatform ();
  STDAPI MFPutWorkItem2 (DWORD dwQueue, LONG Priority, IMFAsyncCallback *pCallback, IUnknown *pState);
  STDAPI MFPutWorkItemEx2 (DWORD dwQueue, LONG Priority, IMFAsyncResult *pResult);
  STDAPI MFPutWaitingWorkItem (HANDLE hEvent, LONG Priority, IMFAsyncResult *pResult, MFWORKITEM_KEY *pKey);
  STDAPI MFAllocateSerialWorkQueue (DWORD dwWorkQueue, DWORD *pdwWorkQueue);
  STDAPI MFCancelWorkItem (MFWORKITEM_KEY Key);
  STDAPI MFLockWorkQueue (DWORD dwWorkQueue);
  STDAPI MFUnlockWorkQueue (DWORD dwWorkQueue);
  STDAPI MFLockSharedWorkQueue (PCWSTR wszClass, LONG BasePriority, DWORD *pdwTaskId, DWORD *pID);
  STDAPI MFCreateAsyncResult (IUnknown *punkObject, IMFAsyncCallback *pCallback, IUnknown *punkState, IMFAsyncResult **ppAsyncResult);
  STDAPI MFInvokeCallback (IMFAsyncResult *pAsyncResult);
  STDAPI MFCreateMemoryBuffer (DWORD cbMaxLength, IMFMediaBuffer **ppBuffer);
  STDAPI MFCreateMediaBufferWrapper (IMFMediaBuffer *pBuffer, DWORD cbOffset, DWORD dwLength, IMFMediaBuffer **ppBuffer);
#endif

#if WINAPI_FAMILY_PARTITION (WINAPI_PARTITION_DESKTOP)
#include <dxgiformat.h>

  typedef void (*MFPERIODICCALLBACK) (IUnknown *pContext);

  typedef enum _EAllocationType {
    eAllocationTypeDynamic,
    eAllocationTypeRT,
    eAllocationTypePageable,
    eAllocationTypeIgnore
  } EAllocationType;

#if WINVER >= 0x0601
  typedef enum {
    MF_STANDARD_WORKQUEUE = 0,
    MF_WINDOW_WORKQUEUE = 1,
    MF_MULTITHREADED_WORKQUEUE = 2,
  } MFASYNC_WORKQUEUE_TYPE;
#endif

  STDAPI MFPutWorkItem (DWORD dwQueue, IMFAsyncCallback *pCallback, IUnknown *pState);
  STDAPI MFPutWorkItemEx (DWORD dwQueue, IMFAsyncResult *pResult);
  STDAPI MFScheduleWorkItem (IMFAsyncCallback *pCallback, IUnknown *pState, INT64 Timeout, MFWORKITEM_KEY *pKey);
  STDAPI MFScheduleWorkItemEx (IMFAsyncResult *pResult, INT64 Timeout, MFWORKITEM_KEY *pKey);
  STDAPI MFGetTimerPeriodicity (DWORD *Periodicity);
  STDAPI MFAddPeriodicCallback (MFPERIODICCALLBACK Callback, IUnknown *pContext, DWORD *pdwKey);
  STDAPI MFRemovePeriodicCallback (DWORD dwKey);
  STDAPI MFAllocateWorkQueue (DWORD *pdwWorkQueue);
  STDAPI MFBeginRegisterWorkQueueWithMMCSS (DWORD dwWorkQueueId, LPCWSTR wszClass, DWORD dwTaskId, IMFAsyncCallback *pDoneCallback, IUnknown *pDoneState);
  STDAPI MFBeginRegisterWorkQueueWithMMCSSEx (DWORD dwWorkQueueId, LPCWSTR wszClass, DWORD dwTaskId, LONG lPriority, IMFAsyncCallback *pDoneCallback, IUnknown *pDoneState);
  STDAPI MFEndRegisterWorkQueueWithMMCSS (IMFAsyncResult *pResult, DWORD *pdwTaskId);
  STDAPI MFBeginUnregisterWorkQueueWithMMCSS (DWORD dwWorkQueueId, IMFAsyncCallback *pDoneCallback, IUnknown *pDoneState);
  STDAPI MFEndUnregisterWorkQueueWithMMCSS (IMFAsyncResult *pResult);
  STDAPI MFGetWorkQueueMMCSSClass (DWORD dwWorkQueueId, LPWSTR pwszClass, DWORD *pcchClass);
  STDAPI MFGetWorkQueueMMCSSTaskId (DWORD dwWorkQueueId, LPDWORD pdwTaskId);
  STDAPI MFRegisterPlatformWithMMCSS (PCWSTR wszClass, DWORD *pdwTaskId, LONG lPriority);
  STDAPI MFUnregisterPlatformFromMMCSS ();
  STDAPI MFGetWorkQueueMMCSSPriority (DWORD dwWorkQueueId, LONG *lPriority);
  STDAPI MFCreateFile (MF_FILE_ACCESSMODE AccessMode, MF_FILE_OPENMODE OpenMode, MF_FILE_FLAGS fFlags, LPCWSTR pwszFileURL, IMFByteStream **ppIByteStream);
  STDAPI MFCreateTempFile (MF_FILE_ACCESSMODE AccessMode, MF_FILE_OPENMODE OpenMode, MF_FILE_FLAGS fFlags, IMFByteStream **ppIByteStream);
  STDAPI MFBeginCreateFile (MF_FILE_ACCESSMODE AccessMode, MF_FILE_OPENMODE OpenMode, MF_FILE_FLAGS fFlags, LPCWSTR pwszFilePath, IMFAsyncCallback *pCallback, IUnknown *pState, IUnknown **ppCancelCookie);
  STDAPI MFEndCreateFile (IMFAsyncResult *pResult, IMFByteStream **ppFile);
  STDAPI MFCancelCreateFile (IUnknown *pCancelCookie);
  STDAPI MFCreateLegacyMediaBufferOnMFMediaBuffer (IMFSample *pSample, IMFMediaBuffer *pMFMediaBuffer, DWORD cbOffset, IMediaBuffer **ppMediaBuffer);
  STDAPI_ (DXGI_FORMAT) MFMapDX9FormatToDXGIFormat (DWORD dx9);
  STDAPI_ (DWORD) MFMapDXGIFormatToDX9Format (DXGI_FORMAT dx11);
  STDAPI MFCreateDXSurfaceBuffer (REFIID riid, IUnknown *punkSurface, WINBOOL fBottomUpWhenLinear, IMFMediaBuffer **ppBuffer);
  STDAPI MFCreateWICBitmapBuffer (REFIID riid, IUnknown *punkSurface, IMFMediaBuffer **ppBuffer);
  STDAPI MFGetContentProtectionSystemCLSID (REFGUID guidProtectionSystemID, CLSID *pclsid);
#if WINVER >= 0x0601
  STDAPI MFAllocateWorkQueueEx (MFASYNC_WORKQUEUE_TYPE WorkQueueType, DWORD *pdwWorkQueue);
#endif
  EXTERN_C void *WINAPI MFHeapAlloc (size_t nSize, ULONG dwFlags, char *pszFile, int line, EAllocationType eat);
  EXTERN_C void WINAPI MFHeapFree (void *pv);

  DEFINE_GUID (CLSID_MFSourceResolver, 0x90eab60f, 0xe43a, 0x4188, 0xbc, 0xc4, 0xe4, 0x7f, 0xdf, 0x04, 0x86, 0x8c);
#endif

#if WINAPI_FAMILY_PARTITION (WINAPI_PARTITION_APP)
  STDAPI MFLockDXGIDeviceManager (UINT *pResetToken, IMFDXGIDeviceManager **ppManager);
  STDAPI MFUnlockDXGIDeviceManager ();
  STDAPI MFCreateDXGISurfaceBuffer (REFIID riid, IUnknown *punkSurface, UINT uSubresourceIndex, WINBOOL fBottomUpWhenLinear, IMFMediaBuffer **ppBuffer);
  STDAPI MFCreateVideoSampleAllocatorEx (REFIID riid, void **ppSampleAllocator);
  STDAPI MFCreateDXGIDeviceManager (UINT *resetToken, IMFDXGIDeviceManager **ppDeviceManager);
  STDAPI MFCreateAlignedMemoryBuffer (DWORD cbMaxLength, DWORD cbAligment, IMFMediaBuffer **ppBuffer);
  STDAPI MFCreateMediaEvent (MediaEventType met, REFGUID guidExtendedType, HRESULT hrStatus, const PROPVARIANT *pvValue, IMFMediaEvent **ppEvent);
  STDAPI MFCreateEventQueue (IMFMediaEventQueue **ppMediaEventQueue);

#define MF_E_DXGI_DEVICE_NOT_INITIALIZED ((HRESULT)__MSABI_LONG(0x80041000))
#define MF_E_DXGI_NEW_VIDEO_DEVICE ((HRESULT)__MSABI_LONG(0x80041001))
#define MF_E_DXGI_VIDEO_DEVICE_LOCKED ((HRESULT)__MSABI_LONG(0x80041002))

#define MF_1_BYTE_ALIGNMENT 0x00000000
#define MF_2_BYTE_ALIGNMENT 0x00000001
#define MF_4_BYTE_ALIGNMENT 0x00000003
#define MF_8_BYTE_ALIGNMENT 0x00000007
#ifndef MF_16_BYTE_ALIGNMENT
#define MF_16_BYTE_ALIGNMENT 0x0000000f
#endif
#ifndef MF_32_BYTE_ALIGNMENT
#define MF_32_BYTE_ALIGNMENT 0x0000001f
#endif
#ifndef MF_64_BYTE_ALIGNMENT
#define MF_64_BYTE_ALIGNMENT 0x0000003f
#endif
#ifndef MF_128_BYTE_ALIGNMENT
#define MF_128_BYTE_ALIGNMENT 0x0000007f
#endif
#ifndef MF_256_BYTE_ALIGNMENT
#define MF_256_BYTE_ALIGNMENT 0x000000ff
#endif
#ifndef MF_512_BYTE_ALIGNMENT
#define MF_512_BYTE_ALIGNMENT 0x000001ff
#endif

#endif

#if WINAPI_FAMILY_PARTITION (WINAPI_PARTITION_DESKTOP)
  typedef enum {
    MF_TOPOSTATUS_INVALID = 0,
    MF_TOPOSTATUS_READY = 100,
    MF_TOPOSTATUS_STARTED_SOURCE = 200,
#if WINVER >= 0x0601
    MF_TOPOSTATUS_DYNAMIC_CHANGED = 210,
#endif
    MF_TOPOSTATUS_SINK_SWITCHED = 300,
    MF_TOPOSTATUS_ENDED = 400,
  } MF_TOPOSTATUS;

  EXTERN_C const GUID MR_BUFFER_SERVICE;

#define MFSESSIONCAP_START 0x00000001
#define MFSESSIONCAP_SEEK 0x00000002
#define MFSESSIONCAP_PAUSE 0x00000004
#define MFSESSIONCAP_RATE_FORWARD 0x00000010
#define MFSESSIONCAP_RATE_REVERSE 0x00000020
#define MFSESSIONCAP_DOES_NOT_USE_NETWORK 0x00000040

  DEFINE_GUID (MF_EVENT_SESSIONCAPS, 0x7e5ebcd0, 0x11b8, 0x4abe, 0xaf, 0xad, 0x10, 0xf6, 0x59, 0x9a, 0x7f, 0x42);
  DEFINE_GUID (MF_EVENT_SESSIONCAPS_DELTA, 0x7e5ebcd1, 0x11b8, 0x4abe, 0xaf, 0xad, 0x10, 0xf6, 0x59, 0x9a, 0x7f, 0x42);
  DEFINE_GUID (MF_EVENT_TOPOLOGY_STATUS, 0x30c5018d, 0x9a53, 0x454b, 0xad, 0x9e, 0x6d, 0x5f, 0x8f, 0xa7, 0xc4, 0x3b);
  DEFINE_GUID (MF_EVENT_START_PRESENTATION_TIME, 0x5ad914d0, 0x9b45, 0x4a8d, 0xa2, 0xc0, 0x81, 0xd1, 0xe5, 0xb, 0xfb, 0x7);
  DEFINE_GUID (MF_EVENT_PRESENTATION_TIME_OFFSET, 0x5ad914d1, 0x9b45, 0x4a8d, 0xa2, 0xc0, 0x81, 0xd1, 0xe5, 0xb, 0xfb, 0x7);
  DEFINE_GUID (MF_EVENT_START_PRESENTATION_TIME_AT_OUTPUT, 0x5ad914d2, 0x9b45, 0x4a8d, 0xa2, 0xc0, 0x81, 0xd1, 0xe5, 0xb, 0xfb, 0x7);
  DEFINE_GUID (MF_EVENT_SOURCE_FAKE_START, 0xa8cc55a7, 0x6b31, 0x419f, 0x84, 0x5d, 0xff, 0xb3, 0x51, 0xa2, 0x43, 0x4b);
  DEFINE_GUID (MF_EVENT_SOURCE_PROJECTSTART, 0xa8cc55a8, 0x6b31, 0x419f, 0x84, 0x5d, 0xff, 0xb3, 0x51, 0xa2, 0x43, 0x4b);
  DEFINE_GUID (MF_EVENT_SOURCE_ACTUAL_START, 0xa8cc55a9, 0x6b31, 0x419f, 0x84, 0x5d, 0xff, 0xb3, 0x51, 0xa2, 0x43, 0x4b);
  DEFINE_GUID (MF_EVENT_SOURCE_TOPOLOGY_CANCELED, 0xdb62f650, 0x9a5e, 0x4704, 0xac, 0xf3, 0x56, 0x3b, 0xc6, 0xa7, 0x33, 0x64);
  DEFINE_GUID (MF_EVENT_SOURCE_CHARACTERISTICS, 0x47db8490, 0x8b22, 0x4f52, 0xaf, 0xda, 0x9c, 0xe1, 0xb2, 0xd3, 0xcf, 0xa8);
  DEFINE_GUID (MF_EVENT_SOURCE_CHARACTERISTICS_OLD, 0x47db8491, 0x8b22, 0x4f52, 0xaf, 0xda, 0x9c, 0xe1, 0xb2, 0xd3, 0xcf, 0xa8);
  DEFINE_GUID (MF_EVENT_DO_THINNING, 0x321ea6fb, 0xdad9, 0x46e4, 0xb3, 0x1d, 0xd2, 0xea, 0xe7, 0x9, 0xe, 0x30);
  DEFINE_GUID (MF_EVENT_SCRUBSAMPLE_TIME, 0x9ac712b3, 0xdcb8, 0x44d5, 0x8d, 0xc, 0x37, 0x45, 0x5a, 0x27, 0x82, 0xe3);
  DEFINE_GUID (MF_EVENT_OUTPUT_NODE, 0x830f1a8b, 0xc060, 0x46dd, 0xa8, 0x01, 0x1c, 0x95, 0xde, 0xc9, 0xb1, 0x07);
  DEFINE_GUID (MF_EVENT_FORMAT_CHANGE_REQUEST_SOURCE_SAR, 0xb26fbdfd, 0xc32c, 0x41fe, 0x9c, 0xf0, 0x8, 0x3c, 0xd5, 0xc7, 0xf8, 0xa4);
#endif

#if WINAPI_FAMILY_PARTITION (WINAPI_PARTITION_APP)
#if WINVER >= 0x0601
  DEFINE_GUID (MF_EVENT_MFT_INPUT_STREAM_ID, 0xf29c2cca, 0x7ae6, 0x42d2, 0xb2, 0x84, 0xbf, 0x83, 0x7c, 0xc8, 0x74, 0xe2);
  DEFINE_GUID (MF_EVENT_MFT_CONTEXT, 0xb7cd31f1, 0x899e, 0x4b41, 0x80, 0xc9, 0x26, 0xa8, 0x96, 0xd3, 0x29, 0x77);
#endif
  STDAPI MFCreateSample (IMFSample **ppIMFSample);
  DEFINE_GUID (MFSampleExtension_CleanPoint, 0x9cdf01d8, 0xa0f0, 0x43ba, 0xb0, 0x77, 0xea, 0xa0, 0x6c, 0xbd, 0x72, 0x8a);
  DEFINE_GUID (MFSampleExtension_Discontinuity, 0x9cdf01d9, 0xa0f0, 0x43ba, 0xb0, 0x77, 0xea, 0xa0, 0x6c, 0xbd, 0x72, 0x8a);
  DEFINE_GUID (MFSampleExtension_Token, 0x8294da66, 0xf328, 0x4805, 0xb5, 0x51, 0x00, 0xde, 0xb4, 0xc5, 0x7a, 0x61);
  DEFINE_GUID (MFSampleExtension_DecodeTimestamp, 0x73a954d4, 0x9e2, 0x4861, 0xbe, 0xfc, 0x94, 0xbd, 0x97, 0xc0, 0x8e, 0x6e);
  DEFINE_GUID (MFSampleExtension_VideoEncodeQP, 0xb2efe478, 0xf979, 0x4c66, 0xb9, 0x5e, 0xee, 0x2b, 0x82, 0xc8, 0x2f, 0x36);
  DEFINE_GUID (MFSampleExtension_VideoEncodePictureType, 0x973704e6, 0xcd14, 0x483c, 0x8f, 0x20, 0xc9, 0xfc, 0x9, 0x28, 0xba, 0xd5);
  DEFINE_GUID (MFSampleExtension_FrameCorruption, 0xb4dd4a8c, 0xbeb, 0x44c4, 0x8b, 0x75, 0xb0, 0x2b, 0x91, 0x3b, 0x4, 0xf0);
  DEFINE_GUID (MFSampleExtension_DescrambleData, 0x43483be6, 0x4903, 0x4314, 0xb0, 0x32, 0x29, 0x51, 0x36, 0x59, 0x36, 0xfc);
  DEFINE_GUID (MFSampleExtension_SampleKeyID, 0x9ed713c8, 0x9b87, 0x4b26, 0x82, 0x97, 0xa9, 0x3b, 0x0c, 0x5a, 0x8a, 0xcc);
  DEFINE_GUID (MFSampleExtension_GenKeyFunc, 0x441ca1ee, 0x6b1f, 0x4501, 0x90, 0x3a, 0xde, 0x87, 0xdf, 0x42, 0xf6, 0xed);
  DEFINE_GUID (MFSampleExtension_GenKeyCtx, 0x188120cb, 0xd7da, 0x4b59, 0x9b, 0x3e, 0x92, 0x52, 0xfd, 0x37, 0x30, 0x1c);
  DEFINE_GUID (MFSampleExtension_PacketCrossOffsets, 0x2789671d, 0x389f, 0x40bb, 0x90, 0xd9, 0xc2, 0x82, 0xf7, 0x7f, 0x9a, 0xbd);
  DEFINE_GUID (MFSampleExtension_Encryption_SampleID, 0x6698b84e, 0x0afa, 0x4330, 0xae, 0xb2, 0x1c, 0x0a, 0x98, 0xd7, 0xa4, 0x4d);
  DEFINE_GUID (MFSampleExtension_Encryption_KeyID, 0x76376591, 0x795f, 0x4da1, 0x86, 0xed, 0x9d, 0x46, 0xec, 0xa1, 0x09, 0xa9);
  DEFINE_GUID (MFSampleExtension_Interlaced, 0xb1d5830a, 0xdeb8, 0x40e3, 0x90, 0xfa, 0x38, 0x99, 0x43, 0x71, 0x64, 0x61);
  DEFINE_GUID (MFSampleExtension_BottomFieldFirst, 0x941ce0a3, 0x6ae3, 0x4dda, 0x9a, 0x08, 0xa6, 0x42, 0x98, 0x34, 0x06, 0x17);
  DEFINE_GUID (MFSampleExtension_RepeatFirstField, 0x304d257c, 0x7493, 0x4fbd, 0xb1, 0x49, 0x92, 0x28, 0xde, 0x8d, 0x9a, 0x99);
  DEFINE_GUID (MFSampleExtension_SingleField, 0x9d85f816, 0x658b, 0x455a, 0xbd, 0xe0, 0x9f, 0xa7, 0xe1, 0x5a, 0xb8, 0xf9);
  DEFINE_GUID (MFSampleExtension_DerivedFromTopField, 0x6852465a, 0xae1c, 0x4553, 0x8e, 0x9b, 0xc3, 0x42, 0x0f, 0xcb, 0x16, 0x37);

  STDAPI MFCreateAttributes (IMFAttributes **ppMFAttributes, UINT32 cInitialSize);
  STDAPI MFInitAttributesFromBlob (IMFAttributes *pAttributes, const UINT8 *pBuf, UINT cbBufSize);
  STDAPI MFGetAttributesAsBlobSize (IMFAttributes *pAttributes, UINT32 *pcbBufSize);
  STDAPI MFGetAttributesAsBlob (IMFAttributes *pAttributes, UINT8 *pBuf, UINT cbBufSize);

#ifdef MF_INIT_GUIDS
#include <initguid.h>
#endif

  DEFINE_GUID (MFT_CATEGORY_VIDEO_DECODER, 0xd6c02d4b, 0x6833, 0x45b4, 0x97, 0x1a, 0x05, 0xa4, 0xb0, 0x4b, 0xab, 0x91);
  DEFINE_GUID (MFT_CATEGORY_VIDEO_ENCODER, 0xf79eac7d, 0xe545, 0x4387, 0xbd, 0xee, 0xd6, 0x47, 0xd7, 0xbd, 0xe4, 0x2a);
  DEFINE_GUID (MFT_CATEGORY_VIDEO_EFFECT, 0x12e17c21, 0x532c, 0x4a6e, 0x8a, 0x1c, 0x40, 0x82, 0x5a, 0x73, 0x63, 0x97);
  DEFINE_GUID (MFT_CATEGORY_MULTIPLEXER, 0x059c561e, 0x05ae, 0x4b61, 0xb6, 0x9d, 0x55, 0xb6, 0x1e, 0xe5, 0x4a, 0x7b);
  DEFINE_GUID (MFT_CATEGORY_DEMULTIPLEXER, 0xa8700a7a, 0x939b, 0x44c5, 0x99, 0xd7, 0x76, 0x22, 0x6b, 0x23, 0xb3, 0xf1);
  DEFINE_GUID (MFT_CATEGORY_AUDIO_DECODER, 0x9ea73fb4, 0xef7a, 0x4559, 0x8d, 0x5d, 0x71, 0x9d, 0x8f, 0x04, 0x26, 0xc7);
  DEFINE_GUID (MFT_CATEGORY_AUDIO_ENCODER, 0x91c64bd0, 0xf91e, 0x4d8c, 0x92, 0x76, 0xdb, 0x24, 0x82, 0x79, 0xd9, 0x75);
  DEFINE_GUID (MFT_CATEGORY_AUDIO_EFFECT, 0x11064c48, 0x3648, 0x4ed0, 0x93, 0x2e, 0x05, 0xce, 0x8a, 0xc8, 0x11, 0xb7);
  DEFINE_GUID (MFT_CATEGORY_OTHER, 0x90175d57, 0xb7ea, 0x4901, 0xae, 0xb3, 0x93, 0x3a, 0x87, 0x47, 0x75, 0x6f);
#if WINVER >= 0x0601
  DEFINE_GUID (MFT_CATEGORY_VIDEO_PROCESSOR, 0x302ea3fc, 0xaa5f, 0x47f9, 0x9f, 0x7a, 0xc2, 0x18, 0x8b, 0xb1, 0x63, 0x2);
#endif
#endif

#if WINAPI_FAMILY_PARTITION (WINAPI_PARTITION_DESKTOP)
#if WINVER >= 0x0601
  enum _MFT_ENUM_FLAG {
    MFT_ENUM_FLAG_SYNCMFT = 0x00000001,
    MFT_ENUM_FLAG_ASYNCMFT = 0x00000002,
    MFT_ENUM_FLAG_HARDWARE = 0x00000004,
    MFT_ENUM_FLAG_FIELDOFUSE = 0x00000008,
    MFT_ENUM_FLAG_LOCALMFT = 0x00000010,
    MFT_ENUM_FLAG_TRANSCODE_ONLY = 0x00000020,
    MFT_ENUM_FLAG_SORTANDFILTER = 0x00000040,
    MFT_ENUM_FLAG_SORTANDFILTER_APPROVED_ONLY = 0x000000c0,
    MFT_ENUM_FLAG_SORTANDFILTER_WEB_ONLY = 0x00000140,
    MFT_ENUM_FLAG_ALL = 0x0000003f
  };
#endif

  STDAPI MFTRegister (CLSID clsidMFT, GUID guidCategory, LPWSTR pszName, UINT32 Flags, UINT32 cInputTypes, MFT_REGISTER_TYPE_INFO *pInputTypes, UINT32 cOutputTypes, MFT_REGISTER_TYPE_INFO *pOutputTypes, IMFAttributes *pAttributes);
  STDAPI MFTUnregister (CLSID clsidMFT);
  STDAPI MFTEnum (GUID guidCategory, UINT32 Flags, MFT_REGISTER_TYPE_INFO *pInputType, MFT_REGISTER_TYPE_INFO *pOutputType, IMFAttributes *pAttributes, CLSID **ppclsidMFT, UINT32 *pcMFTs);
  STDAPI MFTGetInfo (CLSID clsidMFT, LPWSTR *pszName, MFT_REGISTER_TYPE_INFO **ppInputTypes, UINT32 *pcInputTypes, MFT_REGISTER_TYPE_INFO **ppOutputTypes, UINT32 *pcOutputTypes, IMFAttributes **ppAttributes);
#if WINVER >= 0x0601
  STDAPI MFTRegisterLocal (IClassFactory *pClassFactory, REFGUID guidCategory, LPCWSTR pszName, UINT32 Flags, UINT32 cInputTypes, const MFT_REGISTER_TYPE_INFO *pInputTypes, UINT32 cOutputTypes, const MFT_REGISTER_TYPE_INFO *pOutputTypes);
  STDAPI MFTUnregisterLocal (IClassFactory *pClassFactory);
  STDAPI MFTRegisterLocalByCLSID (REFCLSID clisdMFT, REFGUID guidCategory, LPCWSTR pszName, UINT32 Flags, UINT32 cInputTypes, const MFT_REGISTER_TYPE_INFO *pInputTypes, UINT32 cOutputTypes, const MFT_REGISTER_TYPE_INFO *pOutputTypes);
  STDAPI MFTUnregisterLocalByCLSID (CLSID clsidMFT);
  STDAPI MFTEnumEx (GUID guidCategory, UINT32 Flags, const MFT_REGISTER_TYPE_INFO *pInputType, const MFT_REGISTER_TYPE_INFO *pOutputType, IMFActivate ***pppMFTActivate, UINT32 *pnumMFTActivate);
  STDAPI MFGetPluginControl (IMFPluginControl **ppPluginControl);
  STDAPI MFGetMFTMerit (IUnknown *pMFT, UINT32 cbVerifier, const BYTE *verifier, DWORD *merit);
#endif
#if WINVER >= 0x0602
  STDAPI MFRegisterLocalSchemeHandler (PCWSTR szScheme, IMFActivate *pActivate);
  STDAPI MFRegisterLocalByteStreamHandler (PCWSTR szFileExtension, PCWSTR szMimeType, IMFActivate *pActivate);
  STDAPI MFCreateMFByteStreamWrapper (IMFByteStream *pStream, IMFByteStream **ppStreamWrapper);
#endif
#endif

#if WINAPI_FAMILY_PARTITION (WINAPI_PARTITION_APP)
#if WINVER >= 0x0602
  STDAPI MFCreateMediaExtensionActivate (PCWSTR szActivatableClassId, IUnknown *pConfiguration, REFIID riid, LPVOID *ppvObject);
#endif

  DEFINE_GUID (MFT_SUPPORT_DYNAMIC_FORMAT_CHANGE, 0x53476a11, 0x3f13, 0x49fb, 0xac, 0x42, 0xee, 0x27, 0x33, 0xc9, 0x67, 0x41);

#ifndef FCC
#define FCC(ch4) ((((DWORD) (ch4) &0xff) << 24) | (((DWORD) (ch4) &0xff00) << 8) | (((DWORD) (ch4) &0xff0000) >> 8) | (((DWORD) (ch4) &0xff000000) >> 24))
#endif

#ifndef DEFINE_MEDIATYPE_GUID
#define DEFINE_MEDIATYPE_GUID(name, format) DEFINE_GUID (name, format, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71);
#endif

#ifndef DIRECT3D_VERSION
#define D3DFMT_R8G8B8 20
#define D3DFMT_A8R8G8B8 21
#define D3DFMT_X8R8G8B8 22
#define D3DFMT_R5G6B5 23
#define D3DFMT_X1R5G5B5 24
#define D3DFMT_P8 41
#define LOCAL_D3DFMT_DEFINES 1
#endif

  DEFINE_MEDIATYPE_GUID (MFVideoFormat_Base, 0x00000000);
  DEFINE_MEDIATYPE_GUID (MFVideoFormat_RGB32, D3DFMT_X8R8G8B8);
  DEFINE_MEDIATYPE_GUID (MFVideoFormat_ARGB32, D3DFMT_A8R8G8B8);
  DEFINE_MEDIATYPE_GUID (MFVideoFormat_RGB24, D3DFMT_R8G8B8);
  DEFINE_MEDIATYPE_GUID (MFVideoFormat_RGB555, D3DFMT_X1R5G5B5);
  DEFINE_MEDIATYPE_GUID (MFVideoFormat_RGB565, D3DFMT_R5G6B5);
  DEFINE_MEDIATYPE_GUID (MFVideoFormat_RGB8, D3DFMT_P8);
  DEFINE_MEDIATYPE_GUID (MFVideoFormat_AI44, FCC ('AI44'));
  DEFINE_MEDIATYPE_GUID (MFVideoFormat_AYUV, FCC ('AYUV'));
  DEFINE_MEDIATYPE_GUID (MFVideoFormat_YUY2, FCC ('YUY2'));
  DEFINE_MEDIATYPE_GUID (MFVideoFormat_YVYU, FCC ('YVYU'));
  DEFINE_MEDIATYPE_GUID (MFVideoFormat_YVU9, FCC ('YVU9'));
  DEFINE_MEDIATYPE_GUID (MFVideoFormat_UYVY, FCC ('UYVY'));
  DEFINE_MEDIATYPE_GUID (MFVideoFormat_NV11, FCC ('NV11'));
  DEFINE_MEDIATYPE_GUID (MFVideoFormat_NV12, FCC ('NV12'));
  DEFINE_MEDIATYPE_GUID (MFVideoFormat_YV12, FCC ('YV12'));
  DEFINE_MEDIATYPE_GUID (MFVideoFormat_I420, FCC ('I420'));
  DEFINE_MEDIATYPE_GUID (MFVideoFormat_IYUV, FCC ('IYUV'));
  DEFINE_MEDIATYPE_GUID (MFVideoFormat_Y210, FCC ('Y210'));
  DEFINE_MEDIATYPE_GUID (MFVideoFormat_Y216, FCC ('Y216'));
  DEFINE_MEDIATYPE_GUID (MFVideoFormat_Y410, FCC ('Y410'));
  DEFINE_MEDIATYPE_GUID (MFVideoFormat_Y416, FCC ('Y416'));
  DEFINE_MEDIATYPE_GUID (MFVideoFormat_Y41P, FCC ('Y41P'));
  DEFINE_MEDIATYPE_GUID (MFVideoFormat_Y41T, FCC ('Y41T'));
  DEFINE_MEDIATYPE_GUID (MFVideoFormat_Y42T, FCC ('Y42T'));
  DEFINE_MEDIATYPE_GUID (MFVideoFormat_P210, FCC ('P210'));
  DEFINE_MEDIATYPE_GUID (MFVideoFormat_P216, FCC ('P216'));
  DEFINE_MEDIATYPE_GUID (MFVideoFormat_P010, FCC ('P010'));
  DEFINE_MEDIATYPE_GUID (MFVideoFormat_P016, FCC ('P016'));
  DEFINE_MEDIATYPE_GUID (MFVideoFormat_v210, FCC ('v210'));
  DEFINE_MEDIATYPE_GUID (MFVideoFormat_v216, FCC ('v216'));
  DEFINE_MEDIATYPE_GUID (MFVideoFormat_v410, FCC ('v410'));
  DEFINE_MEDIATYPE_GUID (MFVideoFormat_MP43, FCC ('MP43'));
  DEFINE_MEDIATYPE_GUID (MFVideoFormat_MP4S, FCC ('MP4S'));
  DEFINE_MEDIATYPE_GUID (MFVideoFormat_M4S2, FCC ('M4S2'));
  DEFINE_MEDIATYPE_GUID (MFVideoFormat_MP4V, FCC ('MP4V'));
  DEFINE_MEDIATYPE_GUID (MFVideoFormat_WMV1, FCC ('WMV1'));
  DEFINE_MEDIATYPE_GUID (MFVideoFormat_WMV2, FCC ('WMV2'));
  DEFINE_MEDIATYPE_GUID (MFVideoFormat_WMV3, FCC ('WMV3'));
  DEFINE_MEDIATYPE_GUID (MFVideoFormat_WVC1, FCC ('WVC1'));
  DEFINE_MEDIATYPE_GUID (MFVideoFormat_MSS1, FCC ('MSS1'));
  DEFINE_MEDIATYPE_GUID (MFVideoFormat_MSS2, FCC ('MSS2'));
  DEFINE_MEDIATYPE_GUID (MFVideoFormat_MPG1, FCC ('MPG1'));
  DEFINE_MEDIATYPE_GUID (MFVideoFormat_DVSL, FCC ('dvsl'));
  DEFINE_MEDIATYPE_GUID (MFVideoFormat_DVSD, FCC ('dvsd'));
  DEFINE_MEDIATYPE_GUID (MFVideoFormat_DVHD, FCC ('dvhd'));
  DEFINE_MEDIATYPE_GUID (MFVideoFormat_DV25, FCC ('dv25'));
  DEFINE_MEDIATYPE_GUID (MFVideoFormat_DV50, FCC ('dv50'));
  DEFINE_MEDIATYPE_GUID (MFVideoFormat_DVH1, FCC ('dvh1'));
  DEFINE_MEDIATYPE_GUID (MFVideoFormat_DVC, FCC ('dvc '));
  DEFINE_MEDIATYPE_GUID (MFVideoFormat_H264, FCC ('H264'));
  DEFINE_MEDIATYPE_GUID (MFVideoFormat_H265, FCC ('H265'));
  DEFINE_MEDIATYPE_GUID (MFVideoFormat_MJPG, FCC ('MJPG'));
  DEFINE_MEDIATYPE_GUID (MFVideoFormat_420O, FCC ('420O'));
  DEFINE_MEDIATYPE_GUID (MFVideoFormat_HEVC, FCC ('HEVC'));
  DEFINE_MEDIATYPE_GUID (MFVideoFormat_HEVC_ES, FCC('HEVS'));
  DEFINE_MEDIATYPE_GUID (MFVideoFormat_VP80, FCC ('VP80'));
  DEFINE_MEDIATYPE_GUID (MFVideoFormat_VP90, FCC ('VP90'));
#if WINVER >= 0x0602
  DEFINE_MEDIATYPE_GUID (MFVideoFormat_H263, FCC ('H263'));
#endif

#ifdef LOCAL_D3DFMT_DEFINES
#undef D3DFMT_R8G8B8
#undef D3DFMT_A8R8G8B8
#undef D3DFMT_X8R8G8B8
#undef D3DFMT_R5G6B5
#undef D3DFMT_X1R5G5B5
#undef D3DFMT_P8
#undef LOCAL_D3DFMT_DEFINES
#endif

#if WINVER >= 0x0602
  typedef enum _MFVideo3DFormat {
    MFVideo3DSampleFormat_BaseView = 0,
    MFVideo3DSampleFormat_MultiView = 1,
    MFVideo3DSampleFormat_Packed_LeftRight = 2,
    MFVideo3DSampleFormat_Packed_TopBottom = 3,
  } MFVideo3DFormat;

  typedef enum _MFVideo3DSampleFormat {
    MFSampleExtension_3DVideo_MultiView = 1,
    MFSampleExtension_3DVideo_Packed = 0,
  } MFVideo3DSampleFormat;

  typedef enum _MFVideoRotationFormat {
    MFVideoRotationFormat_0 = 0,
    MFVideoRotationFormat_90 = 90,
    MFVideoRotationFormat_180 = 180,
    MFVideoRotationFormat_270 = 270,
  } MFVideoRotationFormat;
#endif

  typedef enum _MFVideoDRMFlags {
    MFVideoDRMFlag_None = 0,
    MFVideoDRMFlag_AnalogProtected = 1,
    MFVideoDRMFlag_DigitallyProtected = 2,
  } MFVideoDRMFlags;

  typedef enum _MFVideoPadFlags {
    MFVideoPadFlag_PAD_TO_None = 0,
    MFVideoPadFlag_PAD_TO_4x3 = 1,
    MFVideoPadFlag_PAD_TO_16x9 = 2
  } MFVideoPadFlags;

  typedef enum _MFVideoSrcContentHintFlags {
    MFVideoSrcContentHintFlag_None = 0,
    MFVideoSrcContentHintFlag_16x9 = 1,
    MFVideoSrcContentHintFlag_235_1 = 2
  } MFVideoSrcContentHintFlags;

  typedef struct _MFFOLDDOWN_MATRIX {
    UINT32 cbSize;
    UINT32 cSrcChannels;
    UINT32 cDstChannels;
    UINT32 dwChannelMask;
    LONG Coeff[64];
  } MFFOLDDOWN_MATRIX;

#define MFVideoFormat_MPG2 MFVideoFormat_MPEG2

  DEFINE_GUID (MFVideoFormat_H264_ES, 0x3f40f4f0, 0x5622, 0x4ff8, 0xb6, 0xd8, 0xa1, 0x7a, 0x58, 0x4b, 0xee, 0x5e);
  DEFINE_GUID (MFVideoFormat_MPEG2, 0xe06d8026, 0xdb46, 0x11cf, 0xb4, 0xd1, 0x00, 0x80, 0x5f, 0x6c, 0xbb, 0xea);
  DEFINE_MEDIATYPE_GUID (MFAudioFormat_Base, 0x00000000);
  DEFINE_MEDIATYPE_GUID (MFAudioFormat_PCM, WAVE_FORMAT_PCM);
  DEFINE_MEDIATYPE_GUID (MFAudioFormat_Float, WAVE_FORMAT_IEEE_FLOAT);
  DEFINE_MEDIATYPE_GUID (MFAudioFormat_DTS, WAVE_FORMAT_DTS);
  DEFINE_MEDIATYPE_GUID (MFAudioFormat_Dolby_AC3_SPDIF, WAVE_FORMAT_DOLBY_AC3_SPDIF);
  DEFINE_MEDIATYPE_GUID (MFAudioFormat_DRM, WAVE_FORMAT_DRM);
  DEFINE_MEDIATYPE_GUID (MFAudioFormat_WMAudioV8, WAVE_FORMAT_WMAUDIO2);
  DEFINE_MEDIATYPE_GUID (MFAudioFormat_WMAudioV9, WAVE_FORMAT_WMAUDIO3);
  DEFINE_MEDIATYPE_GUID (MFAudioFormat_WMAudio_Lossless, WAVE_FORMAT_WMAUDIO_LOSSLESS);
  DEFINE_MEDIATYPE_GUID (MFAudioFormat_WMASPDIF, WAVE_FORMAT_WMASPDIF);
  DEFINE_MEDIATYPE_GUID (MFAudioFormat_MSP1, WAVE_FORMAT_WMAVOICE9);
  DEFINE_MEDIATYPE_GUID (MFAudioFormat_MP3, WAVE_FORMAT_MPEGLAYER3);
  DEFINE_MEDIATYPE_GUID (MFAudioFormat_MPEG, WAVE_FORMAT_MPEG);
  DEFINE_MEDIATYPE_GUID (MFAudioFormat_AAC, WAVE_FORMAT_MPEG_HEAAC);
  DEFINE_MEDIATYPE_GUID (MFAudioFormat_ADTS, WAVE_FORMAT_MPEG_ADTS_AAC);
  DEFINE_GUID (MFAudioFormat_Dolby_AC3, 0xe06d802c, 0xdb46, 0x11cf, 0xb4, 0xd1, 0x00, 0x80, 0x05f, 0x6c, 0xbb, 0xea);
  DEFINE_GUID (MFAudioFormat_Dolby_DDPlus, 0xa7fb87af, 0x2d02, 0x42fb, 0xa4, 0xd4, 0x5, 0xcd, 0x93, 0x84, 0x3b, 0xdd);
  DEFINE_GUID (MFMPEG4Format_Base, 0x00000000, 0x767a, 0x494d, 0xb4, 0x78, 0xf2, 0x9d, 0x25, 0xdc, 0x90, 0x37);
  DEFINE_GUID (MF_MT_MAJOR_TYPE, 0x48eba18e, 0xf8c9, 0x4687, 0xbf, 0x11, 0x0a, 0x74, 0xc9, 0xf9, 0x6a, 0x8f);
  DEFINE_GUID (MF_MT_SUBTYPE, 0xf7e34c9a, 0x42e8, 0x4714, 0xb7, 0x4b, 0xcb, 0x29, 0xd7, 0x2c, 0x35, 0xe5);
  DEFINE_GUID (MF_MT_ALL_SAMPLES_INDEPENDENT, 0xc9173739, 0x5e56, 0x461c, 0xb7, 0x13, 0x46, 0xfb, 0x99, 0x5c, 0xb9, 0x5f);
  DEFINE_GUID (MF_MT_FIXED_SIZE_SAMPLES, 0xb8ebefaf, 0xb718, 0x4e04, 0xb0, 0xa9, 0x11, 0x67, 0x75, 0xe3, 0x32, 0x1b);
  DEFINE_GUID (MF_MT_COMPRESSED, 0x3afd0cee, 0x18f2, 0x4ba5, 0xa1, 0x10, 0x8b, 0xea, 0x50, 0x2e, 0x1f, 0x92);
  DEFINE_GUID (MF_MT_SAMPLE_SIZE, 0xdad3ab78, 0x1990, 0x408b, 0xbc, 0xe2, 0xeb, 0xa6, 0x73, 0xda, 0xcc, 0x10);
  DEFINE_GUID (MF_MT_WRAPPED_TYPE, 0x4d3f7b23, 0xd02f, 0x4e6c, 0x9b, 0xee, 0xe4, 0xbf, 0x2c, 0x6c, 0x69, 0x5d);
  DEFINE_GUID (MF_MT_AUDIO_NUM_CHANNELS, 0x37e48bf5, 0x645e, 0x4c5b, 0x89, 0xde, 0xad, 0xa9, 0xe2, 0x9b, 0x69, 0x6a);
  DEFINE_GUID (MF_MT_AUDIO_SAMPLES_PER_SECOND, 0x5faeeae7, 0x0290, 0x4c31, 0x9e, 0x8a, 0xc5, 0x34, 0xf6, 0x8d, 0x9d, 0xba);
  DEFINE_GUID (MF_MT_AUDIO_FLOAT_SAMPLES_PER_SECOND, 0xfb3b724a, 0xcfb5, 0x4319, 0xae, 0xfe, 0x6e, 0x42, 0xb2, 0x40, 0x61, 0x32);
  DEFINE_GUID (MF_MT_AUDIO_AVG_BYTES_PER_SECOND, 0x1aab75c8, 0xcfef, 0x451c, 0xab, 0x95, 0xac, 0x03, 0x4b, 0x8e, 0x17, 0x31);
  DEFINE_GUID (MF_MT_AUDIO_BLOCK_ALIGNMENT, 0x322de230, 0x9eeb, 0x43bd, 0xab, 0x7a, 0xff, 0x41, 0x22, 0x51, 0x54, 0x1d);
  DEFINE_GUID (MF_MT_AUDIO_BITS_PER_SAMPLE, 0xf2deb57f, 0x40fa, 0x4764, 0xaa, 0x33, 0xed, 0x4f, 0x2d, 0x1f, 0xf6, 0x69);
  DEFINE_GUID (MF_MT_AUDIO_VALID_BITS_PER_SAMPLE, 0xd9bf8d6a, 0x9530, 0x4b7c, 0x9d, 0xdf, 0xff, 0x6f, 0xd5, 0x8b, 0xbd, 0x06);
  DEFINE_GUID (MF_MT_AUDIO_SAMPLES_PER_BLOCK, 0xaab15aac, 0xe13a, 0x4995, 0x92, 0x22, 0x50, 0x1e, 0xa1, 0x5c, 0x68, 0x77);
  DEFINE_GUID (MF_MT_AUDIO_CHANNEL_MASK, 0x55fb5765, 0x644a, 0x4caf, 0x84, 0x79, 0x93, 0x89, 0x83, 0xbb, 0x15, 0x88);
  DEFINE_GUID (MF_MT_AUDIO_FOLDDOWN_MATRIX, 0x9d62927c, 0x36be, 0x4cf2, 0xb5, 0xc4, 0xa3, 0x92, 0x6e, 0x3e, 0x87, 0x11);
  DEFINE_GUID (MF_MT_AUDIO_WMADRC_PEAKREF, 0x9d62927d, 0x36be, 0x4cf2, 0xb5, 0xc4, 0xa3, 0x92, 0x6e, 0x3e, 0x87, 0x11);
  DEFINE_GUID (MF_MT_AUDIO_WMADRC_PEAKTARGET, 0x9d62927e, 0x36be, 0x4cf2, 0xb5, 0xc4, 0xa3, 0x92, 0x6e, 0x3e, 0x87, 0x11);
  DEFINE_GUID (MF_MT_AUDIO_WMADRC_AVGREF, 0x9d62927f, 0x36be, 0x4cf2, 0xb5, 0xc4, 0xa3, 0x92, 0x6e, 0x3e, 0x87, 0x11);
  DEFINE_GUID (MF_MT_AUDIO_WMADRC_AVGTARGET, 0x9d629280, 0x36be, 0x4cf2, 0xb5, 0xc4, 0xa3, 0x92, 0x6e, 0x3e, 0x87, 0x11);
  DEFINE_GUID (MF_MT_AUDIO_PREFER_WAVEFORMATEX, 0xa901aaba, 0xe037, 0x458a, 0xbd, 0xf6, 0x54, 0x5b, 0xe2, 0x07, 0x40, 0x42);
  DEFINE_GUID (MF_MT_FRAME_SIZE, 0x1652c33d, 0xd6b2, 0x4012, 0xb8, 0x34, 0x72, 0x03, 0x08, 0x49, 0xa3, 0x7d);
  DEFINE_GUID (MF_MT_FRAME_RATE, 0xc459a2e8, 0x3d2c, 0x4e44, 0xb1, 0x32, 0xfe, 0xe5, 0x15, 0x6c, 0x7b, 0xb0);
  DEFINE_GUID (MF_MT_PIXEL_ASPECT_RATIO, 0xc6376a1e, 0x8d0a, 0x4027, 0xbe, 0x45, 0x6d, 0x9a, 0x0a, 0xd3, 0x9b, 0xb6);
  DEFINE_GUID (MF_MT_DRM_FLAGS, 0x8772f323, 0x355a, 0x4cc7, 0xbb, 0x78, 0x6d, 0x61, 0xa0, 0x48, 0xae, 0x82);
  DEFINE_GUID (MF_MT_PAD_CONTROL_FLAGS, 0x4d0e73e5, 0x80ea, 0x4354, 0xa9, 0xd0, 0x11, 0x76, 0xce, 0xb0, 0x28, 0xea);
  DEFINE_GUID (MF_MT_SOURCE_CONTENT_HINT, 0x68aca3cc, 0x22d0, 0x44e6, 0x85, 0xf8, 0x28, 0x16, 0x71, 0x97, 0xfa, 0x38);
  DEFINE_GUID (MF_MT_VIDEO_CHROMA_SITING, 0x65df2370, 0xc773, 0x4c33, 0xaa, 0x64, 0x84, 0x3e, 0x06, 0x8e, 0xfb, 0x0c);
  DEFINE_GUID (MF_MT_INTERLACE_MODE, 0xe2724bb8, 0xe676, 0x4806, 0xb4, 0xb2, 0xa8, 0xd6, 0xef, 0xb4, 0x4c, 0xcd);
  DEFINE_GUID (MF_MT_TRANSFER_FUNCTION, 0x5fb0fce9, 0xbe5c, 0x4935, 0xa8, 0x11, 0xec, 0x83, 0x8f, 0x8e, 0xed, 0x93);
  DEFINE_GUID (MF_MT_VIDEO_PRIMARIES, 0xdbfbe4d7, 0x0740, 0x4ee0, 0x81, 0x92, 0x85, 0x0a, 0xb0, 0xe2, 0x19, 0x35);
  DEFINE_GUID (MF_MT_YUV_MATRIX, 0x3e23d450, 0x2c75, 0x4d25, 0xa0, 0x0e, 0xb9, 0x16, 0x70, 0xd1, 0x23, 0x27);
  DEFINE_GUID (MF_MT_VIDEO_LIGHTING, 0x53a0529c, 0x890b, 0x4216, 0x8b, 0xf9, 0x59, 0x93, 0x67, 0xad, 0x6d, 0x20);
  DEFINE_GUID (MF_MT_VIDEO_NOMINAL_RANGE, 0xc21b8ee5, 0xb956, 0x4071, 0x8d, 0xaf, 0x32, 0x5e, 0xdf, 0x5c, 0xab, 0x11);
  DEFINE_GUID (MF_MT_GEOMETRIC_APERTURE, 0x66758743, 0x7e5f, 0x400d, 0x98, 0x0a, 0xaa, 0x85, 0x96, 0xc8, 0x56, 0x96);
  DEFINE_GUID (MF_MT_MINIMUM_DISPLAY_APERTURE, 0xd7388766, 0x18fe, 0x48c6, 0xa1, 0x77, 0xee, 0x89, 0x48, 0x67, 0xc8, 0xc4);
  DEFINE_GUID (MF_MT_PAN_SCAN_APERTURE, 0x79614dde, 0x9187, 0x48fb, 0xb8, 0xc7, 0x4d, 0x52, 0x68, 0x9d, 0xe6, 0x49);
  DEFINE_GUID (MF_MT_PAN_SCAN_ENABLED, 0x4b7f6bc3, 0x8b13, 0x40b2, 0xa9, 0x93, 0xab, 0xf6, 0x30, 0xb8, 0x20, 0x4e);
  DEFINE_GUID (MF_MT_AVG_BITRATE, 0x20332624, 0xfb0d, 0x4d9e, 0xbd, 0x0d, 0xcb, 0xf6, 0x78, 0x6c, 0x10, 0x2e);
  DEFINE_GUID (MF_MT_AVG_BIT_ERROR_RATE, 0x799cabd6, 0x3508, 0x4db4, 0xa3, 0xc7, 0x56, 0x9c, 0xd5, 0x33, 0xde, 0xb1);
  DEFINE_GUID (MF_MT_MAX_KEYFRAME_SPACING, 0xc16eb52b, 0x73a1, 0x476f, 0x8d, 0x62, 0x83, 0x9d, 0x6a, 0x02, 0x06, 0x52);
  DEFINE_GUID (MF_MT_USER_DATA, 0xb6bc765f, 0x4c3b, 0x40a4, 0xbd, 0x51, 0x25, 0x35, 0xb6, 0x6f, 0xe0, 0x9d);
  DEFINE_GUID (MF_MT_DEFAULT_STRIDE, 0x644b4e48, 0x1e02, 0x4516, 0xb0, 0xeb, 0xc0, 0x1c, 0xa9, 0xd4, 0x9a, 0xc6);
  DEFINE_GUID (MF_MT_PALETTE, 0x6d283f42, 0x9846, 0x4410, 0xaf, 0xd9, 0x65, 0x4d, 0x50, 0x3b, 0x1a, 0x54);
  DEFINE_GUID (MF_MT_MPEG_START_TIME_CODE, 0x91f67885, 0x4333, 0x4280, 0x97, 0xcd, 0xbd, 0x5a, 0x6c, 0x03, 0xa0, 0x6e);
  DEFINE_GUID (MF_MT_MPEG2_PROFILE, 0xad76a80b, 0x2d5c, 0x4e0b, 0xb3, 0x75, 0x64, 0xe5, 0x20, 0x13, 0x70, 0x36);
  DEFINE_GUID (MF_MT_MPEG2_LEVEL, 0x96f66574, 0x11c5, 0x4015, 0x86, 0x66, 0xbf, 0xf5, 0x16, 0x43, 0x6d, 0xa7);
  DEFINE_GUID (MF_MT_MPEG2_FLAGS, 0x31e3991d, 0xf701, 0x4b2f, 0xb4, 0x26, 0x8a, 0xe3, 0xbd, 0xa9, 0xe0, 0x4b);
  DEFINE_GUID (MF_MT_MPEG_SEQUENCE_HEADER, 0x3c036de7, 0x3ad0, 0x4c9e, 0x92, 0x16, 0xee, 0x6d, 0x6a, 0xc2, 0x1c, 0xb3);
  DEFINE_GUID (MF_MT_MPEG2_STANDARD, 0xa20af9e8, 0x928a, 0x4b26, 0xaa, 0xa9, 0xf0, 0x5c, 0x74, 0xca, 0xc4, 0x7c);
  DEFINE_GUID (MF_MT_MPEG2_TIMECODE, 0x5229ba10, 0xe29d, 0x4f80, 0xa5, 0x9c, 0xdf, 0x4f, 0x18, 0x2, 0x7, 0xd2);
  DEFINE_GUID (MF_MT_MPEG2_CONTENT_PACKET, 0x825d55e4, 0x4f12, 0x4197, 0x9e, 0xb3, 0x59, 0xb6, 0xe4, 0x71, 0xf, 0x6);
  DEFINE_GUID (MF_MT_H264_MAX_CODEC_CONFIG_DELAY, 0xf5929986, 0x4c45, 0x4fbb, 0xbb, 0x49, 0x6c, 0xc5, 0x34, 0xd0, 0x5b, 0x9b);
  DEFINE_GUID (MF_MT_H264_SUPPORTED_SLICE_MODES, 0xc8be1937, 0x4d64, 0x4549, 0x83, 0x43, 0xa8, 0x8, 0x6c, 0xb, 0xfd, 0xa5);
  DEFINE_GUID (MF_MT_H264_SUPPORTED_SYNC_FRAME_TYPES, 0x89a52c01, 0xf282, 0x48d2, 0xb5, 0x22, 0x22, 0xe6, 0xae, 0x63, 0x31, 0x99);
  DEFINE_GUID (MF_MT_H264_RESOLUTION_SCALING, 0xe3854272, 0xf715, 0x4757, 0xba, 0x90, 0x1b, 0x69, 0x6c, 0x77, 0x34, 0x57);
  DEFINE_GUID (MF_MT_H264_SIMULCAST_SUPPORT, 0x9ea2d63d, 0x53f0, 0x4a34, 0xb9, 0x4e, 0x9d, 0xe4, 0x9a, 0x7, 0x8c, 0xb3);
  DEFINE_GUID (MF_MT_H264_SUPPORTED_RATE_CONTROL_MODES, 0x6a8ac47e, 0x519c, 0x4f18, 0x9b, 0xb3, 0x7e, 0xea, 0xae, 0xa5, 0x59, 0x4d);
  DEFINE_GUID (MF_MT_H264_MAX_MB_PER_SEC, 0x45256d30, 0x7215, 0x4576, 0x93, 0x36, 0xb0, 0xf1, 0xbc, 0xd5, 0x9b, 0xb2);
  DEFINE_GUID (MF_MT_H264_SUPPORTED_USAGES, 0x60b1a998, 0xdc01, 0x40ce, 0x97, 0x36, 0xab, 0xa8, 0x45, 0xa2, 0xdb, 0xdc);
  DEFINE_GUID (MF_MT_H264_CAPABILITIES, 0xbb3bd508, 0x490a, 0x11e0, 0x99, 0xe4, 0x13, 0x16, 0xdf, 0xd7, 0x20, 0x85);
  DEFINE_GUID (MF_MT_H264_SVC_CAPABILITIES, 0xf8993abe, 0xd937, 0x4a8f, 0xbb, 0xca, 0x69, 0x66, 0xfe, 0x9e, 0x11, 0x52);
  DEFINE_GUID (MF_MT_H264_USAGE, 0x359ce3a5, 0xaf00, 0x49ca, 0xa2, 0xf4, 0x2a, 0xc9, 0x4c, 0xa8, 0x2b, 0x61);
  DEFINE_GUID (MF_MT_H264_RATE_CONTROL_MODES, 0x705177d8, 0x45cb, 0x11e0, 0xac, 0x7d, 0xb9, 0x1c, 0xe0, 0xd7, 0x20, 0x85);
  DEFINE_GUID (MF_MT_H264_LAYOUT_PER_STREAM, 0x85e299b2, 0x90e3, 0x4fe8, 0xb2, 0xf5, 0xc0, 0x67, 0xe0, 0xbf, 0xe5, 0x7a);
  DEFINE_GUID (MF_MT_DV_AAUX_SRC_PACK_0, 0x84bd5d88, 0x0fb8, 0x4ac8, 0xbe, 0x4b, 0xa8, 0x84, 0x8b, 0xef, 0x98, 0xf3);
  DEFINE_GUID (MF_MT_DV_AAUX_CTRL_PACK_0, 0xf731004e, 0x1dd1, 0x4515, 0xaa, 0xbe, 0xf0, 0xc0, 0x6a, 0xa5, 0x36, 0xac);
  DEFINE_GUID (MF_MT_DV_AAUX_SRC_PACK_1, 0x720e6544, 0x0225, 0x4003, 0xa6, 0x51, 0x01, 0x96, 0x56, 0x3a, 0x95, 0x8e);
  DEFINE_GUID (MF_MT_DV_AAUX_CTRL_PACK_1, 0xcd1f470d, 0x1f04, 0x4fe0, 0xbf, 0xb9, 0xd0, 0x7a, 0xe0, 0x38, 0x6a, 0xd8);
  DEFINE_GUID (MF_MT_DV_VAUX_SRC_PACK, 0x41402d9d, 0x7b57, 0x43c6, 0xb1, 0x29, 0x2c, 0xb9, 0x97, 0xf1, 0x50, 0x09);
  DEFINE_GUID (MF_MT_DV_VAUX_CTRL_PACK, 0x2f84e1c4, 0x0da1, 0x4788, 0x93, 0x8e, 0x0d, 0xfb, 0xfb, 0xb3, 0x4b, 0x48);
  DEFINE_GUID (MFMediaType_Default, 0x81a412e6, 0x8103, 0x4b06, 0x85, 0x7f, 0x18, 0x62, 0x78, 0x10, 0x24, 0xac);
  DEFINE_GUID (MFMediaType_Audio, 0x73647561, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71);
  DEFINE_GUID (MFMediaType_Video, 0x73646976, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71);
  DEFINE_GUID (MFMediaType_Protected, 0x7b4b6fe6, 0x9d04, 0x4494, 0xbe, 0x14, 0x7e, 0x0b, 0xd0, 0x76, 0xc8, 0xe4);
  DEFINE_GUID (MFMediaType_SAMI, 0xe69669a0, 0x3dcd, 0x40cb, 0x9e, 0x2e, 0x37, 0x08, 0x38, 0x7c, 0x06, 0x16);
  DEFINE_GUID (MFMediaType_Script, 0x72178c22, 0xe45b, 0x11d5, 0xbc, 0x2a, 0x00, 0xb0, 0xd0, 0xf3, 0xf4, 0xab);
  DEFINE_GUID (MFMediaType_Image, 0x72178c23, 0xe45b, 0x11d5, 0xbc, 0x2a, 0x00, 0xb0, 0xd0, 0xf3, 0xf4, 0xab);
  DEFINE_GUID (MFMediaType_HTML, 0x72178c24, 0xe45b, 0x11d5, 0xbc, 0x2a, 0x00, 0xb0, 0xd0, 0xf3, 0xf4, 0xab);
  DEFINE_GUID (MFMediaType_Binary, 0x72178c25, 0xe45b, 0x11d5, 0xbc, 0x2a, 0x00, 0xb0, 0xd0, 0xf3, 0xf4, 0xab);
  DEFINE_GUID (MFMediaType_FileTransfer, 0x72178c26, 0xe45b, 0x11d5, 0xbc, 0x2a, 0x00, 0xb0, 0xd0, 0xf3, 0xf4, 0xab);
  DEFINE_GUID (MFMediaType_Stream, 0xe436eb83, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70);
  DEFINE_GUID (MFImageFormat_JPEG, 0x19e4a5aa, 0x5662, 0x4fc5, 0xa0, 0xc0, 0x17, 0x58, 0x02, 0x8e, 0x10, 0x57);
  DEFINE_GUID (MFImageFormat_RGB32, 0x00000016, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71);
  DEFINE_GUID (MFStreamFormat_MPEG2Transport, 0xe06d8023, 0xdb46, 0x11cf, 0xb4, 0xd1, 0x00, 0x80, 0x5f, 0x6c, 0xbb, 0xea);
  DEFINE_GUID (MFStreamFormat_MPEG2Program, 0x263067d1, 0xd330, 0x45dc, 0xb6, 0x69, 0x34, 0xd9, 0x86, 0xe4, 0xe3, 0xe1);
#if WINVER >= 0x0601
  DEFINE_GUID (MF_MT_AAC_PAYLOAD_TYPE, 0xbfbabe79, 0x7434, 0x4d1c, 0x94, 0xf0, 0x72, 0xa3, 0xb9, 0xe1, 0x71, 0x88);
  DEFINE_GUID (MF_MT_AAC_AUDIO_PROFILE_LEVEL_INDICATION, 0x7632f0e6, 0x9538, 0x4d61, 0xac, 0xda, 0xea, 0x29, 0xc8, 0xc1, 0x44, 0x56);
  DEFINE_GUID (MF_MT_IMAGE_LOSS_TOLERANT, 0xed062cf4, 0xe34e, 0x4922, 0xbe, 0x99, 0x93, 0x40, 0x32, 0x13, 0x3d, 0x7c);
  DEFINE_GUID (MF_MT_MPEG4_SAMPLE_DESCRIPTION, 0x261e9d83, 0x9529, 0x4b8f, 0xa1, 0x11, 0x8b, 0x9c, 0x95, 0x0a, 0x81, 0xa9);
  DEFINE_GUID (MF_MT_MPEG4_CURRENT_SAMPLE_ENTRY, 0x9aa7e155, 0xb64a, 0x4c1d, 0xa5, 0x00, 0x45, 0x5d, 0x60, 0x0b, 0x65, 0x60);
  DEFINE_GUID (MF_MT_FRAME_RATE_RANGE_MIN, 0xd2e7558c, 0xdc1f, 0x403f, 0x9a, 0x72, 0xd2, 0x8b, 0xb1, 0xeb, 0x3b, 0x5e);
  DEFINE_GUID (MF_MT_FRAME_RATE_RANGE_MAX, 0xe3371d41, 0xb4cf, 0x4a05, 0xbd, 0x4e, 0x20, 0xb8, 0x8b, 0xb2, 0xc4, 0xd6);
#endif
#if WINVER >= 0x0602
  DEFINE_GUID (MF_MT_VIDEO_3D, 0xcb5e88cf, 0x7b5b, 0x476b, 0x85, 0xaa, 0x1c, 0xa5, 0xae, 0x18, 0x75, 0x55);
  DEFINE_GUID (MF_MT_VIDEO_3D_FORMAT, 0x5315d8a0, 0x87c5, 0x4697, 0xb7, 0x93, 0x66, 0x6, 0xc6, 0x7c, 0x4, 0x9b);
  DEFINE_GUID (MF_MT_VIDEO_3D_NUM_VIEWS, 0xbb077e8a, 0xdcbf, 0x42eb, 0xaf, 0x60, 0x41, 0x8d, 0xf9, 0x8a, 0xa4, 0x95);
  DEFINE_GUID (MF_MT_VIDEO_3D_LEFT_IS_BASE, 0x6d4b7bff, 0x5629, 0x4404, 0x94, 0x8c, 0xc6, 0x34, 0xf4, 0xce, 0x26, 0xd4);
  DEFINE_GUID (MF_MT_VIDEO_3D_FIRST_IS_LEFT, 0xec298493, 0xada, 0x4ea1, 0xa4, 0xfe, 0xcb, 0xbd, 0x36, 0xce, 0x93, 0x31);
  DEFINE_GUID (MFSampleExtension_3DVideo, 0xf86f97a4, 0xdd54, 0x4e2e, 0x9a, 0x5e, 0x55, 0xfc, 0x2d, 0x74, 0xa0, 0x05);
  DEFINE_GUID (MFSampleExtension_3DVideo_SampleFormat, 0x8671772, 0xe36f, 0x4cff, 0x97, 0xb3, 0xd7, 0x2e, 0x20, 0x98, 0x7a, 0x48);
  DEFINE_GUID (MF_MT_VIDEO_ROTATION, 0xc380465d, 0x2271, 0x428c, 0x9b, 0x83, 0xec, 0xea, 0x3b, 0x4a, 0x85, 0xc1);
  DEFINE_GUID (MF_MT_TIMESTAMP_CAN_BE_DTS, 0x24974215, 0x1b7b, 0x41e4, 0x86, 0x25, 0xac, 0x46, 0x9f, 0x2d, 0xed, 0xaa);
  DEFINE_GUID (MF_LOW_LATENCY, 0x9c27891a, 0xed7a, 0x40e1, 0x88, 0xe8, 0xb2, 0x27, 0x27, 0xa0, 0x24, 0xee);
#endif
#endif

#if WINAPI_FAMILY_PARTITION (WINAPI_PARTITION_DESKTOP)
  typedef struct _MT_CUSTOM_VIDEO_PRIMARIES {
    float fRx;
    float fRy;
    float fGx;
    float fGy;
    float fBx;
    float fBy;
    float fWx;
    float fWy;
  } MT_CUSTOM_VIDEO_PRIMARIES;

#if WINVER >= 0x0601
  typedef struct _MT_ARBITRARY_HEADER {
    GUID majortype;
    GUID subtype;
    WINBOOL bFixedSizeSamples;
    WINBOOL bTemporalCompression;
    ULONG lSampleSize;
    GUID formattype;
  } MT_ARBITRARY_HEADER;
#endif

  DEFINE_GUID (MF_MT_CUSTOM_VIDEO_PRIMARIES, 0x47537213, 0x8cfb, 0x4722, 0xaa, 0x34, 0xfb, 0xc9, 0xe2, 0x4d, 0x77, 0xb8);
  DEFINE_GUID (MF_MT_AM_FORMAT_TYPE, 0x73d1072d, 0x1870, 0x4174, 0xa0, 0x63, 0x29, 0xff, 0x4f, 0xf6, 0xc1, 0x1e);
  DEFINE_GUID (AM_MEDIA_TYPE_REPRESENTATION, 0xe2e42ad2, 0x132c, 0x491e, 0xa2, 0x68, 0x3c, 0x7c, 0x2d, 0xca, 0x18, 0x1f);
  DEFINE_GUID (FORMAT_MFVideoFormat, 0xaed4ab2d, 0x7326, 0x43cb, 0x94, 0x64, 0xc8, 0x79, 0xca, 0xb9, 0xc4, 0x3d);
#if WINVER >= 0x0601
  DEFINE_GUID (MF_MT_ARBITRARY_HEADER, 0x9e6bd6f5, 0x109, 0x4f95, 0x84, 0xac, 0x93, 0x9, 0x15, 0x3a, 0x19, 0xfc);
  DEFINE_GUID (MF_MT_ARBITRARY_FORMAT, 0x5a75b249, 0xd7d, 0x49a1, 0xa1, 0xc3, 0xe0, 0xd8, 0x7f, 0xc, 0xad, 0xe5);
  DEFINE_GUID (MF_MT_ORIGINAL_4CC, 0xd7be3fe0, 0x2bc7, 0x492d, 0xb8, 0x43, 0x61, 0xa1, 0x91, 0x9b, 0x70, 0xc3);
  DEFINE_GUID (MF_MT_ORIGINAL_WAVE_FORMAT_TAG, 0x8cbbc843, 0x9fd9, 0x49c2, 0x88, 0x2f, 0xa7, 0x25, 0x86, 0xc4, 0x08, 0xad);
#endif

  struct tagVIDEOINFOHEADER;
  struct tagVIDEOINFOHEADER2;
  struct tagMPEG2VIDEOINFO;
  struct _AMMediaType;

  typedef struct tagVIDEOINFOHEADER VIDEOINFOHEADER;
  typedef struct tagVIDEOINFOHEADER2 VIDEOINFOHEADER2;
  struct tagMPEG1VIDEOINFO;
  typedef struct tagMPEG1VIDEOINFO MPEG1VIDEOINFO;
  typedef struct tagMPEG2VIDEOINFO MPEG2VIDEOINFO;
  typedef struct _AMMediaType AM_MEDIA_TYPE;

  STDAPI MFValidateMediaTypeSize (GUID FormatType, UINT8 *pBlock, UINT32 cbSize);
  STDAPI MFCreateMFVideoFormatFromMFMediaType (IMFMediaType *pMFType, MFVIDEOFORMAT **ppMFVF, UINT32 *pcbSize);
#endif

#if WINAPI_FAMILY_PARTITION (WINAPI_PARTITION_APP)
  typedef enum _MFWaveFormatExConvertFlags {
    MFWaveFormatExConvertFlag_Normal = 0,
    MFWaveFormatExConvertFlag_ForceExtensible = 1
  } MFWaveFormatExConvertFlags;

  STDAPI MFCreateMediaType (IMFMediaType **ppMFType);
  STDAPI MFCreateWaveFormatExFromMFMediaType (IMFMediaType *pMFType, WAVEFORMATEX **ppWF, UINT32 *pcbSize, UINT32 Flags
#ifdef __cplusplus
    = MFWaveFormatExConvertFlag_Normal
#endif
    );
#endif

#if WINAPI_FAMILY_PARTITION (WINAPI_PARTITION_DESKTOP)
  STDAPI MFInitMediaTypeFromVideoInfoHeader (IMFMediaType *pMFType, const VIDEOINFOHEADER *pVIH, UINT32 cbBufSize, const GUID *pSubtype
#ifdef __cplusplus
    = NULL
#endif
    );
  STDAPI MFInitMediaTypeFromVideoInfoHeader2 (IMFMediaType *pMFType, const VIDEOINFOHEADER2 *pVIH2, UINT32 cbBufSize, const GUID *pSubtype
#ifdef __cplusplus
    = NULL
#endif
    );
  STDAPI MFInitMediaTypeFromMPEG1VideoInfo (IMFMediaType *pMFType, const MPEG1VIDEOINFO *pMP1VI, UINT32 cbBufSize, const GUID *pSubtype
#ifdef __cplusplus
    = NULL
#endif
    );
  STDAPI MFInitMediaTypeFromMPEG2VideoInfo (IMFMediaType *pMFType, const MPEG2VIDEOINFO *pMP2VI, UINT32 cbBufSize, const GUID *pSubtype
#ifdef __cplusplus
    = NULL
#endif
    );
  STDAPI MFCalculateBitmapImageSize (const BITMAPINFOHEADER *pBMIH, UINT32 cbBufSize, UINT32 *pcbImageSize, WINBOOL *pbKnown
#ifdef __cplusplus
    = NULL
#endif
    );
  STDAPI MFInitMediaTypeFromWaveFormatEx (IMFMediaType *pMFType, const WAVEFORMATEX *pWaveFormat, UINT32 cbBufSize);
  STDAPI MFWrapMediaType (IMFMediaType *pOrig, REFGUID MajorType, REFGUID SubType, IMFMediaType **ppWrap);
  STDAPI MFUnwrapMediaType (IMFMediaType *pWrap, IMFMediaType **ppOrig);
  STDAPI MFCopyImage (BYTE *pDest, LONG lDestStride, const BYTE *pSrc, LONG lSrcStride, DWORD dwWidthInBytes, DWORD dwLines);
  STDAPI MFCreate2DMediaBuffer (DWORD dwWidth, DWORD dwHeight, DWORD dwFourCC, WINBOOL fBottomUp, IMFMediaBuffer **ppBuffer);
  STDAPI MFCreateMediaBufferFromMediaType (IMFMediaType *pMediaType, LONGLONG llDuration, DWORD dwMinLength, DWORD dwMinAlignment, IMFMediaBuffer **ppBuffer);
#endif

#if WINAPI_FAMILY_PARTITION (WINAPI_PARTITION_DESKTOP)
  STDAPI MFCalculateImageSize (REFGUID guidSubtype, UINT32 unWidth, UINT32 unHeight, UINT32 *pcbImageSize);
  STDAPI MFFrameRateToAverageTimePerFrame (UINT32 unNumerator, UINT32 unDenominator, UINT64 *punAverageTimePerFrame);
  STDAPI MFAverageTimePerFrameToFrameRate (UINT64 unAverageTimePerFrame, UINT32 *punNumerator, UINT32 *punDenominator);
  STDAPI MFInitMediaTypeFromMFVideoFormat (IMFMediaType *pMFType, const MFVIDEOFORMAT *pMFVF, UINT32 cbBufSize);
  STDAPI MFInitMediaTypeFromAMMediaType (IMFMediaType *pMFType, const AM_MEDIA_TYPE *pAMType);
  STDAPI MFInitAMMediaTypeFromMFMediaType (IMFMediaType *pMFType, GUID guidFormatBlockType, AM_MEDIA_TYPE *pAMType);
  STDAPI MFCreateAMMediaTypeFromMFMediaType (IMFMediaType *pMFType, GUID guidFormatBlockType, AM_MEDIA_TYPE **ppAMType);
  STDAPI_ (WINBOOL) MFCompareFullToPartialMediaType (IMFMediaType *pMFTypeFull, IMFMediaType *pMFTypePartial);
#ifdef _KSMEDIA_
  STDAPI MFCreateVideoMediaTypeFromVideoInfoHeader (const KS_VIDEOINFOHEADER *pVideoInfoHeader, DWORD cbVideoInfoHeader, DWORD dwPixelAspectRatioX, DWORD dwPixelAspectRatioY, MFVideoInterlaceMode InterlaceMode, QWORD VideoFlags, const GUID *pSubtype, IMFVideoMediaType **ppIVideoMediaType);
  STDAPI MFCreateVideoMediaTypeFromVideoInfoHeader2 (const KS_VIDEOINFOHEADER2 *pVideoInfoHeader, DWORD cbVideoInfoHeader, QWORD AdditionalVideoFlags, const GUID *pSubtype, IMFVideoMediaType **ppIVideoMediaType);
#endif
  STDAPI MFCreateVideoMediaType (const MFVIDEOFORMAT *pVideoFormat, IMFVideoMediaType **ppIVideoMediaType);
  STDAPI MFCreateVideoMediaTypeFromSubtype (const GUID *pAMSubtype, IMFVideoMediaType **ppIVideoMediaType);
  STDAPI_ (WINBOOL) MFIsFormatYUV (DWORD Format);
  STDAPI MFCreateVideoMediaTypeFromBitMapInfoHeader (const BITMAPINFOHEADER *pbmihBitMapInfoHeader, DWORD dwPixelAspectRatioX, DWORD dwPixelAspectRatioY, MFVideoInterlaceMode InterlaceMode, QWORD VideoFlags, QWORD qwFramesPerSecondNumerator, QWORD qwFramesPerSecondDenominator, DWORD dwMaxBitRate, IMFVideoMediaType **ppIVideoMediaType);
  STDAPI MFGetStrideForBitmapInfoHeader (DWORD format, DWORD dwWidth, LONG *pStride);
  STDAPI MFGetPlaneSize (DWORD format, DWORD dwWidth, DWORD dwHeight, DWORD *pdwPlaneSize);
  STDAPI MFCreateMediaTypeFromRepresentation (GUID guidRepresentation, LPVOID pvRepresentation, IMFMediaType **ppIMediaType);
  STDAPI MFCreateAudioMediaType (const WAVEFORMATEX *pAudioFormat, IMFAudioMediaType **ppIAudioMediaType);
  DWORD STDMETHODCALLTYPE MFGetUncompressedVideoFormat (const MFVIDEOFORMAT *pVideoFormat);
  STDAPI MFInitVideoFormat (MFVIDEOFORMAT *pVideoFormat, MFStandardVideoFormat type);
  STDAPI MFInitVideoFormat_RGB (MFVIDEOFORMAT *pVideoFormat, DWORD dwWidth, DWORD dwHeight, DWORD D3Dfmt);
  STDAPI MFConvertColorInfoToDXVA (DWORD *pdwToDXVA, const MFVIDEOFORMAT *pFromFormat);
  STDAPI MFConvertColorInfoFromDXVA (MFVIDEOFORMAT *pToFormat, DWORD dwFromDXVA);
  STDAPI MFConvertFromFP16Array (float *pDest, const WORD *pSrc, DWORD dwCount);
  STDAPI MFConvertToFP16Array (WORD *pDest, const float *pSrc, DWORD dwCount);
#if WINVER >= 0x0601
  STDAPI MFCreateVideoMediaTypeFromBitMapInfoHeaderEx (const BITMAPINFOHEADER *pbmihBitMapInfoHeader, UINT32 cbBitMapInfoHeader, DWORD dwPixelAspectRatioX, DWORD dwPixelAspectRatioY, MFVideoInterlaceMode InterlaceMode, QWORD VideoFlags, DWORD dwFramesPerSecondNumerator, DWORD dwFramesPerSecondDenominator, DWORD dwMaxBitRate, IMFVideoMediaType **ppIVideoMediaType);
#endif
#endif

#if WINAPI_FAMILY_PARTITION (WINAPI_PARTITION_APP)
#ifdef __cplusplus
  inline UINT32 HI32 (UINT64 up) { return (UINT32) (up >> 32); }
  inline UINT32 LO32 (UINT64 up) { return (UINT32) up; }
  inline UINT64 Pack2UINT32AsUINT64 (UINT32 uh, UINT32 ul) { return (((UINT64) uh) << 32) | ((UINT64) ul); }
  inline void Unpack2UINT32AsUINT64 (UINT64 up, UINT32 *puh, UINT32 *pul) { *puh = HI32 (up); *pul = LO32 (up); }
  inline UINT64 PackSize (UINT32 uw, UINT32 uh) { return Pack2UINT32AsUINT64 (uw, uh); }
  inline void UnpackSize (UINT64 up, UINT32 *puw, UINT32 *puh) { Unpack2UINT32AsUINT64 (up, puw, puh); }
  inline UINT64 PackRatio (INT32 n, UINT32 ud) { return Pack2UINT32AsUINT64 ((UINT32) n, ud); }
  inline void UnpackRatio (UINT64 up, INT32 *pn, UINT32 *pud) { Unpack2UINT32AsUINT64 (up, (UINT32 *) pn, pud); }
  inline UINT32 MFGetAttributeUINT32 (IMFAttributes *pattr, REFGUID guid, UINT32 udef) {
    UINT32 r;
    if (FAILED (pattr->GetUINT32 (guid, &r)))
      r = udef;
    return r;
  }
  inline UINT64 MFGetAttributeUINT64 (IMFAttributes *pattr, REFGUID guid, UINT64 udef) {
    UINT64 r;
    if (FAILED (pattr->GetUINT64 (guid, &r)))
      r = udef;
    return r;
  }
  inline double MFGetAttributeDouble (IMFAttributes *pattr, REFGUID guid, double fdef) {
    double r;
    if (FAILED (pattr->GetDouble (guid, &r)))
      r = fdef;
    return r;
  }
  inline HRESULT MFGetAttribute2UINT32asUINT64 (IMFAttributes *pattr, REFGUID guid, UINT32 *puh, UINT32 *pul) {
    UINT64 up;
    HRESULT hr = pattr->GetUINT64 (guid, &up);
    if (!FAILED (hr))
      Unpack2UINT32AsUINT64 (up, puh, pul);
    return hr;
  }
  inline HRESULT MFSetAttribute2UINT32asUINT64 (IMFAttributes *pattr, REFGUID guid, UINT32 uh, UINT32 ul) {
    return pattr->SetUINT64 (guid, Pack2UINT32AsUINT64 (uh, ul));
  }
  inline HRESULT MFGetAttributeRatio (IMFAttributes *pattr, REFGUID guid, UINT32 *pn, UINT32 *pd) { return MFGetAttribute2UINT32asUINT64 (pattr, guid, pn, pd); }
  inline HRESULT MFGetAttributeSize (IMFAttributes *pattr, REFGUID guid, UINT32 *pw, UINT32 *ph) { return MFGetAttribute2UINT32asUINT64 (pattr, guid, pw, ph); }
  inline HRESULT MFSetAttributeRatio (IMFAttributes *pattr, REFGUID guid, UINT32 un, UINT32 ud) { return MFSetAttribute2UINT32asUINT64 (pattr, guid, un, ud); }
  inline HRESULT MFSetAttributeSize (IMFAttributes *pattr, REFGUID guid, UINT32 uw, UINT32 uh) { return MFSetAttribute2UINT32asUINT64 (pattr, guid, uw, uh); }
#ifdef _INTSAFE_H_INCLUDED_
  inline HRESULT MFGetAttributeString (IMFAttributes *pattr, REFGUID guid, PWSTR *ppsz) {
    HRESULT hr;
    UINT32 length;
    PWSTR psz = NULL;
    *ppsz = NULL;
    hr = pattr->GetStringLength (guid, &length);
    if (SUCCEEDED (hr))
      hr = UIntAdd (length, 1, &length);
    if (SUCCEEDED (hr)) {
      size_t cb;
      hr = SizeTMult (length, sizeof (WCHAR), &cb);
      if (SUCCEEDED (hr) && !(psz = PWSTR (CoTaskMemAlloc (cb))))
	hr = E_OUTOFMEMORY;
    }
    if (SUCCEEDED (hr))
      hr = pattr->GetString (guid, psz, length, &length);
    if (SUCCEEDED (hr))
      *ppsz = psz;
    else
      CoTaskMemFree (psz);
    return hr;
  }
#endif

  STDAPI MFCreateCollection (IMFCollection **ppIMFCollection);
#endif

#if WINVER >= 0x0601
  LONGLONG WINAPI MFllMulDiv (LONGLONG a, LONGLONG b, LONGLONG c, LONGLONG d);
#endif
#endif

#if defined (__cplusplus)
}
#endif
#endif

/**
 * This file has no copyright assigned and is placed in the Public Domain.
 * This file is part of the mingw-w64 runtime package.
 * No warranty is given; refer to the file DISCLAIMER.PD within this package.
 */

#ifndef _MFERROR_H
#define _MFERROR_H

#define STATUS_SEVERITY(hr) (((hr) >> 30) & 0x3)
#define _HRESULT_TYPEDEF_(_sc) ((HRESULT)_sc)

#define FACILITY_MF_WIN32  0x7
#define FACILITY_MF        0xd

#define STATUS_SEVERITY_SUCCESS        0x0
#define STATUS_SEVERITY_INFORMATIONAL  0x1
#define STATUS_SEVERITY_WARNING        0x2
#define STATUS_SEVERITY_ERROR          0x3

#define MF_E_PLATFORM_NOT_INITIALIZED  _HRESULT_TYPEDEF_(0xc00d36b0)
#define MF_E_BUFFERTOOSMALL            _HRESULT_TYPEDEF_(0xc00d36b1)
#define MF_E_INVALIDREQUEST            _HRESULT_TYPEDEF_(0xc00d36b2)
#define MF_E_INVALIDSTREAMNUMBER       _HRESULT_TYPEDEF_(0xc00d36b3)
#define MF_E_INVALIDMEDIATYPE          _HRESULT_TYPEDEF_(0xc00d36b4)
#define MF_E_NOTACCEPTING              _HRESULT_TYPEDEF_(0xc00d36b5)
#define MF_E_NOT_INITIALIZED           _HRESULT_TYPEDEF_(0xc00d36b6)
#define MF_E_UNSUPPORTED_REPRESENTATION  _HRESULT_TYPEDEF_(0xc00d36b7)
#define MF_E_NO_MORE_TYPES             _HRESULT_TYPEDEF_(0xc00d36b9)
#define MF_E_UNSUPPORTED_SERVICE       _HRESULT_TYPEDEF_(0xc00d36ba)
#define MF_E_UNEXPECTED                _HRESULT_TYPEDEF_(0xc00d36bb)
#define MF_E_INVALIDNAME               _HRESULT_TYPEDEF_(0xc00d36bc)
#define MF_E_INVALIDTYPE               _HRESULT_TYPEDEF_(0xc00d36bd)
#define MF_E_INVALID_FILE_FORMAT       _HRESULT_TYPEDEF_(0xc00d36be)
#define MF_E_INVALIDINDEX              _HRESULT_TYPEDEF_(0xc00d36bf)
#define MF_E_INVALID_TIMESTAMP         _HRESULT_TYPEDEF_(0xc00d36c0)
#define MF_E_UNSUPPORTED_SCHEME        _HRESULT_TYPEDEF_(0xc00d36c3)
#define MF_E_UNSUPPORTED_BYTESTREAM_TYPE  _HRESULT_TYPEDEF_(0xc00d36c4)
#define MF_E_UNSUPPORTED_TIME_FORMAT   _HRESULT_TYPEDEF_(0xc00d36c5)
#define MF_E_NO_SAMPLE_TIMESTAMP       _HRESULT_TYPEDEF_(0xc00d36c8)
#define MF_E_NO_SAMPLE_DURATION        _HRESULT_TYPEDEF_(0xc00d36c9)
#define MF_E_INVALID_STREAM_DATA       _HRESULT_TYPEDEF_(0xc00d36cb)
#define MF_E_RT_UNAVAILABLE            _HRESULT_TYPEDEF_(0xc00d36cf)
#define MF_E_UNSUPPORTED_RATE          _HRESULT_TYPEDEF_(0xc00d36d0)
#define MF_E_THINNING_UNSUPPORTED      _HRESULT_TYPEDEF_(0xc00d36d1)
#define MF_E_REVERSE_UNSUPPORTED       _HRESULT_TYPEDEF_(0xc00d36d2)
#define MF_E_UNSUPPORTED_RATE_TRANSITION  _HRESULT_TYPEDEF_(0xc00d36d3)
#define MF_E_RATE_CHANGE_PREEMPTED     _HRESULT_TYPEDEF_(0xc00d36d4)
#define MF_E_NOT_FOUND                 _HRESULT_TYPEDEF_(0xc00d36d5)
#define MF_E_NOT_AVAILABLE             _HRESULT_TYPEDEF_(0xc00d36d6)
#define MF_E_NO_CLOCK                  _HRESULT_TYPEDEF_(0xc00d36d7)
#define MF_S_MULTIPLE_BEGIN            _HRESULT_TYPEDEF_(0x000d36d8)
#define MF_E_MULTIPLE_BEGIN            _HRESULT_TYPEDEF_(0xc00d36d9)
#define MF_E_MULTIPLE_SUBSCRIBERS      _HRESULT_TYPEDEF_(0xc00d36da)
#define MF_E_TIMER_ORPHANED            _HRESULT_TYPEDEF_(0xc00d36db)
#define MF_E_STATE_TRANSITION_PENDING      _HRESULT_TYPEDEF_(0xc00d36dc)
#define MF_E_UNSUPPORTED_STATE_TRANSITION  _HRESULT_TYPEDEF_(0xc00d36dd)
#define MF_E_UNRECOVERABLE_ERROR_OCCURRED  _HRESULT_TYPEDEF_(0xc00d36de)
#define MF_E_SAMPLE_HAS_TOO_MANY_BUFFERS   _HRESULT_TYPEDEF_(0xc00d36df)
#define MF_E_SAMPLE_NOT_WRITABLE       _HRESULT_TYPEDEF_(0xc00d36e0)
#define MF_E_INVALID_KEY               _HRESULT_TYPEDEF_(0xc00d36e2)
#define MF_E_BAD_STARTUP_VERSION       _HRESULT_TYPEDEF_(0xc00d36e3)
#define MF_E_UNSUPPORTED_CAPTION       _HRESULT_TYPEDEF_(0xc00d36e4)
#define MF_E_INVALID_POSITION          _HRESULT_TYPEDEF_(0xc00d36e5)
#define MF_E_ATTRIBUTENOTFOUND         _HRESULT_TYPEDEF_(0xc00d36e6)
#define MF_E_PROPERTY_TYPE_NOT_ALLOWED _HRESULT_TYPEDEF_(0xc00d36e7)

#define MF_E_TOPO_INVALID_OPTIONAL_NODE    _HRESULT_TYPEDEF_(0xc00d520e)
#define MF_E_TOPO_CANNOT_FIND_DECRYPTOR    _HRESULT_TYPEDEF_(0xc00d5211)
#define MF_E_TOPO_CODEC_NOT_FOUND      _HRESULT_TYPEDEF_(0xc00d5212)
#define MF_E_TOPO_CANNOT_CONNECT       _HRESULT_TYPEDEF_(0xc00d5213)
#define MF_E_TOPO_UNSUPPORTED          _HRESULT_TYPEDEF_(0xc00d5214)
#define MF_E_TOPO_INVALID_TIME_ATTRIBUTES  _HRESULT_TYPEDEF_(0xc00d5215)
#define MF_E_TOPO_LOOPS_IN_TOPOLOGY    _HRESULT_TYPEDEF_(0xC00d5216)
#define MF_E_TOPO_MISSING_PRESENTATION_DESCRIPTOR  _HRESULT_TYPEDEF_(0xc00d5217)
#define MF_E_TOPO_MISSING_STREAM_DESCRIPTOR        _HRESULT_TYPEDEF_(0xc00d5218)
#define MF_E_TOPO_STREAM_DESCRIPTOR_NOT_SELECTED   _HRESULT_TYPEDEF_(0xc00d5219)
#define MF_E_TOPO_MISSING_SOURCE       _HRESULT_TYPEDEF_(0xc00d521a)
#define MF_E_TOPO_SINK_ACTIVATES_UNSUPPORTED       _HRESULT_TYPEDEF_(0xc00d521b)
#define MF_E_TRANSFORM_TYPE_NOT_SET      _HRESULT_TYPEDEF_(0xc00d6d60)
#define MF_E_TRANSFORM_STREAM_CHANGE     _HRESULT_TYPEDEF_(0xc00d6d61)
#define MF_E_TRANSFORM_INPUT_REMAINING   _HRESULT_TYPEDEF_(0xc00d6d62)
#define MF_E_TRANSFORM_PROFILE_MISSING   _HRESULT_TYPEDEF_(0xc00d6d63)
#define MF_E_TRANSFORM_PROFILE_INVALID_OR_CORRUPT  _HRESULT_TYPEDEF_(0xc00d6d64)
#define MF_E_TRANSFORM_PROFILE_TRUNCATED           _HRESULT_TYPEDEF_(0xc00d6d65)
#define MF_E_TRANSFORM_PROPERTY_PID_NOT_RECOGNIZED _HRESULT_TYPEDEF_(0xc00d6d66)
#define MF_E_TRANSFORM_PROPERTY_VARIANT_TYPE_WRONG _HRESULT_TYPEDEF_(0xc00d6d67)
#define MF_E_TRANSFORM_PROPERTY_NOT_WRITEABLE      _HRESULT_TYPEDEF_(0xc00d6d68)
#define MF_E_TRANSFORM_PROPERTY_ARRAY_VALUE_WRONG_NUM_DIM  _HRESULT_TYPEDEF_(0xc00d6d69)
#define MF_E_TRANSFORM_PROPERTY_VALUE_SIZE_WRONG   _HRESULT_TYPEDEF_(0xc00d6d6a)
#define MF_E_TRANSFORM_PROPERTY_VALUE_OUT_OF_RANGE _HRESULT_TYPEDEF_(0xc00d6d6b)
#define MF_E_TRANSFORM_PROPERTY_VALUE_INCOMPATIBLE _HRESULT_TYPEDEF_(0xc00d6d6c)
#define MF_E_TRANSFORM_NOT_POSSIBLE_FOR_CURRENT_OUTPUT_MEDIATYPE       _HRESULT_TYPEDEF_(0xc00d6d6d)
#define MF_E_TRANSFORM_NOT_POSSIBLE_FOR_CURRENT_INPUT_MEDIATYPE        _HRESULT_TYPEDEF_(0xc00d6d6e)
#define MF_E_TRANSFORM_NOT_POSSIBLE_FOR_CURRENT_MEDIATYPE_COMBINATION  _HRESULT_TYPEDEF_(0xc00d6d6f)
#define MF_E_TRANSFORM_CONFLICTS_WITH_OTHER_CURRENTLY_ENABLED_FEATURES _HRESULT_TYPEDEF_(0xc00d6d70)
#define MF_E_TRANSFORM_NEED_MORE_INPUT                                 _HRESULT_TYPEDEF_(0xc00d6d72)
#define MF_E_TRANSFORM_NOT_POSSIBLE_FOR_CURRENT_SPKR_CONFIG            _HRESULT_TYPEDEF_(0xc00d6d73)
#define MF_E_TRANSFORM_CANNOT_CHANGE_MEDIATYPE_WHILE_PROCESSING        _HRESULT_TYPEDEF_(0xc00d6d74)
#define MF_S_TRANSFORM_DO_NOT_PROPAGATE_EVENT       _HRESULT_TYPEDEF_(0x000d6d75)
#define MF_E_UNSUPPORTED_D3D_TYPE                   _HRESULT_TYPEDEF_(0xc00d6d76)
#define MF_E_TRANSFORM_ASYNC_LOCKED                 _HRESULT_TYPEDEF_(0xc00d6d77)
#define MF_E_TRANSFORM_CANNOT_INITIALIZE_ACM_DRIVER _HRESULT_TYPEDEF_(0xc00d6d78)

#endif /* _MFERROR_H */

/*** Autogenerated by WIDL 1.6 from include/mfidl.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 __mfidl_h__
#define __mfidl_h__

/* Forward declarations */

#ifndef __IMFTopologyNode_FWD_DEFINED__
#define __IMFTopologyNode_FWD_DEFINED__
typedef interface IMFTopologyNode IMFTopologyNode;
#endif

#ifndef __IMFTopology_FWD_DEFINED__
#define __IMFTopology_FWD_DEFINED__
typedef interface IMFTopology IMFTopology;
#endif

#ifndef __IMFClock_FWD_DEFINED__
#define __IMFClock_FWD_DEFINED__
typedef interface IMFClock IMFClock;
#endif

#ifndef __IMFMediaSession_FWD_DEFINED__
#define __IMFMediaSession_FWD_DEFINED__
typedef interface IMFMediaSession IMFMediaSession;
#endif

#ifndef __IMFMediaTypeHandler_FWD_DEFINED__
#define __IMFMediaTypeHandler_FWD_DEFINED__
typedef interface IMFMediaTypeHandler IMFMediaTypeHandler;
#endif

#ifndef __IMFStreamDescriptor_FWD_DEFINED__
#define __IMFStreamDescriptor_FWD_DEFINED__
typedef interface IMFStreamDescriptor IMFStreamDescriptor;
#endif

#ifndef __IMFPresentationDescriptor_FWD_DEFINED__
#define __IMFPresentationDescriptor_FWD_DEFINED__
typedef interface IMFPresentationDescriptor IMFPresentationDescriptor;
#endif

#ifndef __IMFMediaSource_FWD_DEFINED__
#define __IMFMediaSource_FWD_DEFINED__
typedef interface IMFMediaSource IMFMediaSource;
#endif

#ifndef __IMFByteStreamBuffering_FWD_DEFINED__
#define __IMFByteStreamBuffering_FWD_DEFINED__
typedef interface IMFByteStreamBuffering IMFByteStreamBuffering;
#endif

/* Headers for imported files */

#include <mfobjects.h>

#ifdef __cplusplus
extern "C" {
#endif

#include <mftransform.h>
#include <windef.h>
typedef enum MFSESSION_SETTOPOLOGY_FLAGS {
    MFSESSION_SETTOPOLOGY_IMMEDIATE = 0x1,
    MFSESSION_SETTOPOLOGY_NORESOLUTION = 0x2,
    MFSESSION_SETTOPOLOGY_CLEAR_CURRENT = 0x4
} MFSESSION_SETTOPOLOGY_FLAGS;
typedef enum MFSESSION_GETFULLTOPOLOGY_FLAGS {
    MFSESSION_GETFULLTOPOLOGY_CURRENT = 0
} MFSESSION_GETFULLTOPOLOGY_FLAGS;
typedef enum MFPMPSESSION_CREATION_FLAGS {
    MFPMPSESSION_UNPROTECTED_PROCESS = 0x1
} MFPMPSESSION_CREATION_FLAGS;
typedef UINT64 TOPOID;
typedef enum MF_TOPOLOGY_TYPE {
    MF_TOPOLOGY_OUTPUT_NODE = 0,
    MF_TOPOLOGY_SOURCESTREAM_NODE = 1,
    MF_TOPOLOGY_TRANSFORM_NODE = 2,
    MF_TOPOLOGY_TEE_NODE = 3,
    MF_TOPOLOGY_MAX = 0xffffffff
} MF_TOPOLOGY_TYPE;
/*****************************************************************************
 * IMFTopologyNode interface
 */
#ifndef __IMFTopologyNode_INTERFACE_DEFINED__
#define __IMFTopologyNode_INTERFACE_DEFINED__

DEFINE_GUID(IID_IMFTopologyNode, 0x83cf873a, 0xf6da, 0x4bc8, 0x82,0x3f, 0xba,0xcf,0xd5,0x5d,0xc4,0x30);
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("83cf873a-f6da-4bc8-823f-bacfd55dc430")
IMFTopologyNode : public IMFAttributes
{
    virtual HRESULT STDMETHODCALLTYPE SetObject(
        IUnknown *pObject) = 0;

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

    virtual HRESULT STDMETHODCALLTYPE GetNodeType(
        MF_TOPOLOGY_TYPE *pType) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetTopoNodeID(
        TOPOID *pID) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetTopoNodeID(
        TOPOID ullTopoID) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetInputCount(
        DWORD *pcInputs) = 0;

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

    virtual HRESULT STDMETHODCALLTYPE ConnectOutput(
        DWORD dwOutputIndex,
        IMFTopologyNode *pDownstreamNode,
        DWORD dwInputIndexOnDownstreamNode) = 0;

    virtual HRESULT STDMETHODCALLTYPE DisconnectOutput(
        DWORD dwOutputIndex) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetInput(
        DWORD dwInputIndex,
        IMFTopologyNode **ppUpstreamNode,
        DWORD *pdwOutputIndexOnUpstreamNode) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetOutput(
        DWORD dwOutputIndex,
        IMFTopologyNode **ppDownstreamNode,
        DWORD *pdwInputIndexOnDownstreamNode) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetOutputPrefType(
        DWORD dwOutputIndex,
        IMFMediaType *pType) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetOutputPrefType(
        DWORD dwOutputIndex,
        IMFMediaType **ppType) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetInputPrefType(
        DWORD dwInputIndex,
        IMFMediaType *pType) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetInputPrefType(
        DWORD dwInputIndex,
        IMFMediaType **ppType) = 0;

    virtual HRESULT STDMETHODCALLTYPE CloneFrom(
        IMFTopologyNode *pNode) = 0;

};
#ifdef __CRT_UUID_DECL
__CRT_UUID_DECL(IMFTopologyNode, 0x83cf873a, 0xf6da, 0x4bc8, 0x82,0x3f, 0xba,0xcf,0xd5,0x5d,0xc4,0x30)
#endif
#else
typedef struct IMFTopologyNodeVtbl {
    BEGIN_INTERFACE

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

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

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

    /*** IMFAttributes methods ***/
    HRESULT (STDMETHODCALLTYPE *GetItem)(
        IMFTopologyNode* This,
        REFGUID guidKey,
        PROPVARIANT *pValue);

    HRESULT (STDMETHODCALLTYPE *GetItemType)(
        IMFTopologyNode* This,
        REFGUID guidKey,
        MF_ATTRIBUTE_TYPE *pType);

    HRESULT (STDMETHODCALLTYPE *CompareItem)(
        IMFTopologyNode* This,
        REFGUID guidKey,
        REFPROPVARIANT Value,
        WINBOOL *pbResult);

    HRESULT (STDMETHODCALLTYPE *Compare)(
        IMFTopologyNode* This,
        IMFAttributes *pTheirs,
        MF_ATTRIBUTES_MATCH_TYPE MatchType,
        WINBOOL *pbResult);

    HRESULT (STDMETHODCALLTYPE *GetUINT32)(
        IMFTopologyNode* This,
        REFGUID guidKey,
        UINT32 *punValue);

    HRESULT (STDMETHODCALLTYPE *GetUINT64)(
        IMFTopologyNode* This,
        REFGUID guidKey,
        UINT64 *punValue);

    HRESULT (STDMETHODCALLTYPE *GetDouble)(
        IMFTopologyNode* This,
        REFGUID guidKey,
        double *pfValue);

    HRESULT (STDMETHODCALLTYPE *GetGUID)(
        IMFTopologyNode* This,
        REFGUID guidKey,
        GUID *pguidValue);

    HRESULT (STDMETHODCALLTYPE *GetStringLength)(
        IMFTopologyNode* This,
        REFGUID guidKey,
        UINT32 *pcchLength);

    HRESULT (STDMETHODCALLTYPE *GetString)(
        IMFTopologyNode* This,
        REFGUID guidKey,
        LPWSTR pwszValue,
        UINT32 cchBufSize,
        UINT32 *pcchLength);

    HRESULT (STDMETHODCALLTYPE *GetAllocatedString)(
        IMFTopologyNode* This,
        REFGUID guidKey,
        LPWSTR *ppwszValue,
        UINT32 *pcchLength);

    HRESULT (STDMETHODCALLTYPE *GetBlobSize)(
        IMFTopologyNode* This,
        REFGUID guidKey,
        UINT32 *pcbBlobSize);

    HRESULT (STDMETHODCALLTYPE *GetBlob)(
        IMFTopologyNode* This,
        REFGUID guidKey,
        UINT8 *pBuf,
        UINT32 cbBufSize,
        UINT32 *pcbBlobSize);

    HRESULT (STDMETHODCALLTYPE *GetAllocatedBlob)(
        IMFTopologyNode* This,
        REFGUID guidKey,
        UINT8 **ppBuf,
        UINT32 *pcbSize);

    HRESULT (STDMETHODCALLTYPE *GetUnknown)(
        IMFTopologyNode* This,
        REFGUID guidKey,
        REFIID riid,
        LPVOID *ppv);

    HRESULT (STDMETHODCALLTYPE *SetItem)(
        IMFTopologyNode* This,
        REFGUID guidKey,
        REFPROPVARIANT Value);

    HRESULT (STDMETHODCALLTYPE *DeleteItem)(
        IMFTopologyNode* This,
        REFGUID guidKey);

    HRESULT (STDMETHODCALLTYPE *DeleteAllItems)(
        IMFTopologyNode* This);

    HRESULT (STDMETHODCALLTYPE *SetUINT32)(
        IMFTopologyNode* This,
        REFGUID guidKey,
        UINT32 unValue);

    HRESULT (STDMETHODCALLTYPE *SetUINT64)(
        IMFTopologyNode* This,
        REFGUID guidKey,
        UINT64 unValue);

    HRESULT (STDMETHODCALLTYPE *SetDouble)(
        IMFTopologyNode* This,
        REFGUID guidKey,
        double fValue);

    HRESULT (STDMETHODCALLTYPE *SetGUID)(
        IMFTopologyNode* This,
        REFGUID guidKey,
        REFGUID guidValue);

    HRESULT (STDMETHODCALLTYPE *SetString)(
        IMFTopologyNode* This,
        REFGUID guidKey,
        LPCWSTR wszValue);

    HRESULT (STDMETHODCALLTYPE *SetBlob)(
        IMFTopologyNode* This,
        REFGUID guidKey,
        const UINT8 *pBuf,
        UINT32 cbBufSize);

    HRESULT (STDMETHODCALLTYPE *SetUnknown)(
        IMFTopologyNode* This,
        REFGUID guidKey,
        IUnknown *pUnknown);

    HRESULT (STDMETHODCALLTYPE *LockStore)(
        IMFTopologyNode* This);

    HRESULT (STDMETHODCALLTYPE *UnlockStore)(
        IMFTopologyNode* This);

    HRESULT (STDMETHODCALLTYPE *GetCount)(
        IMFTopologyNode* This,
        UINT32 *pcItems);

    HRESULT (STDMETHODCALLTYPE *GetItemByIndex)(
        IMFTopologyNode* This,
        UINT32 unIndex,
        GUID *pguidKey,
        PROPVARIANT *pValue);

    HRESULT (STDMETHODCALLTYPE *CopyAllItems)(
        IMFTopologyNode* This,
        IMFAttributes *pDest);

    /*** IMFTopologyNode methods ***/
    HRESULT (STDMETHODCALLTYPE *SetObject)(
        IMFTopologyNode* This,
        IUnknown *pObject);

    HRESULT (STDMETHODCALLTYPE *GetObject)(
        IMFTopologyNode* This,
        IUnknown **ppObject);

    HRESULT (STDMETHODCALLTYPE *GetNodeType)(
        IMFTopologyNode* This,
        MF_TOPOLOGY_TYPE *pType);

    HRESULT (STDMETHODCALLTYPE *GetTopoNodeID)(
        IMFTopologyNode* This,
        TOPOID *pID);

    HRESULT (STDMETHODCALLTYPE *SetTopoNodeID)(
        IMFTopologyNode* This,
        TOPOID ullTopoID);

    HRESULT (STDMETHODCALLTYPE *GetInputCount)(
        IMFTopologyNode* This,
        DWORD *pcInputs);

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

    HRESULT (STDMETHODCALLTYPE *ConnectOutput)(
        IMFTopologyNode* This,
        DWORD dwOutputIndex,
        IMFTopologyNode *pDownstreamNode,
        DWORD dwInputIndexOnDownstreamNode);

    HRESULT (STDMETHODCALLTYPE *DisconnectOutput)(
        IMFTopologyNode* This,
        DWORD dwOutputIndex);

    HRESULT (STDMETHODCALLTYPE *GetInput)(
        IMFTopologyNode* This,
        DWORD dwInputIndex,
        IMFTopologyNode **ppUpstreamNode,
        DWORD *pdwOutputIndexOnUpstreamNode);

    HRESULT (STDMETHODCALLTYPE *GetOutput)(
        IMFTopologyNode* This,
        DWORD dwOutputIndex,
        IMFTopologyNode **ppDownstreamNode,
        DWORD *pdwInputIndexOnDownstreamNode);

    HRESULT (STDMETHODCALLTYPE *SetOutputPrefType)(
        IMFTopologyNode* This,
        DWORD dwOutputIndex,
        IMFMediaType *pType);

    HRESULT (STDMETHODCALLTYPE *GetOutputPrefType)(
        IMFTopologyNode* This,
        DWORD dwOutputIndex,
        IMFMediaType **ppType);

    HRESULT (STDMETHODCALLTYPE *SetInputPrefType)(
        IMFTopologyNode* This,
        DWORD dwInputIndex,
        IMFMediaType *pType);

    HRESULT (STDMETHODCALLTYPE *GetInputPrefType)(
        IMFTopologyNode* This,
        DWORD dwInputIndex,
        IMFMediaType **ppType);

    HRESULT (STDMETHODCALLTYPE *CloneFrom)(
        IMFTopologyNode* This,
        IMFTopologyNode *pNode);

    END_INTERFACE
} IMFTopologyNodeVtbl;
interface IMFTopologyNode {
    CONST_VTBL IMFTopologyNodeVtbl* lpVtbl;
};

#ifdef COBJMACROS
#ifndef WIDL_C_INLINE_WRAPPERS
/*** IUnknown methods ***/
#define IMFTopologyNode_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
#define IMFTopologyNode_AddRef(This) (This)->lpVtbl->AddRef(This)
#define IMFTopologyNode_Release(This) (This)->lpVtbl->Release(This)
/*** IMFAttributes methods ***/
#define IMFTopologyNode_GetItem(This,guidKey,pValue) (This)->lpVtbl->GetItem(This,guidKey,pValue)
#define IMFTopologyNode_GetItemType(This,guidKey,pType) (This)->lpVtbl->GetItemType(This,guidKey,pType)
#define IMFTopologyNode_CompareItem(This,guidKey,Value,pbResult) (This)->lpVtbl->CompareItem(This,guidKey,Value,pbResult)
#define IMFTopologyNode_Compare(This,pTheirs,MatchType,pbResult) (This)->lpVtbl->Compare(This,pTheirs,MatchType,pbResult)
#define IMFTopologyNode_GetUINT32(This,guidKey,punValue) (This)->lpVtbl->GetUINT32(This,guidKey,punValue)
#define IMFTopologyNode_GetUINT64(This,guidKey,punValue) (This)->lpVtbl->GetUINT64(This,guidKey,punValue)
#define IMFTopologyNode_GetDouble(This,guidKey,pfValue) (This)->lpVtbl->GetDouble(This,guidKey,pfValue)
#define IMFTopologyNode_GetGUID(This,guidKey,pguidValue) (This)->lpVtbl->GetGUID(This,guidKey,pguidValue)
#define IMFTopologyNode_GetStringLength(This,guidKey,pcchLength) (This)->lpVtbl->GetStringLength(This,guidKey,pcchLength)
#define IMFTopologyNode_GetString(This,guidKey,pwszValue,cchBufSize,pcchLength) (This)->lpVtbl->GetString(This,guidKey,pwszValue,cchBufSize,pcchLength)
#define IMFTopologyNode_GetAllocatedString(This,guidKey,ppwszValue,pcchLength) (This)->lpVtbl->GetAllocatedString(This,guidKey,ppwszValue,pcchLength)
#define IMFTopologyNode_GetBlobSize(This,guidKey,pcbBlobSize) (This)->lpVtbl->GetBlobSize(This,guidKey,pcbBlobSize)
#define IMFTopologyNode_GetBlob(This,guidKey,pBuf,cbBufSize,pcbBlobSize) (This)->lpVtbl->GetBlob(This,guidKey,pBuf,cbBufSize,pcbBlobSize)
#define IMFTopologyNode_GetAllocatedBlob(This,guidKey,ppBuf,pcbSize) (This)->lpVtbl->GetAllocatedBlob(This,guidKey,ppBuf,pcbSize)
#define IMFTopologyNode_GetUnknown(This,guidKey,riid,ppv) (This)->lpVtbl->GetUnknown(This,guidKey,riid,ppv)
#define IMFTopologyNode_SetItem(This,guidKey,Value) (This)->lpVtbl->SetItem(This,guidKey,Value)
#define IMFTopologyNode_DeleteItem(This,guidKey) (This)->lpVtbl->DeleteItem(This,guidKey)
#define IMFTopologyNode_DeleteAllItems(This) (This)->lpVtbl->DeleteAllItems(This)
#define IMFTopologyNode_SetUINT32(This,guidKey,unValue) (This)->lpVtbl->SetUINT32(This,guidKey,unValue)
#define IMFTopologyNode_SetUINT64(This,guidKey,unValue) (This)->lpVtbl->SetUINT64(This,guidKey,unValue)
#define IMFTopologyNode_SetDouble(This,guidKey,fValue) (This)->lpVtbl->SetDouble(This,guidKey,fValue)
#define IMFTopologyNode_SetGUID(This,guidKey,guidValue) (This)->lpVtbl->SetGUID(This,guidKey,guidValue)
#define IMFTopologyNode_SetString(This,guidKey,wszValue) (This)->lpVtbl->SetString(This,guidKey,wszValue)
#define IMFTopologyNode_SetBlob(This,guidKey,pBuf,cbBufSize) (This)->lpVtbl->SetBlob(This,guidKey,pBuf,cbBufSize)
#define IMFTopologyNode_SetUnknown(This,guidKey,pUnknown) (This)->lpVtbl->SetUnknown(This,guidKey,pUnknown)
#define IMFTopologyNode_LockStore(This) (This)->lpVtbl->LockStore(This)
#define IMFTopologyNode_UnlockStore(This) (This)->lpVtbl->UnlockStore(This)
#define IMFTopologyNode_GetCount(This,pcItems) (This)->lpVtbl->GetCount(This,pcItems)
#define IMFTopologyNode_GetItemByIndex(This,unIndex,pguidKey,pValue) (This)->lpVtbl->GetItemByIndex(This,unIndex,pguidKey,pValue)
#define IMFTopologyNode_CopyAllItems(This,pDest) (This)->lpVtbl->CopyAllItems(This,pDest)
/*** IMFTopologyNode methods ***/
#define IMFTopologyNode_SetObject(This,pObject) (This)->lpVtbl->SetObject(This,pObject)
#define IMFTopologyNode_GetObject(This,ppObject) (This)->lpVtbl->GetObject(This,ppObject)
#define IMFTopologyNode_GetNodeType(This,pType) (This)->lpVtbl->GetNodeType(This,pType)
#define IMFTopologyNode_GetTopoNodeID(This,pID) (This)->lpVtbl->GetTopoNodeID(This,pID)
#define IMFTopologyNode_SetTopoNodeID(This,ullTopoID) (This)->lpVtbl->SetTopoNodeID(This,ullTopoID)
#define IMFTopologyNode_GetInputCount(This,pcInputs) (This)->lpVtbl->GetInputCount(This,pcInputs)
#define IMFTopologyNode_GetOutputCount(This,pcOutputs) (This)->lpVtbl->GetOutputCount(This,pcOutputs)
#define IMFTopologyNode_ConnectOutput(This,dwOutputIndex,pDownstreamNode,dwInputIndexOnDownstreamNode) (This)->lpVtbl->ConnectOutput(This,dwOutputIndex,pDownstreamNode,dwInputIndexOnDownstreamNode)
#define IMFTopologyNode_DisconnectOutput(This,dwOutputIndex) (This)->lpVtbl->DisconnectOutput(This,dwOutputIndex)
#define IMFTopologyNode_GetInput(This,dwInputIndex,ppUpstreamNode,pdwOutputIndexOnUpstreamNode) (This)->lpVtbl->GetInput(This,dwInputIndex,ppUpstreamNode,pdwOutputIndexOnUpstreamNode)
#define IMFTopologyNode_GetOutput(This,dwOutputIndex,ppDownstreamNode,pdwInputIndexOnDownstreamNode) (This)->lpVtbl->GetOutput(This,dwOutputIndex,ppDownstreamNode,pdwInputIndexOnDownstreamNode)
#define IMFTopologyNode_SetOutputPrefType(This,dwOutputIndex,pType) (This)->lpVtbl->SetOutputPrefType(This,dwOutputIndex,pType)
#define IMFTopologyNode_GetOutputPrefType(This,dwOutputIndex,ppType) (This)->lpVtbl->GetOutputPrefType(This,dwOutputIndex,ppType)
#define IMFTopologyNode_SetInputPrefType(This,dwInputIndex,pType) (This)->lpVtbl->SetInputPrefType(This,dwInputIndex,pType)
#define IMFTopologyNode_GetInputPrefType(This,dwInputIndex,ppType) (This)->lpVtbl->GetInputPrefType(This,dwInputIndex,ppType)
#define IMFTopologyNode_CloneFrom(This,pNode) (This)->lpVtbl->CloneFrom(This,pNode)
#else
/*** IUnknown methods ***/
static FORCEINLINE HRESULT IMFTopologyNode_QueryInterface(IMFTopologyNode* This,REFIID riid,void **ppvObject) {
    return This->lpVtbl->QueryInterface(This,riid,ppvObject);
}
static FORCEINLINE ULONG IMFTopologyNode_AddRef(IMFTopologyNode* This) {
    return This->lpVtbl->AddRef(This);
}
static FORCEINLINE ULONG IMFTopologyNode_Release(IMFTopologyNode* This) {
    return This->lpVtbl->Release(This);
}
/*** IMFAttributes methods ***/
static FORCEINLINE HRESULT IMFTopologyNode_GetItem(IMFTopologyNode* This,REFGUID guidKey,PROPVARIANT *pValue) {
    return This->lpVtbl->GetItem(This,guidKey,pValue);
}
static FORCEINLINE HRESULT IMFTopologyNode_GetItemType(IMFTopologyNode* This,REFGUID guidKey,MF_ATTRIBUTE_TYPE *pType) {
    return This->lpVtbl->GetItemType(This,guidKey,pType);
}
static FORCEINLINE HRESULT IMFTopologyNode_CompareItem(IMFTopologyNode* This,REFGUID guidKey,REFPROPVARIANT Value,WINBOOL *pbResult) {
    return This->lpVtbl->CompareItem(This,guidKey,Value,pbResult);
}
static FORCEINLINE HRESULT IMFTopologyNode_Compare(IMFTopologyNode* This,IMFAttributes *pTheirs,MF_ATTRIBUTES_MATCH_TYPE MatchType,WINBOOL *pbResult) {
    return This->lpVtbl->Compare(This,pTheirs,MatchType,pbResult);
}
static FORCEINLINE HRESULT IMFTopologyNode_GetUINT32(IMFTopologyNode* This,REFGUID guidKey,UINT32 *punValue) {
    return This->lpVtbl->GetUINT32(This,guidKey,punValue);
}
static FORCEINLINE HRESULT IMFTopologyNode_GetUINT64(IMFTopologyNode* This,REFGUID guidKey,UINT64 *punValue) {
    return This->lpVtbl->GetUINT64(This,guidKey,punValue);
}
static FORCEINLINE HRESULT IMFTopologyNode_GetDouble(IMFTopologyNode* This,REFGUID guidKey,double *pfValue) {
    return This->lpVtbl->GetDouble(This,guidKey,pfValue);
}
static FORCEINLINE HRESULT IMFTopologyNode_GetGUID(IMFTopologyNode* This,REFGUID guidKey,GUID *pguidValue) {
    return This->lpVtbl->GetGUID(This,guidKey,pguidValue);
}
static FORCEINLINE HRESULT IMFTopologyNode_GetStringLength(IMFTopologyNode* This,REFGUID guidKey,UINT32 *pcchLength) {
    return This->lpVtbl->GetStringLength(This,guidKey,pcchLength);
}
static FORCEINLINE HRESULT IMFTopologyNode_GetString(IMFTopologyNode* This,REFGUID guidKey,LPWSTR pwszValue,UINT32 cchBufSize,UINT32 *pcchLength) {
    return This->lpVtbl->GetString(This,guidKey,pwszValue,cchBufSize,pcchLength);
}
static FORCEINLINE HRESULT IMFTopologyNode_GetAllocatedString(IMFTopologyNode* This,REFGUID guidKey,LPWSTR *ppwszValue,UINT32 *pcchLength) {
    return This->lpVtbl->GetAllocatedString(This,guidKey,ppwszValue,pcchLength);
}
static FORCEINLINE HRESULT IMFTopologyNode_GetBlobSize(IMFTopologyNode* This,REFGUID guidKey,UINT32 *pcbBlobSize) {
    return This->lpVtbl->GetBlobSize(This,guidKey,pcbBlobSize);
}
static FORCEINLINE HRESULT IMFTopologyNode_GetBlob(IMFTopologyNode* This,REFGUID guidKey,UINT8 *pBuf,UINT32 cbBufSize,UINT32 *pcbBlobSize) {
    return This->lpVtbl->GetBlob(This,guidKey,pBuf,cbBufSize,pcbBlobSize);
}
static FORCEINLINE HRESULT IMFTopologyNode_GetAllocatedBlob(IMFTopologyNode* This,REFGUID guidKey,UINT8 **ppBuf,UINT32 *pcbSize) {
    return This->lpVtbl->GetAllocatedBlob(This,guidKey,ppBuf,pcbSize);
}
static FORCEINLINE HRESULT IMFTopologyNode_GetUnknown(IMFTopologyNode* This,REFGUID guidKey,REFIID riid,LPVOID *ppv) {
    return This->lpVtbl->GetUnknown(This,guidKey,riid,ppv);
}
static FORCEINLINE HRESULT IMFTopologyNode_SetItem(IMFTopologyNode* This,REFGUID guidKey,REFPROPVARIANT Value) {
    return This->lpVtbl->SetItem(This,guidKey,Value);
}
static FORCEINLINE HRESULT IMFTopologyNode_DeleteItem(IMFTopologyNode* This,REFGUID guidKey) {
    return This->lpVtbl->DeleteItem(This,guidKey);
}
static FORCEINLINE HRESULT IMFTopologyNode_DeleteAllItems(IMFTopologyNode* This) {
    return This->lpVtbl->DeleteAllItems(This);
}
static FORCEINLINE HRESULT IMFTopologyNode_SetUINT32(IMFTopologyNode* This,REFGUID guidKey,UINT32 unValue) {
    return This->lpVtbl->SetUINT32(This,guidKey,unValue);
}
static FORCEINLINE HRESULT IMFTopologyNode_SetUINT64(IMFTopologyNode* This,REFGUID guidKey,UINT64 unValue) {
    return This->lpVtbl->SetUINT64(This,guidKey,unValue);
}
static FORCEINLINE HRESULT IMFTopologyNode_SetDouble(IMFTopologyNode* This,REFGUID guidKey,double fValue) {
    return This->lpVtbl->SetDouble(This,guidKey,fValue);
}
static FORCEINLINE HRESULT IMFTopologyNode_SetGUID(IMFTopologyNode* This,REFGUID guidKey,REFGUID guidValue) {
    return This->lpVtbl->SetGUID(This,guidKey,guidValue);
}
static FORCEINLINE HRESULT IMFTopologyNode_SetString(IMFTopologyNode* This,REFGUID guidKey,LPCWSTR wszValue) {
    return This->lpVtbl->SetString(This,guidKey,wszValue);
}
static FORCEINLINE HRESULT IMFTopologyNode_SetBlob(IMFTopologyNode* This,REFGUID guidKey,const UINT8 *pBuf,UINT32 cbBufSize) {
    return This->lpVtbl->SetBlob(This,guidKey,pBuf,cbBufSize);
}
static FORCEINLINE HRESULT IMFTopologyNode_SetUnknown(IMFTopologyNode* This,REFGUID guidKey,IUnknown *pUnknown) {
    return This->lpVtbl->SetUnknown(This,guidKey,pUnknown);
}
static FORCEINLINE HRESULT IMFTopologyNode_LockStore(IMFTopologyNode* This) {
    return This->lpVtbl->LockStore(This);
}
static FORCEINLINE HRESULT IMFTopologyNode_UnlockStore(IMFTopologyNode* This) {
    return This->lpVtbl->UnlockStore(This);
}
static FORCEINLINE HRESULT IMFTopologyNode_GetCount(IMFTopologyNode* This,UINT32 *pcItems) {
    return This->lpVtbl->GetCount(This,pcItems);
}
static FORCEINLINE HRESULT IMFTopologyNode_GetItemByIndex(IMFTopologyNode* This,UINT32 unIndex,GUID *pguidKey,PROPVARIANT *pValue) {
    return This->lpVtbl->GetItemByIndex(This,unIndex,pguidKey,pValue);
}
static FORCEINLINE HRESULT IMFTopologyNode_CopyAllItems(IMFTopologyNode* This,IMFAttributes *pDest) {
    return This->lpVtbl->CopyAllItems(This,pDest);
}
/*** IMFTopologyNode methods ***/
static FORCEINLINE HRESULT IMFTopologyNode_SetObject(IMFTopologyNode* This,IUnknown *pObject) {
    return This->lpVtbl->SetObject(This,pObject);
}
static FORCEINLINE HRESULT IMFTopologyNode_GetObject(IMFTopologyNode* This,IUnknown **ppObject) {
    return This->lpVtbl->GetObject(This,ppObject);
}
static FORCEINLINE HRESULT IMFTopologyNode_GetNodeType(IMFTopologyNode* This,MF_TOPOLOGY_TYPE *pType) {
    return This->lpVtbl->GetNodeType(This,pType);
}
static FORCEINLINE HRESULT IMFTopologyNode_GetTopoNodeID(IMFTopologyNode* This,TOPOID *pID) {
    return This->lpVtbl->GetTopoNodeID(This,pID);
}
static FORCEINLINE HRESULT IMFTopologyNode_SetTopoNodeID(IMFTopologyNode* This,TOPOID ullTopoID) {
    return This->lpVtbl->SetTopoNodeID(This,ullTopoID);
}
static FORCEINLINE HRESULT IMFTopologyNode_GetInputCount(IMFTopologyNode* This,DWORD *pcInputs) {
    return This->lpVtbl->GetInputCount(This,pcInputs);
}
static FORCEINLINE HRESULT IMFTopologyNode_GetOutputCount(IMFTopologyNode* This,DWORD *pcOutputs) {
    return This->lpVtbl->GetOutputCount(This,pcOutputs);
}
static FORCEINLINE HRESULT IMFTopologyNode_ConnectOutput(IMFTopologyNode* This,DWORD dwOutputIndex,IMFTopologyNode *pDownstreamNode,DWORD dwInputIndexOnDownstreamNode) {
    return This->lpVtbl->ConnectOutput(This,dwOutputIndex,pDownstreamNode,dwInputIndexOnDownstreamNode);
}
static FORCEINLINE HRESULT IMFTopologyNode_DisconnectOutput(IMFTopologyNode* This,DWORD dwOutputIndex) {
    return This->lpVtbl->DisconnectOutput(This,dwOutputIndex);
}
static FORCEINLINE HRESULT IMFTopologyNode_GetInput(IMFTopologyNode* This,DWORD dwInputIndex,IMFTopologyNode **ppUpstreamNode,DWORD *pdwOutputIndexOnUpstreamNode) {
    return This->lpVtbl->GetInput(This,dwInputIndex,ppUpstreamNode,pdwOutputIndexOnUpstreamNode);
}
static FORCEINLINE HRESULT IMFTopologyNode_GetOutput(IMFTopologyNode* This,DWORD dwOutputIndex,IMFTopologyNode **ppDownstreamNode,DWORD *pdwInputIndexOnDownstreamNode) {
    return This->lpVtbl->GetOutput(This,dwOutputIndex,ppDownstreamNode,pdwInputIndexOnDownstreamNode);
}
static FORCEINLINE HRESULT IMFTopologyNode_SetOutputPrefType(IMFTopologyNode* This,DWORD dwOutputIndex,IMFMediaType *pType) {
    return This->lpVtbl->SetOutputPrefType(This,dwOutputIndex,pType);
}
static FORCEINLINE HRESULT IMFTopologyNode_GetOutputPrefType(IMFTopologyNode* This,DWORD dwOutputIndex,IMFMediaType **ppType) {
    return This->lpVtbl->GetOutputPrefType(This,dwOutputIndex,ppType);
}
static FORCEINLINE HRESULT IMFTopologyNode_SetInputPrefType(IMFTopologyNode* This,DWORD dwInputIndex,IMFMediaType *pType) {
    return This->lpVtbl->SetInputPrefType(This,dwInputIndex,pType);
}
static FORCEINLINE HRESULT IMFTopologyNode_GetInputPrefType(IMFTopologyNode* This,DWORD dwInputIndex,IMFMediaType **ppType) {
    return This->lpVtbl->GetInputPrefType(This,dwInputIndex,ppType);
}
static FORCEINLINE HRESULT IMFTopologyNode_CloneFrom(IMFTopologyNode* This,IMFTopologyNode *pNode) {
    return This->lpVtbl->CloneFrom(This,pNode);
}
#endif
#endif

#endif

HRESULT STDMETHODCALLTYPE IMFTopologyNode_SetObject_Proxy(
    IMFTopologyNode* This,
    IUnknown *pObject);
void __RPC_STUB IMFTopologyNode_SetObject_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFTopologyNode_GetObject_Proxy(
    IMFTopologyNode* This,
    IUnknown **ppObject);
void __RPC_STUB IMFTopologyNode_GetObject_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFTopologyNode_GetNodeType_Proxy(
    IMFTopologyNode* This,
    MF_TOPOLOGY_TYPE *pType);
void __RPC_STUB IMFTopologyNode_GetNodeType_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFTopologyNode_GetTopoNodeID_Proxy(
    IMFTopologyNode* This,
    TOPOID *pID);
void __RPC_STUB IMFTopologyNode_GetTopoNodeID_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFTopologyNode_SetTopoNodeID_Proxy(
    IMFTopologyNode* This,
    TOPOID ullTopoID);
void __RPC_STUB IMFTopologyNode_SetTopoNodeID_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFTopologyNode_GetInputCount_Proxy(
    IMFTopologyNode* This,
    DWORD *pcInputs);
void __RPC_STUB IMFTopologyNode_GetInputCount_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFTopologyNode_GetOutputCount_Proxy(
    IMFTopologyNode* This,
    DWORD *pcOutputs);
void __RPC_STUB IMFTopologyNode_GetOutputCount_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFTopologyNode_GetInput_Proxy(
    IMFTopologyNode* This,
    DWORD dwInputIndex,
    IMFTopologyNode **ppUpstreamNode,
    DWORD *pdwOutputIndexOnUpstreamNode);
void __RPC_STUB IMFTopologyNode_GetInput_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFTopologyNode_GetOutput_Proxy(
    IMFTopologyNode* This,
    DWORD dwOutputIndex,
    IMFTopologyNode **ppDownstreamNode,
    DWORD *pdwInputIndexOnDownstreamNode);
void __RPC_STUB IMFTopologyNode_GetOutput_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFTopologyNode_RemoteGetOutputPrefType_Proxy(
    IMFTopologyNode* This,
    DWORD dwOutputIndex,
    DWORD *pcbData,
    BYTE **ppbData);
void __RPC_STUB IMFTopologyNode_RemoteGetOutputPrefType_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFTopologyNode_RemoteGetInputPrefType_Proxy(
    IMFTopologyNode* This,
    DWORD dwInputIndex,
    DWORD *pcbData,
    BYTE **ppbData);
void __RPC_STUB IMFTopologyNode_RemoteGetInputPrefType_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFTopologyNode_CloneFrom_Proxy(
    IMFTopologyNode* This,
    IMFTopologyNode *pNode);
void __RPC_STUB IMFTopologyNode_CloneFrom_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMFTopologyNode_GetOutputPrefType_Proxy(
    IMFTopologyNode* This,
    DWORD dwOutputIndex,
    IMFMediaType **ppType);
HRESULT __RPC_STUB IMFTopologyNode_GetOutputPrefType_Stub(
    IMFTopologyNode* This,
    DWORD dwOutputIndex,
    DWORD *pcbData,
    BYTE **ppbData);
HRESULT CALLBACK IMFTopologyNode_GetInputPrefType_Proxy(
    IMFTopologyNode* This,
    DWORD dwInputIndex,
    IMFMediaType **ppType);
HRESULT __RPC_STUB IMFTopologyNode_GetInputPrefType_Stub(
    IMFTopologyNode* This,
    DWORD dwInputIndex,
    DWORD *pcbData,
    BYTE **ppbData);

#endif  /* __IMFTopologyNode_INTERFACE_DEFINED__ */

/*****************************************************************************
 * IMFTopology interface
 */
#ifndef __IMFTopology_INTERFACE_DEFINED__
#define __IMFTopology_INTERFACE_DEFINED__

DEFINE_GUID(IID_IMFTopology, 0x83cf873a, 0xf6da, 0x4bc8, 0x82,0x3f, 0xba,0xcf,0xd5,0x5d,0xc4,0x33);
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("83cf873a-f6da-4bc8-823f-bacfd55dc433")
IMFTopology : public IMFAttributes
{
    virtual HRESULT STDMETHODCALLTYPE GetTopologyID(
        TOPOID *pID) = 0;

    virtual HRESULT STDMETHODCALLTYPE AddNode(
        IMFTopologyNode *pNode) = 0;

    virtual HRESULT STDMETHODCALLTYPE RemoveNode(
        IMFTopologyNode *pNode) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetNodeCount(
        WORD *pwNodes) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetNode(
        WORD wIndex,
        IMFTopologyNode **ppNode) = 0;

    virtual HRESULT STDMETHODCALLTYPE Clear(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE CloneFrom(
        IMFTopology *pTopology) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetNodeByID(
        TOPOID qwTopoNodeID,
        IMFTopologyNode **ppNode) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetSourceNodeCollection(
        IMFCollection **ppCollection) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetOutputNodeCollection(
        IMFCollection **ppCollection) = 0;

};
#ifdef __CRT_UUID_DECL
__CRT_UUID_DECL(IMFTopology, 0x83cf873a, 0xf6da, 0x4bc8, 0x82,0x3f, 0xba,0xcf,0xd5,0x5d,0xc4,0x33)
#endif
#else
typedef struct IMFTopologyVtbl {
    BEGIN_INTERFACE

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

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

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

    /*** IMFAttributes methods ***/
    HRESULT (STDMETHODCALLTYPE *GetItem)(
        IMFTopology* This,
        REFGUID guidKey,
        PROPVARIANT *pValue);

    HRESULT (STDMETHODCALLTYPE *GetItemType)(
        IMFTopology* This,
        REFGUID guidKey,
        MF_ATTRIBUTE_TYPE *pType);

    HRESULT (STDMETHODCALLTYPE *CompareItem)(
        IMFTopology* This,
        REFGUID guidKey,
        REFPROPVARIANT Value,
        WINBOOL *pbResult);

    HRESULT (STDMETHODCALLTYPE *Compare)(
        IMFTopology* This,
        IMFAttributes *pTheirs,
        MF_ATTRIBUTES_MATCH_TYPE MatchType,
        WINBOOL *pbResult);

    HRESULT (STDMETHODCALLTYPE *GetUINT32)(
        IMFTopology* This,
        REFGUID guidKey,
        UINT32 *punValue);

    HRESULT (STDMETHODCALLTYPE *GetUINT64)(
        IMFTopology* This,
        REFGUID guidKey,
        UINT64 *punValue);

    HRESULT (STDMETHODCALLTYPE *GetDouble)(
        IMFTopology* This,
        REFGUID guidKey,
        double *pfValue);

    HRESULT (STDMETHODCALLTYPE *GetGUID)(
        IMFTopology* This,
        REFGUID guidKey,
        GUID *pguidValue);

    HRESULT (STDMETHODCALLTYPE *GetStringLength)(
        IMFTopology* This,
        REFGUID guidKey,
        UINT32 *pcchLength);

    HRESULT (STDMETHODCALLTYPE *GetString)(
        IMFTopology* This,
        REFGUID guidKey,
        LPWSTR pwszValue,
        UINT32 cchBufSize,
        UINT32 *pcchLength);

    HRESULT (STDMETHODCALLTYPE *GetAllocatedString)(
        IMFTopology* This,
        REFGUID guidKey,
        LPWSTR *ppwszValue,
        UINT32 *pcchLength);

    HRESULT (STDMETHODCALLTYPE *GetBlobSize)(
        IMFTopology* This,
        REFGUID guidKey,
        UINT32 *pcbBlobSize);

    HRESULT (STDMETHODCALLTYPE *GetBlob)(
        IMFTopology* This,
        REFGUID guidKey,
        UINT8 *pBuf,
        UINT32 cbBufSize,
        UINT32 *pcbBlobSize);

    HRESULT (STDMETHODCALLTYPE *GetAllocatedBlob)(
        IMFTopology* This,
        REFGUID guidKey,
        UINT8 **ppBuf,
        UINT32 *pcbSize);

    HRESULT (STDMETHODCALLTYPE *GetUnknown)(
        IMFTopology* This,
        REFGUID guidKey,
        REFIID riid,
        LPVOID *ppv);

    HRESULT (STDMETHODCALLTYPE *SetItem)(
        IMFTopology* This,
        REFGUID guidKey,
        REFPROPVARIANT Value);

    HRESULT (STDMETHODCALLTYPE *DeleteItem)(
        IMFTopology* This,
        REFGUID guidKey);

    HRESULT (STDMETHODCALLTYPE *DeleteAllItems)(
        IMFTopology* This);

    HRESULT (STDMETHODCALLTYPE *SetUINT32)(
        IMFTopology* This,
        REFGUID guidKey,
        UINT32 unValue);

    HRESULT (STDMETHODCALLTYPE *SetUINT64)(
        IMFTopology* This,
        REFGUID guidKey,
        UINT64 unValue);

    HRESULT (STDMETHODCALLTYPE *SetDouble)(
        IMFTopology* This,
        REFGUID guidKey,
        double fValue);

    HRESULT (STDMETHODCALLTYPE *SetGUID)(
        IMFTopology* This,
        REFGUID guidKey,
        REFGUID guidValue);

    HRESULT (STDMETHODCALLTYPE *SetString)(
        IMFTopology* This,
        REFGUID guidKey,
        LPCWSTR wszValue);

    HRESULT (STDMETHODCALLTYPE *SetBlob)(
        IMFTopology* This,
        REFGUID guidKey,
        const UINT8 *pBuf,
        UINT32 cbBufSize);

    HRESULT (STDMETHODCALLTYPE *SetUnknown)(
        IMFTopology* This,
        REFGUID guidKey,
        IUnknown *pUnknown);

    HRESULT (STDMETHODCALLTYPE *LockStore)(
        IMFTopology* This);

    HRESULT (STDMETHODCALLTYPE *UnlockStore)(
        IMFTopology* This);

    HRESULT (STDMETHODCALLTYPE *GetCount)(
        IMFTopology* This,
        UINT32 *pcItems);

    HRESULT (STDMETHODCALLTYPE *GetItemByIndex)(
        IMFTopology* This,
        UINT32 unIndex,
        GUID *pguidKey,
        PROPVARIANT *pValue);

    HRESULT (STDMETHODCALLTYPE *CopyAllItems)(
        IMFTopology* This,
        IMFAttributes *pDest);

    /*** IMFTopology methods ***/
    HRESULT (STDMETHODCALLTYPE *GetTopologyID)(
        IMFTopology* This,
        TOPOID *pID);

    HRESULT (STDMETHODCALLTYPE *AddNode)(
        IMFTopology* This,
        IMFTopologyNode *pNode);

    HRESULT (STDMETHODCALLTYPE *RemoveNode)(
        IMFTopology* This,
        IMFTopologyNode *pNode);

    HRESULT (STDMETHODCALLTYPE *GetNodeCount)(
        IMFTopology* This,
        WORD *pwNodes);

    HRESULT (STDMETHODCALLTYPE *GetNode)(
        IMFTopology* This,
        WORD wIndex,
        IMFTopologyNode **ppNode);

    HRESULT (STDMETHODCALLTYPE *Clear)(
        IMFTopology* This);

    HRESULT (STDMETHODCALLTYPE *CloneFrom)(
        IMFTopology* This,
        IMFTopology *pTopology);

    HRESULT (STDMETHODCALLTYPE *GetNodeByID)(
        IMFTopology* This,
        TOPOID qwTopoNodeID,
        IMFTopologyNode **ppNode);

    HRESULT (STDMETHODCALLTYPE *GetSourceNodeCollection)(
        IMFTopology* This,
        IMFCollection **ppCollection);

    HRESULT (STDMETHODCALLTYPE *GetOutputNodeCollection)(
        IMFTopology* This,
        IMFCollection **ppCollection);

    END_INTERFACE
} IMFTopologyVtbl;
interface IMFTopology {
    CONST_VTBL IMFTopologyVtbl* lpVtbl;
};

#ifdef COBJMACROS
#ifndef WIDL_C_INLINE_WRAPPERS
/*** IUnknown methods ***/
#define IMFTopology_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
#define IMFTopology_AddRef(This) (This)->lpVtbl->AddRef(This)
#define IMFTopology_Release(This) (This)->lpVtbl->Release(This)
/*** IMFAttributes methods ***/
#define IMFTopology_GetItem(This,guidKey,pValue) (This)->lpVtbl->GetItem(This,guidKey,pValue)
#define IMFTopology_GetItemType(This,guidKey,pType) (This)->lpVtbl->GetItemType(This,guidKey,pType)
#define IMFTopology_CompareItem(This,guidKey,Value,pbResult) (This)->lpVtbl->CompareItem(This,guidKey,Value,pbResult)
#define IMFTopology_Compare(This,pTheirs,MatchType,pbResult) (This)->lpVtbl->Compare(This,pTheirs,MatchType,pbResult)
#define IMFTopology_GetUINT32(This,guidKey,punValue) (This)->lpVtbl->GetUINT32(This,guidKey,punValue)
#define IMFTopology_GetUINT64(This,guidKey,punValue) (This)->lpVtbl->GetUINT64(This,guidKey,punValue)
#define IMFTopology_GetDouble(This,guidKey,pfValue) (This)->lpVtbl->GetDouble(This,guidKey,pfValue)
#define IMFTopology_GetGUID(This,guidKey,pguidValue) (This)->lpVtbl->GetGUID(This,guidKey,pguidValue)
#define IMFTopology_GetStringLength(This,guidKey,pcchLength) (This)->lpVtbl->GetStringLength(This,guidKey,pcchLength)
#define IMFTopology_GetString(This,guidKey,pwszValue,cchBufSize,pcchLength) (This)->lpVtbl->GetString(This,guidKey,pwszValue,cchBufSize,pcchLength)
#define IMFTopology_GetAllocatedString(This,guidKey,ppwszValue,pcchLength) (This)->lpVtbl->GetAllocatedString(This,guidKey,ppwszValue,pcchLength)
#define IMFTopology_GetBlobSize(This,guidKey,pcbBlobSize) (This)->lpVtbl->GetBlobSize(This,guidKey,pcbBlobSize)
#define IMFTopology_GetBlob(This,guidKey,pBuf,cbBufSize,pcbBlobSize) (This)->lpVtbl->GetBlob(This,guidKey,pBuf,cbBufSize,pcbBlobSize)
#define IMFTopology_GetAllocatedBlob(This,guidKey,ppBuf,pcbSize) (This)->lpVtbl->GetAllocatedBlob(This,guidKey,ppBuf,pcbSize)
#define IMFTopology_GetUnknown(This,guidKey,riid,ppv) (This)->lpVtbl->GetUnknown(This,guidKey,riid,ppv)
#define IMFTopology_SetItem(This,guidKey,Value) (This)->lpVtbl->SetItem(This,guidKey,Value)
#define IMFTopology_DeleteItem(This,guidKey) (This)->lpVtbl->DeleteItem(This,guidKey)
#define IMFTopology_DeleteAllItems(This) (This)->lpVtbl->DeleteAllItems(This)
#define IMFTopology_SetUINT32(This,guidKey,unValue) (This)->lpVtbl->SetUINT32(This,guidKey,unValue)
#define IMFTopology_SetUINT64(This,guidKey,unValue) (This)->lpVtbl->SetUINT64(This,guidKey,unValue)
#define IMFTopology_SetDouble(This,guidKey,fValue) (This)->lpVtbl->SetDouble(This,guidKey,fValue)
#define IMFTopology_SetGUID(This,guidKey,guidValue) (This)->lpVtbl->SetGUID(This,guidKey,guidValue)
#define IMFTopology_SetString(This,guidKey,wszValue) (This)->lpVtbl->SetString(This,guidKey,wszValue)
#define IMFTopology_SetBlob(This,guidKey,pBuf,cbBufSize) (This)->lpVtbl->SetBlob(This,guidKey,pBuf,cbBufSize)
#define IMFTopology_SetUnknown(This,guidKey,pUnknown) (This)->lpVtbl->SetUnknown(This,guidKey,pUnknown)
#define IMFTopology_LockStore(This) (This)->lpVtbl->LockStore(This)
#define IMFTopology_UnlockStore(This) (This)->lpVtbl->UnlockStore(This)
#define IMFTopology_GetCount(This,pcItems) (This)->lpVtbl->GetCount(This,pcItems)
#define IMFTopology_GetItemByIndex(This,unIndex,pguidKey,pValue) (This)->lpVtbl->GetItemByIndex(This,unIndex,pguidKey,pValue)
#define IMFTopology_CopyAllItems(This,pDest) (This)->lpVtbl->CopyAllItems(This,pDest)
/*** IMFTopology methods ***/
#define IMFTopology_GetTopologyID(This,pID) (This)->lpVtbl->GetTopologyID(This,pID)
#define IMFTopology_AddNode(This,pNode) (This)->lpVtbl->AddNode(This,pNode)
#define IMFTopology_RemoveNode(This,pNode) (This)->lpVtbl->RemoveNode(This,pNode)
#define IMFTopology_GetNodeCount(This,pwNodes) (This)->lpVtbl->GetNodeCount(This,pwNodes)
#define IMFTopology_GetNode(This,wIndex,ppNode) (This)->lpVtbl->GetNode(This,wIndex,ppNode)
#define IMFTopology_Clear(This) (This)->lpVtbl->Clear(This)
#define IMFTopology_CloneFrom(This,pTopology) (This)->lpVtbl->CloneFrom(This,pTopology)
#define IMFTopology_GetNodeByID(This,qwTopoNodeID,ppNode) (This)->lpVtbl->GetNodeByID(This,qwTopoNodeID,ppNode)
#define IMFTopology_GetSourceNodeCollection(This,ppCollection) (This)->lpVtbl->GetSourceNodeCollection(This,ppCollection)
#define IMFTopology_GetOutputNodeCollection(This,ppCollection) (This)->lpVtbl->GetOutputNodeCollection(This,ppCollection)
#else
/*** IUnknown methods ***/
static FORCEINLINE HRESULT IMFTopology_QueryInterface(IMFTopology* This,REFIID riid,void **ppvObject) {
    return This->lpVtbl->QueryInterface(This,riid,ppvObject);
}
static FORCEINLINE ULONG IMFTopology_AddRef(IMFTopology* This) {
    return This->lpVtbl->AddRef(This);
}
static FORCEINLINE ULONG IMFTopology_Release(IMFTopology* This) {
    return This->lpVtbl->Release(This);
}
/*** IMFAttributes methods ***/
static FORCEINLINE HRESULT IMFTopology_GetItem(IMFTopology* This,REFGUID guidKey,PROPVARIANT *pValue) {
    return This->lpVtbl->GetItem(This,guidKey,pValue);
}
static FORCEINLINE HRESULT IMFTopology_GetItemType(IMFTopology* This,REFGUID guidKey,MF_ATTRIBUTE_TYPE *pType) {
    return This->lpVtbl->GetItemType(This,guidKey,pType);
}
static FORCEINLINE HRESULT IMFTopology_CompareItem(IMFTopology* This,REFGUID guidKey,REFPROPVARIANT Value,WINBOOL *pbResult) {
    return This->lpVtbl->CompareItem(This,guidKey,Value,pbResult);
}
static FORCEINLINE HRESULT IMFTopology_Compare(IMFTopology* This,IMFAttributes *pTheirs,MF_ATTRIBUTES_MATCH_TYPE MatchType,WINBOOL *pbResult) {
    return This->lpVtbl->Compare(This,pTheirs,MatchType,pbResult);
}
static FORCEINLINE HRESULT IMFTopology_GetUINT32(IMFTopology* This,REFGUID guidKey,UINT32 *punValue) {
    return This->lpVtbl->GetUINT32(This,guidKey,punValue);
}
static FORCEINLINE HRESULT IMFTopology_GetUINT64(IMFTopology* This,REFGUID guidKey,UINT64 *punValue) {
    return This->lpVtbl->GetUINT64(This,guidKey,punValue);
}
static FORCEINLINE HRESULT IMFTopology_GetDouble(IMFTopology* This,REFGUID guidKey,double *pfValue) {
    return This->lpVtbl->GetDouble(This,guidKey,pfValue);
}
static FORCEINLINE HRESULT IMFTopology_GetGUID(IMFTopology* This,REFGUID guidKey,GUID *pguidValue) {
    return This->lpVtbl->GetGUID(This,guidKey,pguidValue);
}
static FORCEINLINE HRESULT IMFTopology_GetStringLength(IMFTopology* This,REFGUID guidKey,UINT32 *pcchLength) {
    return This->lpVtbl->GetStringLength(This,guidKey,pcchLength);
}
static FORCEINLINE HRESULT IMFTopology_GetString(IMFTopology* This,REFGUID guidKey,LPWSTR pwszValue,UINT32 cchBufSize,UINT32 *pcchLength) {
    return This->lpVtbl->GetString(This,guidKey,pwszValue,cchBufSize,pcchLength);
}
static FORCEINLINE HRESULT IMFTopology_GetAllocatedString(IMFTopology* This,REFGUID guidKey,LPWSTR *ppwszValue,UINT32 *pcchLength) {
    return This->lpVtbl->GetAllocatedString(This,guidKey,ppwszValue,pcchLength);
}
static FORCEINLINE HRESULT IMFTopology_GetBlobSize(IMFTopology* This,REFGUID guidKey,UINT32 *pcbBlobSize) {
    return This->lpVtbl->GetBlobSize(This,guidKey,pcbBlobSize);
}
static FORCEINLINE HRESULT IMFTopology_GetBlob(IMFTopology* This,REFGUID guidKey,UINT8 *pBuf,UINT32 cbBufSize,UINT32 *pcbBlobSize) {
    return This->lpVtbl->GetBlob(This,guidKey,pBuf,cbBufSize,pcbBlobSize);
}
static FORCEINLINE HRESULT IMFTopology_GetAllocatedBlob(IMFTopology* This,REFGUID guidKey,UINT8 **ppBuf,UINT32 *pcbSize) {
    return This->lpVtbl->GetAllocatedBlob(This,guidKey,ppBuf,pcbSize);
}
static FORCEINLINE HRESULT IMFTopology_GetUnknown(IMFTopology* This,REFGUID guidKey,REFIID riid,LPVOID *ppv) {
    return This->lpVtbl->GetUnknown(This,guidKey,riid,ppv);
}
static FORCEINLINE HRESULT IMFTopology_SetItem(IMFTopology* This,REFGUID guidKey,REFPROPVARIANT Value) {
    return This->lpVtbl->SetItem(This,guidKey,Value);
}
static FORCEINLINE HRESULT IMFTopology_DeleteItem(IMFTopology* This,REFGUID guidKey) {
    return This->lpVtbl->DeleteItem(This,guidKey);
}
static FORCEINLINE HRESULT IMFTopology_DeleteAllItems(IMFTopology* This) {
    return This->lpVtbl->DeleteAllItems(This);
}
static FORCEINLINE HRESULT IMFTopology_SetUINT32(IMFTopology* This,REFGUID guidKey,UINT32 unValue) {
    return This->lpVtbl->SetUINT32(This,guidKey,unValue);
}
static FORCEINLINE HRESULT IMFTopology_SetUINT64(IMFTopology* This,REFGUID guidKey,UINT64 unValue) {
    return This->lpVtbl->SetUINT64(This,guidKey,unValue);
}
static FORCEINLINE HRESULT IMFTopology_SetDouble(IMFTopology* This,REFGUID guidKey,double fValue) {
    return This->lpVtbl->SetDouble(This,guidKey,fValue);
}
static FORCEINLINE HRESULT IMFTopology_SetGUID(IMFTopology* This,REFGUID guidKey,REFGUID guidValue) {
    return This->lpVtbl->SetGUID(This,guidKey,guidValue);
}
static FORCEINLINE HRESULT IMFTopology_SetString(IMFTopology* This,REFGUID guidKey,LPCWSTR wszValue) {
    return This->lpVtbl->SetString(This,guidKey,wszValue);
}
static FORCEINLINE HRESULT IMFTopology_SetBlob(IMFTopology* This,REFGUID guidKey,const UINT8 *pBuf,UINT32 cbBufSize) {
    return This->lpVtbl->SetBlob(This,guidKey,pBuf,cbBufSize);
}
static FORCEINLINE HRESULT IMFTopology_SetUnknown(IMFTopology* This,REFGUID guidKey,IUnknown *pUnknown) {
    return This->lpVtbl->SetUnknown(This,guidKey,pUnknown);
}
static FORCEINLINE HRESULT IMFTopology_LockStore(IMFTopology* This) {
    return This->lpVtbl->LockStore(This);
}
static FORCEINLINE HRESULT IMFTopology_UnlockStore(IMFTopology* This) {
    return This->lpVtbl->UnlockStore(This);
}
static FORCEINLINE HRESULT IMFTopology_GetCount(IMFTopology* This,UINT32 *pcItems) {
    return This->lpVtbl->GetCount(This,pcItems);
}
static FORCEINLINE HRESULT IMFTopology_GetItemByIndex(IMFTopology* This,UINT32 unIndex,GUID *pguidKey,PROPVARIANT *pValue) {
    return This->lpVtbl->GetItemByIndex(This,unIndex,pguidKey,pValue);
}
static FORCEINLINE HRESULT IMFTopology_CopyAllItems(IMFTopology* This,IMFAttributes *pDest) {
    return This->lpVtbl->CopyAllItems(This,pDest);
}
/*** IMFTopology methods ***/
static FORCEINLINE HRESULT IMFTopology_GetTopologyID(IMFTopology* This,TOPOID *pID) {
    return This->lpVtbl->GetTopologyID(This,pID);
}
static FORCEINLINE HRESULT IMFTopology_AddNode(IMFTopology* This,IMFTopologyNode *pNode) {
    return This->lpVtbl->AddNode(This,pNode);
}
static FORCEINLINE HRESULT IMFTopology_RemoveNode(IMFTopology* This,IMFTopologyNode *pNode) {
    return This->lpVtbl->RemoveNode(This,pNode);
}
static FORCEINLINE HRESULT IMFTopology_GetNodeCount(IMFTopology* This,WORD *pwNodes) {
    return This->lpVtbl->GetNodeCount(This,pwNodes);
}
static FORCEINLINE HRESULT IMFTopology_GetNode(IMFTopology* This,WORD wIndex,IMFTopologyNode **ppNode) {
    return This->lpVtbl->GetNode(This,wIndex,ppNode);
}
static FORCEINLINE HRESULT IMFTopology_Clear(IMFTopology* This) {
    return This->lpVtbl->Clear(This);
}
static FORCEINLINE HRESULT IMFTopology_CloneFrom(IMFTopology* This,IMFTopology *pTopology) {
    return This->lpVtbl->CloneFrom(This,pTopology);
}
static FORCEINLINE HRESULT IMFTopology_GetNodeByID(IMFTopology* This,TOPOID qwTopoNodeID,IMFTopologyNode **ppNode) {
    return This->lpVtbl->GetNodeByID(This,qwTopoNodeID,ppNode);
}
static FORCEINLINE HRESULT IMFTopology_GetSourceNodeCollection(IMFTopology* This,IMFCollection **ppCollection) {
    return This->lpVtbl->GetSourceNodeCollection(This,ppCollection);
}
static FORCEINLINE HRESULT IMFTopology_GetOutputNodeCollection(IMFTopology* This,IMFCollection **ppCollection) {
    return This->lpVtbl->GetOutputNodeCollection(This,ppCollection);
}
#endif
#endif

#endif

HRESULT STDMETHODCALLTYPE IMFTopology_GetTopologyID_Proxy(
    IMFTopology* This,
    TOPOID *pID);
void __RPC_STUB IMFTopology_GetTopologyID_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFTopology_GetNodeCount_Proxy(
    IMFTopology* This,
    WORD *pwNodes);
void __RPC_STUB IMFTopology_GetNodeCount_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFTopology_GetNode_Proxy(
    IMFTopology* This,
    WORD wIndex,
    IMFTopologyNode **ppNode);
void __RPC_STUB IMFTopology_GetNode_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFTopology_CloneFrom_Proxy(
    IMFTopology* This,
    IMFTopology *pTopology);
void __RPC_STUB IMFTopology_CloneFrom_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFTopology_GetNodeByID_Proxy(
    IMFTopology* This,
    TOPOID qwTopoNodeID,
    IMFTopologyNode **ppNode);
void __RPC_STUB IMFTopology_GetNodeByID_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFTopology_GetSourceNodeCollection_Proxy(
    IMFTopology* This,
    IMFCollection **ppCollection);
void __RPC_STUB IMFTopology_GetSourceNodeCollection_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFTopology_GetOutputNodeCollection_Proxy(
    IMFTopology* This,
    IMFCollection **ppCollection);
void __RPC_STUB IMFTopology_GetOutputNodeCollection_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IMFTopology_INTERFACE_DEFINED__ */

typedef LONGLONG MFTIME;
typedef enum _MF_CLOCK_STATE {
    MFCLOCK_STATE_INVALID = 0,
    MFCLOCK_STATE_RUNNING = 1,
    MFCLOCK_STATE_STOPPED = 2,
    MFCLOCK_STATE_PAUSED = 3
} MF_CLOCK_STATE;
typedef enum _MF_CLOCK_STATE MFCLOCK_STATE;
typedef struct _MFCLOCK_PROPERTIES {
    UINT64 qwCorrelationRate;
    GUID guidClockId;
    DWORD dwClockFlags;
    UINT64 qwClockFrequency;
    DWORD dwClockTolerance;
    DWORD dwClockJitter;
} MFCLOCK_PROPERTIES;
/*****************************************************************************
 * IMFClock interface
 */
#ifndef __IMFClock_INTERFACE_DEFINED__
#define __IMFClock_INTERFACE_DEFINED__

DEFINE_GUID(IID_IMFClock, 0x2eb1e945, 0x18b8, 0x4139, 0x9b,0x1a, 0xd5,0xd5,0x84,0x81,0x85,0x30);
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("2eb1e945-18b8-4139-9b1a-d5d584818530")
IMFClock : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE GetClockCharacteristics(
        DWORD *pdwCharacteristics) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetCorrelatedTime(
        DWORD dwReserved,
        LONGLONG *pllClockTime,
        MFTIME *phnsSystemTime) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetContinuityKey(
        DWORD *pdwContinuityKey) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetState(
        DWORD dwReserved,
        MFCLOCK_STATE *peClockState) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetProperties(
        MFCLOCK_PROPERTIES *pClockProperties) = 0;

};
#ifdef __CRT_UUID_DECL
__CRT_UUID_DECL(IMFClock, 0x2eb1e945, 0x18b8, 0x4139, 0x9b,0x1a, 0xd5,0xd5,0x84,0x81,0x85,0x30)
#endif
#else
typedef struct IMFClockVtbl {
    BEGIN_INTERFACE

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

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

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

    /*** IMFClock methods ***/
    HRESULT (STDMETHODCALLTYPE *GetClockCharacteristics)(
        IMFClock* This,
        DWORD *pdwCharacteristics);

    HRESULT (STDMETHODCALLTYPE *GetCorrelatedTime)(
        IMFClock* This,
        DWORD dwReserved,
        LONGLONG *pllClockTime,
        MFTIME *phnsSystemTime);

    HRESULT (STDMETHODCALLTYPE *GetContinuityKey)(
        IMFClock* This,
        DWORD *pdwContinuityKey);

    HRESULT (STDMETHODCALLTYPE *GetState)(
        IMFClock* This,
        DWORD dwReserved,
        MFCLOCK_STATE *peClockState);

    HRESULT (STDMETHODCALLTYPE *GetProperties)(
        IMFClock* This,
        MFCLOCK_PROPERTIES *pClockProperties);

    END_INTERFACE
} IMFClockVtbl;
interface IMFClock {
    CONST_VTBL IMFClockVtbl* lpVtbl;
};

#ifdef COBJMACROS
#ifndef WIDL_C_INLINE_WRAPPERS
/*** IUnknown methods ***/
#define IMFClock_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
#define IMFClock_AddRef(This) (This)->lpVtbl->AddRef(This)
#define IMFClock_Release(This) (This)->lpVtbl->Release(This)
/*** IMFClock methods ***/
#define IMFClock_GetClockCharacteristics(This,pdwCharacteristics) (This)->lpVtbl->GetClockCharacteristics(This,pdwCharacteristics)
#define IMFClock_GetCorrelatedTime(This,dwReserved,pllClockTime,phnsSystemTime) (This)->lpVtbl->GetCorrelatedTime(This,dwReserved,pllClockTime,phnsSystemTime)
#define IMFClock_GetContinuityKey(This,pdwContinuityKey) (This)->lpVtbl->GetContinuityKey(This,pdwContinuityKey)
#define IMFClock_GetState(This,dwReserved,peClockState) (This)->lpVtbl->GetState(This,dwReserved,peClockState)
#define IMFClock_GetProperties(This,pClockProperties) (This)->lpVtbl->GetProperties(This,pClockProperties)
#else
/*** IUnknown methods ***/
static FORCEINLINE HRESULT IMFClock_QueryInterface(IMFClock* This,REFIID riid,void **ppvObject) {
    return This->lpVtbl->QueryInterface(This,riid,ppvObject);
}
static FORCEINLINE ULONG IMFClock_AddRef(IMFClock* This) {
    return This->lpVtbl->AddRef(This);
}
static FORCEINLINE ULONG IMFClock_Release(IMFClock* This) {
    return This->lpVtbl->Release(This);
}
/*** IMFClock methods ***/
static FORCEINLINE HRESULT IMFClock_GetClockCharacteristics(IMFClock* This,DWORD *pdwCharacteristics) {
    return This->lpVtbl->GetClockCharacteristics(This,pdwCharacteristics);
}
static FORCEINLINE HRESULT IMFClock_GetCorrelatedTime(IMFClock* This,DWORD dwReserved,LONGLONG *pllClockTime,MFTIME *phnsSystemTime) {
    return This->lpVtbl->GetCorrelatedTime(This,dwReserved,pllClockTime,phnsSystemTime);
}
static FORCEINLINE HRESULT IMFClock_GetContinuityKey(IMFClock* This,DWORD *pdwContinuityKey) {
    return This->lpVtbl->GetContinuityKey(This,pdwContinuityKey);
}
static FORCEINLINE HRESULT IMFClock_GetState(IMFClock* This,DWORD dwReserved,MFCLOCK_STATE *peClockState) {
    return This->lpVtbl->GetState(This,dwReserved,peClockState);
}
static FORCEINLINE HRESULT IMFClock_GetProperties(IMFClock* This,MFCLOCK_PROPERTIES *pClockProperties) {
    return This->lpVtbl->GetProperties(This,pClockProperties);
}
#endif
#endif

#endif

HRESULT STDMETHODCALLTYPE IMFClock_GetClockCharacteristics_Proxy(
    IMFClock* This,
    DWORD *pdwCharacteristics);
void __RPC_STUB IMFClock_GetClockCharacteristics_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFClock_GetCorrelatedTime_Proxy(
    IMFClock* This,
    DWORD dwReserved,
    LONGLONG *pllClockTime,
    MFTIME *phnsSystemTime);
void __RPC_STUB IMFClock_GetCorrelatedTime_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFClock_GetContinuityKey_Proxy(
    IMFClock* This,
    DWORD *pdwContinuityKey);
void __RPC_STUB IMFClock_GetContinuityKey_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFClock_GetState_Proxy(
    IMFClock* This,
    DWORD dwReserved,
    MFCLOCK_STATE *peClockState);
void __RPC_STUB IMFClock_GetState_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFClock_GetProperties_Proxy(
    IMFClock* This,
    MFCLOCK_PROPERTIES *pClockProperties);
void __RPC_STUB IMFClock_GetProperties_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IMFClock_INTERFACE_DEFINED__ */

#define SHA_HASH_LEN 20
#define STR_HASH_LEN (SHA_HASH_LEN*2+3)
typedef struct _MFRR_COMPONENT_HASH_INFO {
  DWORD ulReason;
  WCHAR rgHeaderHash[STR_HASH_LEN];
  WCHAR rgPublicKeyHash[STR_HASH_LEN];
  WCHAR wszName[MAX_PATH];
} MFRR_COMPONENT_HASH_INFO, *PMFRR_COMPONENT_HASH_INFO;
EXTERN_GUID(MF_PD_DURATION, 0x6c990d33,0xbb8e,0x477a,0x85,0x98,0xd,0x5d,0x96,0xfc,0xd8,0x8a);
typedef enum _MF_CONNECT_METHOD {
    MF_CONNECT_DIRECT = 0x0,
    MF_CONNECT_ALLOW_CONVERTER = 0x1,
    MF_CONNECT_ALLOW_DECODER = 0x3,
    MF_CONNECT_RESOLVE_INDEPENDENT_OUTPUTTYPES = 0x4,
    MF_CONNECT_AS_OPTIONAL = 0x10000,
    MF_CONNECT_AS_OPTIONAL_BRANCH = 0x20000
} MF_CONNECT_METHOD;
/*****************************************************************************
 * IMFMediaSession interface
 */
#ifndef __IMFMediaSession_INTERFACE_DEFINED__
#define __IMFMediaSession_INTERFACE_DEFINED__

DEFINE_GUID(IID_IMFMediaSession, 0x90377834, 0x21d0, 0x4dee, 0x82,0x14, 0xba,0x2e,0x3e,0x6c,0x11,0x27);
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("90377834-21d0-4dee-8214-ba2e3e6c1127")
IMFMediaSession : public IMFMediaEventGenerator
{
    virtual HRESULT STDMETHODCALLTYPE SetTopology(
        DWORD dwSetTopologyFlags,
        IMFTopology *pTopology) = 0;

    virtual HRESULT STDMETHODCALLTYPE ClearTopologies(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE Start(
        const GUID *pguidTimeFormat,
        const PROPVARIANT *pvarStartPosition) = 0;

    virtual HRESULT STDMETHODCALLTYPE Pause(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE Stop(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE Close(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE Shutdown(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetClock(
        IMFClock **ppClock) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetSessionCapabilities(
        DWORD *pdwCaps) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetFullTopology(
        DWORD dwGetFullTopologyFlags,
        TOPOID TopoId,
        IMFTopology **ppFullTopology) = 0;

};
#ifdef __CRT_UUID_DECL
__CRT_UUID_DECL(IMFMediaSession, 0x90377834, 0x21d0, 0x4dee, 0x82,0x14, 0xba,0x2e,0x3e,0x6c,0x11,0x27)
#endif
#else
typedef struct IMFMediaSessionVtbl {
    BEGIN_INTERFACE

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

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

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

    /*** IMFMediaEventGenerator methods ***/
    HRESULT (STDMETHODCALLTYPE *GetEvent)(
        IMFMediaSession* This,
        DWORD dwFlags,
        IMFMediaEvent **ppEvent);

    HRESULT (STDMETHODCALLTYPE *BeginGetEvent)(
        IMFMediaSession* This,
        IMFAsyncCallback *pCallback,
        IUnknown *punkState);

    HRESULT (STDMETHODCALLTYPE *EndGetEvent)(
        IMFMediaSession* This,
        IMFAsyncResult *pResult,
        IMFMediaEvent **ppEvent);

    HRESULT (STDMETHODCALLTYPE *QueueEvent)(
        IMFMediaSession* This,
        MediaEventType met,
        REFGUID guidExtendedType,
        HRESULT hrStatus,
        const PROPVARIANT *pvValue);

    /*** IMFMediaSession methods ***/
    HRESULT (STDMETHODCALLTYPE *SetTopology)(
        IMFMediaSession* This,
        DWORD dwSetTopologyFlags,
        IMFTopology *pTopology);

    HRESULT (STDMETHODCALLTYPE *ClearTopologies)(
        IMFMediaSession* This);

    HRESULT (STDMETHODCALLTYPE *Start)(
        IMFMediaSession* This,
        const GUID *pguidTimeFormat,
        const PROPVARIANT *pvarStartPosition);

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

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

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

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

    HRESULT (STDMETHODCALLTYPE *GetClock)(
        IMFMediaSession* This,
        IMFClock **ppClock);

    HRESULT (STDMETHODCALLTYPE *GetSessionCapabilities)(
        IMFMediaSession* This,
        DWORD *pdwCaps);

    HRESULT (STDMETHODCALLTYPE *GetFullTopology)(
        IMFMediaSession* This,
        DWORD dwGetFullTopologyFlags,
        TOPOID TopoId,
        IMFTopology **ppFullTopology);

    END_INTERFACE
} IMFMediaSessionVtbl;
interface IMFMediaSession {
    CONST_VTBL IMFMediaSessionVtbl* lpVtbl;
};

#ifdef COBJMACROS
#ifndef WIDL_C_INLINE_WRAPPERS
/*** IUnknown methods ***/
#define IMFMediaSession_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
#define IMFMediaSession_AddRef(This) (This)->lpVtbl->AddRef(This)
#define IMFMediaSession_Release(This) (This)->lpVtbl->Release(This)
/*** IMFMediaEventGenerator methods ***/
#define IMFMediaSession_GetEvent(This,dwFlags,ppEvent) (This)->lpVtbl->GetEvent(This,dwFlags,ppEvent)
#define IMFMediaSession_BeginGetEvent(This,pCallback,punkState) (This)->lpVtbl->BeginGetEvent(This,pCallback,punkState)
#define IMFMediaSession_EndGetEvent(This,pResult,ppEvent) (This)->lpVtbl->EndGetEvent(This,pResult,ppEvent)
#define IMFMediaSession_QueueEvent(This,met,guidExtendedType,hrStatus,pvValue) (This)->lpVtbl->QueueEvent(This,met,guidExtendedType,hrStatus,pvValue)
/*** IMFMediaSession methods ***/
#define IMFMediaSession_SetTopology(This,dwSetTopologyFlags,pTopology) (This)->lpVtbl->SetTopology(This,dwSetTopologyFlags,pTopology)
#define IMFMediaSession_ClearTopologies(This) (This)->lpVtbl->ClearTopologies(This)
#define IMFMediaSession_Start(This,pguidTimeFormat,pvarStartPosition) (This)->lpVtbl->Start(This,pguidTimeFormat,pvarStartPosition)
#define IMFMediaSession_Pause(This) (This)->lpVtbl->Pause(This)
#define IMFMediaSession_Stop(This) (This)->lpVtbl->Stop(This)
#define IMFMediaSession_Close(This) (This)->lpVtbl->Close(This)
#define IMFMediaSession_Shutdown(This) (This)->lpVtbl->Shutdown(This)
#define IMFMediaSession_GetClock(This,ppClock) (This)->lpVtbl->GetClock(This,ppClock)
#define IMFMediaSession_GetSessionCapabilities(This,pdwCaps) (This)->lpVtbl->GetSessionCapabilities(This,pdwCaps)
#define IMFMediaSession_GetFullTopology(This,dwGetFullTopologyFlags,TopoId,ppFullTopology) (This)->lpVtbl->GetFullTopology(This,dwGetFullTopologyFlags,TopoId,ppFullTopology)
#else
/*** IUnknown methods ***/
static FORCEINLINE HRESULT IMFMediaSession_QueryInterface(IMFMediaSession* This,REFIID riid,void **ppvObject) {
    return This->lpVtbl->QueryInterface(This,riid,ppvObject);
}
static FORCEINLINE ULONG IMFMediaSession_AddRef(IMFMediaSession* This) {
    return This->lpVtbl->AddRef(This);
}
static FORCEINLINE ULONG IMFMediaSession_Release(IMFMediaSession* This) {
    return This->lpVtbl->Release(This);
}
/*** IMFMediaEventGenerator methods ***/
static FORCEINLINE HRESULT IMFMediaSession_GetEvent(IMFMediaSession* This,DWORD dwFlags,IMFMediaEvent **ppEvent) {
    return This->lpVtbl->GetEvent(This,dwFlags,ppEvent);
}
static FORCEINLINE HRESULT IMFMediaSession_BeginGetEvent(IMFMediaSession* This,IMFAsyncCallback *pCallback,IUnknown *punkState) {
    return This->lpVtbl->BeginGetEvent(This,pCallback,punkState);
}
static FORCEINLINE HRESULT IMFMediaSession_EndGetEvent(IMFMediaSession* This,IMFAsyncResult *pResult,IMFMediaEvent **ppEvent) {
    return This->lpVtbl->EndGetEvent(This,pResult,ppEvent);
}
static FORCEINLINE HRESULT IMFMediaSession_QueueEvent(IMFMediaSession* This,MediaEventType met,REFGUID guidExtendedType,HRESULT hrStatus,const PROPVARIANT *pvValue) {
    return This->lpVtbl->QueueEvent(This,met,guidExtendedType,hrStatus,pvValue);
}
/*** IMFMediaSession methods ***/
static FORCEINLINE HRESULT IMFMediaSession_SetTopology(IMFMediaSession* This,DWORD dwSetTopologyFlags,IMFTopology *pTopology) {
    return This->lpVtbl->SetTopology(This,dwSetTopologyFlags,pTopology);
}
static FORCEINLINE HRESULT IMFMediaSession_ClearTopologies(IMFMediaSession* This) {
    return This->lpVtbl->ClearTopologies(This);
}
static FORCEINLINE HRESULT IMFMediaSession_Start(IMFMediaSession* This,const GUID *pguidTimeFormat,const PROPVARIANT *pvarStartPosition) {
    return This->lpVtbl->Start(This,pguidTimeFormat,pvarStartPosition);
}
static FORCEINLINE HRESULT IMFMediaSession_Pause(IMFMediaSession* This) {
    return This->lpVtbl->Pause(This);
}
static FORCEINLINE HRESULT IMFMediaSession_Stop(IMFMediaSession* This) {
    return This->lpVtbl->Stop(This);
}
static FORCEINLINE HRESULT IMFMediaSession_Close(IMFMediaSession* This) {
    return This->lpVtbl->Close(This);
}
static FORCEINLINE HRESULT IMFMediaSession_Shutdown(IMFMediaSession* This) {
    return This->lpVtbl->Shutdown(This);
}
static FORCEINLINE HRESULT IMFMediaSession_GetClock(IMFMediaSession* This,IMFClock **ppClock) {
    return This->lpVtbl->GetClock(This,ppClock);
}
static FORCEINLINE HRESULT IMFMediaSession_GetSessionCapabilities(IMFMediaSession* This,DWORD *pdwCaps) {
    return This->lpVtbl->GetSessionCapabilities(This,pdwCaps);
}
static FORCEINLINE HRESULT IMFMediaSession_GetFullTopology(IMFMediaSession* This,DWORD dwGetFullTopologyFlags,TOPOID TopoId,IMFTopology **ppFullTopology) {
    return This->lpVtbl->GetFullTopology(This,dwGetFullTopologyFlags,TopoId,ppFullTopology);
}
#endif
#endif

#endif

HRESULT STDMETHODCALLTYPE IMFMediaSession_SetTopology_Proxy(
    IMFMediaSession* This,
    DWORD dwSetTopologyFlags,
    IMFTopology *pTopology);
void __RPC_STUB IMFMediaSession_SetTopology_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFMediaSession_ClearTopologies_Proxy(
    IMFMediaSession* This);
void __RPC_STUB IMFMediaSession_ClearTopologies_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFMediaSession_Start_Proxy(
    IMFMediaSession* This,
    const GUID *pguidTimeFormat,
    const PROPVARIANT *pvarStartPosition);
void __RPC_STUB IMFMediaSession_Start_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFMediaSession_Pause_Proxy(
    IMFMediaSession* This);
void __RPC_STUB IMFMediaSession_Pause_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFMediaSession_Stop_Proxy(
    IMFMediaSession* This);
void __RPC_STUB IMFMediaSession_Stop_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFMediaSession_Close_Proxy(
    IMFMediaSession* This);
void __RPC_STUB IMFMediaSession_Close_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFMediaSession_Shutdown_Proxy(
    IMFMediaSession* This);
void __RPC_STUB IMFMediaSession_Shutdown_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFMediaSession_GetClock_Proxy(
    IMFMediaSession* This,
    IMFClock **ppClock);
void __RPC_STUB IMFMediaSession_GetClock_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFMediaSession_GetSessionCapabilities_Proxy(
    IMFMediaSession* This,
    DWORD *pdwCaps);
void __RPC_STUB IMFMediaSession_GetSessionCapabilities_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFMediaSession_GetFullTopology_Proxy(
    IMFMediaSession* This,
    DWORD dwGetFullTopologyFlags,
    TOPOID TopoId,
    IMFTopology **ppFullTopology);
void __RPC_STUB IMFMediaSession_GetFullTopology_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IMFMediaSession_INTERFACE_DEFINED__ */

/*****************************************************************************
 * IMFMediaTypeHandler interface
 */
#ifndef __IMFMediaTypeHandler_INTERFACE_DEFINED__
#define __IMFMediaTypeHandler_INTERFACE_DEFINED__

DEFINE_GUID(IID_IMFMediaTypeHandler, 0xe93dcf6c, 0x4b07, 0x4e1e, 0x81,0x23, 0xaa,0x16,0xed,0x6e,0xad,0xf5);
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("e93dcf6c-4b07-4e1e-8123-aa16ed6eadf5")
IMFMediaTypeHandler : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE IsMediaTypeSupported(
        IMFMediaType *pMediaType,
        IMFMediaType **ppMediaType) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetMediaTypeCount(
        DWORD *pdwTypeCount) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetMediaTypeByIndex(
        DWORD dwIndex,
        IMFMediaType **ppType) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetCurrentMediaType(
        IMFMediaType *pMediaType) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetCurrentMediaType(
        IMFMediaType **ppMediaType) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetMajorType(
        GUID *pguidMajorType) = 0;

};
#ifdef __CRT_UUID_DECL
__CRT_UUID_DECL(IMFMediaTypeHandler, 0xe93dcf6c, 0x4b07, 0x4e1e, 0x81,0x23, 0xaa,0x16,0xed,0x6e,0xad,0xf5)
#endif
#else
typedef struct IMFMediaTypeHandlerVtbl {
    BEGIN_INTERFACE

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

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

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

    /*** IMFMediaTypeHandler methods ***/
    HRESULT (STDMETHODCALLTYPE *IsMediaTypeSupported)(
        IMFMediaTypeHandler* This,
        IMFMediaType *pMediaType,
        IMFMediaType **ppMediaType);

    HRESULT (STDMETHODCALLTYPE *GetMediaTypeCount)(
        IMFMediaTypeHandler* This,
        DWORD *pdwTypeCount);

    HRESULT (STDMETHODCALLTYPE *GetMediaTypeByIndex)(
        IMFMediaTypeHandler* This,
        DWORD dwIndex,
        IMFMediaType **ppType);

    HRESULT (STDMETHODCALLTYPE *SetCurrentMediaType)(
        IMFMediaTypeHandler* This,
        IMFMediaType *pMediaType);

    HRESULT (STDMETHODCALLTYPE *GetCurrentMediaType)(
        IMFMediaTypeHandler* This,
        IMFMediaType **ppMediaType);

    HRESULT (STDMETHODCALLTYPE *GetMajorType)(
        IMFMediaTypeHandler* This,
        GUID *pguidMajorType);

    END_INTERFACE
} IMFMediaTypeHandlerVtbl;
interface IMFMediaTypeHandler {
    CONST_VTBL IMFMediaTypeHandlerVtbl* lpVtbl;
};

#ifdef COBJMACROS
#ifndef WIDL_C_INLINE_WRAPPERS
/*** IUnknown methods ***/
#define IMFMediaTypeHandler_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
#define IMFMediaTypeHandler_AddRef(This) (This)->lpVtbl->AddRef(This)
#define IMFMediaTypeHandler_Release(This) (This)->lpVtbl->Release(This)
/*** IMFMediaTypeHandler methods ***/
#define IMFMediaTypeHandler_IsMediaTypeSupported(This,pMediaType,ppMediaType) (This)->lpVtbl->IsMediaTypeSupported(This,pMediaType,ppMediaType)
#define IMFMediaTypeHandler_GetMediaTypeCount(This,pdwTypeCount) (This)->lpVtbl->GetMediaTypeCount(This,pdwTypeCount)
#define IMFMediaTypeHandler_GetMediaTypeByIndex(This,dwIndex,ppType) (This)->lpVtbl->GetMediaTypeByIndex(This,dwIndex,ppType)
#define IMFMediaTypeHandler_SetCurrentMediaType(This,pMediaType) (This)->lpVtbl->SetCurrentMediaType(This,pMediaType)
#define IMFMediaTypeHandler_GetCurrentMediaType(This,ppMediaType) (This)->lpVtbl->GetCurrentMediaType(This,ppMediaType)
#define IMFMediaTypeHandler_GetMajorType(This,pguidMajorType) (This)->lpVtbl->GetMajorType(This,pguidMajorType)
#else
/*** IUnknown methods ***/
static FORCEINLINE HRESULT IMFMediaTypeHandler_QueryInterface(IMFMediaTypeHandler* This,REFIID riid,void **ppvObject) {
    return This->lpVtbl->QueryInterface(This,riid,ppvObject);
}
static FORCEINLINE ULONG IMFMediaTypeHandler_AddRef(IMFMediaTypeHandler* This) {
    return This->lpVtbl->AddRef(This);
}
static FORCEINLINE ULONG IMFMediaTypeHandler_Release(IMFMediaTypeHandler* This) {
    return This->lpVtbl->Release(This);
}
/*** IMFMediaTypeHandler methods ***/
static FORCEINLINE HRESULT IMFMediaTypeHandler_IsMediaTypeSupported(IMFMediaTypeHandler* This,IMFMediaType *pMediaType,IMFMediaType **ppMediaType) {
    return This->lpVtbl->IsMediaTypeSupported(This,pMediaType,ppMediaType);
}
static FORCEINLINE HRESULT IMFMediaTypeHandler_GetMediaTypeCount(IMFMediaTypeHandler* This,DWORD *pdwTypeCount) {
    return This->lpVtbl->GetMediaTypeCount(This,pdwTypeCount);
}
static FORCEINLINE HRESULT IMFMediaTypeHandler_GetMediaTypeByIndex(IMFMediaTypeHandler* This,DWORD dwIndex,IMFMediaType **ppType) {
    return This->lpVtbl->GetMediaTypeByIndex(This,dwIndex,ppType);
}
static FORCEINLINE HRESULT IMFMediaTypeHandler_SetCurrentMediaType(IMFMediaTypeHandler* This,IMFMediaType *pMediaType) {
    return This->lpVtbl->SetCurrentMediaType(This,pMediaType);
}
static FORCEINLINE HRESULT IMFMediaTypeHandler_GetCurrentMediaType(IMFMediaTypeHandler* This,IMFMediaType **ppMediaType) {
    return This->lpVtbl->GetCurrentMediaType(This,ppMediaType);
}
static FORCEINLINE HRESULT IMFMediaTypeHandler_GetMajorType(IMFMediaTypeHandler* This,GUID *pguidMajorType) {
    return This->lpVtbl->GetMajorType(This,pguidMajorType);
}
#endif
#endif

#endif

HRESULT STDMETHODCALLTYPE IMFMediaTypeHandler_RemoteGetCurrentMediaType_Proxy(
    IMFMediaTypeHandler* This,
    BYTE **ppbData,
    DWORD *pcbData);
void __RPC_STUB IMFMediaTypeHandler_RemoteGetCurrentMediaType_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFMediaTypeHandler_GetMajorType_Proxy(
    IMFMediaTypeHandler* This,
    GUID *pguidMajorType);
void __RPC_STUB IMFMediaTypeHandler_GetMajorType_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMFMediaTypeHandler_GetCurrentMediaType_Proxy(
    IMFMediaTypeHandler* This,
    IMFMediaType **ppMediaType);
HRESULT __RPC_STUB IMFMediaTypeHandler_GetCurrentMediaType_Stub(
    IMFMediaTypeHandler* This,
    BYTE **ppbData,
    DWORD *pcbData);

#endif  /* __IMFMediaTypeHandler_INTERFACE_DEFINED__ */

/*****************************************************************************
 * IMFStreamDescriptor interface
 */
#ifndef __IMFStreamDescriptor_INTERFACE_DEFINED__
#define __IMFStreamDescriptor_INTERFACE_DEFINED__

DEFINE_GUID(IID_IMFStreamDescriptor, 0x56c03d9c, 0x9dbb, 0x45f5, 0xab,0x4b, 0xd8,0x0f,0x47,0xc0,0x59,0x38);
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("56c03d9c-9dbb-45f5-ab4b-d80f47c05938")
IMFStreamDescriptor : public IMFAttributes
{
    virtual HRESULT STDMETHODCALLTYPE GetStreamIdentifier(
        DWORD *pdwStreamIdentifier) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetMediaTypeHandler(
        IMFMediaTypeHandler **ppMediaTypeHandler) = 0;

};
#ifdef __CRT_UUID_DECL
__CRT_UUID_DECL(IMFStreamDescriptor, 0x56c03d9c, 0x9dbb, 0x45f5, 0xab,0x4b, 0xd8,0x0f,0x47,0xc0,0x59,0x38)
#endif
#else
typedef struct IMFStreamDescriptorVtbl {
    BEGIN_INTERFACE

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

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

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

    /*** IMFAttributes methods ***/
    HRESULT (STDMETHODCALLTYPE *GetItem)(
        IMFStreamDescriptor* This,
        REFGUID guidKey,
        PROPVARIANT *pValue);

    HRESULT (STDMETHODCALLTYPE *GetItemType)(
        IMFStreamDescriptor* This,
        REFGUID guidKey,
        MF_ATTRIBUTE_TYPE *pType);

    HRESULT (STDMETHODCALLTYPE *CompareItem)(
        IMFStreamDescriptor* This,
        REFGUID guidKey,
        REFPROPVARIANT Value,
        WINBOOL *pbResult);

    HRESULT (STDMETHODCALLTYPE *Compare)(
        IMFStreamDescriptor* This,
        IMFAttributes *pTheirs,
        MF_ATTRIBUTES_MATCH_TYPE MatchType,
        WINBOOL *pbResult);

    HRESULT (STDMETHODCALLTYPE *GetUINT32)(
        IMFStreamDescriptor* This,
        REFGUID guidKey,
        UINT32 *punValue);

    HRESULT (STDMETHODCALLTYPE *GetUINT64)(
        IMFStreamDescriptor* This,
        REFGUID guidKey,
        UINT64 *punValue);

    HRESULT (STDMETHODCALLTYPE *GetDouble)(
        IMFStreamDescriptor* This,
        REFGUID guidKey,
        double *pfValue);

    HRESULT (STDMETHODCALLTYPE *GetGUID)(
        IMFStreamDescriptor* This,
        REFGUID guidKey,
        GUID *pguidValue);

    HRESULT (STDMETHODCALLTYPE *GetStringLength)(
        IMFStreamDescriptor* This,
        REFGUID guidKey,
        UINT32 *pcchLength);

    HRESULT (STDMETHODCALLTYPE *GetString)(
        IMFStreamDescriptor* This,
        REFGUID guidKey,
        LPWSTR pwszValue,
        UINT32 cchBufSize,
        UINT32 *pcchLength);

    HRESULT (STDMETHODCALLTYPE *GetAllocatedString)(
        IMFStreamDescriptor* This,
        REFGUID guidKey,
        LPWSTR *ppwszValue,
        UINT32 *pcchLength);

    HRESULT (STDMETHODCALLTYPE *GetBlobSize)(
        IMFStreamDescriptor* This,
        REFGUID guidKey,
        UINT32 *pcbBlobSize);

    HRESULT (STDMETHODCALLTYPE *GetBlob)(
        IMFStreamDescriptor* This,
        REFGUID guidKey,
        UINT8 *pBuf,
        UINT32 cbBufSize,
        UINT32 *pcbBlobSize);

    HRESULT (STDMETHODCALLTYPE *GetAllocatedBlob)(
        IMFStreamDescriptor* This,
        REFGUID guidKey,
        UINT8 **ppBuf,
        UINT32 *pcbSize);

    HRESULT (STDMETHODCALLTYPE *GetUnknown)(
        IMFStreamDescriptor* This,
        REFGUID guidKey,
        REFIID riid,
        LPVOID *ppv);

    HRESULT (STDMETHODCALLTYPE *SetItem)(
        IMFStreamDescriptor* This,
        REFGUID guidKey,
        REFPROPVARIANT Value);

    HRESULT (STDMETHODCALLTYPE *DeleteItem)(
        IMFStreamDescriptor* This,
        REFGUID guidKey);

    HRESULT (STDMETHODCALLTYPE *DeleteAllItems)(
        IMFStreamDescriptor* This);

    HRESULT (STDMETHODCALLTYPE *SetUINT32)(
        IMFStreamDescriptor* This,
        REFGUID guidKey,
        UINT32 unValue);

    HRESULT (STDMETHODCALLTYPE *SetUINT64)(
        IMFStreamDescriptor* This,
        REFGUID guidKey,
        UINT64 unValue);

    HRESULT (STDMETHODCALLTYPE *SetDouble)(
        IMFStreamDescriptor* This,
        REFGUID guidKey,
        double fValue);

    HRESULT (STDMETHODCALLTYPE *SetGUID)(
        IMFStreamDescriptor* This,
        REFGUID guidKey,
        REFGUID guidValue);

    HRESULT (STDMETHODCALLTYPE *SetString)(
        IMFStreamDescriptor* This,
        REFGUID guidKey,
        LPCWSTR wszValue);

    HRESULT (STDMETHODCALLTYPE *SetBlob)(
        IMFStreamDescriptor* This,
        REFGUID guidKey,
        const UINT8 *pBuf,
        UINT32 cbBufSize);

    HRESULT (STDMETHODCALLTYPE *SetUnknown)(
        IMFStreamDescriptor* This,
        REFGUID guidKey,
        IUnknown *pUnknown);

    HRESULT (STDMETHODCALLTYPE *LockStore)(
        IMFStreamDescriptor* This);

    HRESULT (STDMETHODCALLTYPE *UnlockStore)(
        IMFStreamDescriptor* This);

    HRESULT (STDMETHODCALLTYPE *GetCount)(
        IMFStreamDescriptor* This,
        UINT32 *pcItems);

    HRESULT (STDMETHODCALLTYPE *GetItemByIndex)(
        IMFStreamDescriptor* This,
        UINT32 unIndex,
        GUID *pguidKey,
        PROPVARIANT *pValue);

    HRESULT (STDMETHODCALLTYPE *CopyAllItems)(
        IMFStreamDescriptor* This,
        IMFAttributes *pDest);

    /*** IMFStreamDescriptor methods ***/
    HRESULT (STDMETHODCALLTYPE *GetStreamIdentifier)(
        IMFStreamDescriptor* This,
        DWORD *pdwStreamIdentifier);

    HRESULT (STDMETHODCALLTYPE *GetMediaTypeHandler)(
        IMFStreamDescriptor* This,
        IMFMediaTypeHandler **ppMediaTypeHandler);

    END_INTERFACE
} IMFStreamDescriptorVtbl;
interface IMFStreamDescriptor {
    CONST_VTBL IMFStreamDescriptorVtbl* lpVtbl;
};

#ifdef COBJMACROS
#ifndef WIDL_C_INLINE_WRAPPERS
/*** IUnknown methods ***/
#define IMFStreamDescriptor_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
#define IMFStreamDescriptor_AddRef(This) (This)->lpVtbl->AddRef(This)
#define IMFStreamDescriptor_Release(This) (This)->lpVtbl->Release(This)
/*** IMFAttributes methods ***/
#define IMFStreamDescriptor_GetItem(This,guidKey,pValue) (This)->lpVtbl->GetItem(This,guidKey,pValue)
#define IMFStreamDescriptor_GetItemType(This,guidKey,pType) (This)->lpVtbl->GetItemType(This,guidKey,pType)
#define IMFStreamDescriptor_CompareItem(This,guidKey,Value,pbResult) (This)->lpVtbl->CompareItem(This,guidKey,Value,pbResult)
#define IMFStreamDescriptor_Compare(This,pTheirs,MatchType,pbResult) (This)->lpVtbl->Compare(This,pTheirs,MatchType,pbResult)
#define IMFStreamDescriptor_GetUINT32(This,guidKey,punValue) (This)->lpVtbl->GetUINT32(This,guidKey,punValue)
#define IMFStreamDescriptor_GetUINT64(This,guidKey,punValue) (This)->lpVtbl->GetUINT64(This,guidKey,punValue)
#define IMFStreamDescriptor_GetDouble(This,guidKey,pfValue) (This)->lpVtbl->GetDouble(This,guidKey,pfValue)
#define IMFStreamDescriptor_GetGUID(This,guidKey,pguidValue) (This)->lpVtbl->GetGUID(This,guidKey,pguidValue)
#define IMFStreamDescriptor_GetStringLength(This,guidKey,pcchLength) (This)->lpVtbl->GetStringLength(This,guidKey,pcchLength)
#define IMFStreamDescriptor_GetString(This,guidKey,pwszValue,cchBufSize,pcchLength) (This)->lpVtbl->GetString(This,guidKey,pwszValue,cchBufSize,pcchLength)
#define IMFStreamDescriptor_GetAllocatedString(This,guidKey,ppwszValue,pcchLength) (This)->lpVtbl->GetAllocatedString(This,guidKey,ppwszValue,pcchLength)
#define IMFStreamDescriptor_GetBlobSize(This,guidKey,pcbBlobSize) (This)->lpVtbl->GetBlobSize(This,guidKey,pcbBlobSize)
#define IMFStreamDescriptor_GetBlob(This,guidKey,pBuf,cbBufSize,pcbBlobSize) (This)->lpVtbl->GetBlob(This,guidKey,pBuf,cbBufSize,pcbBlobSize)
#define IMFStreamDescriptor_GetAllocatedBlob(This,guidKey,ppBuf,pcbSize) (This)->lpVtbl->GetAllocatedBlob(This,guidKey,ppBuf,pcbSize)
#define IMFStreamDescriptor_GetUnknown(This,guidKey,riid,ppv) (This)->lpVtbl->GetUnknown(This,guidKey,riid,ppv)
#define IMFStreamDescriptor_SetItem(This,guidKey,Value) (This)->lpVtbl->SetItem(This,guidKey,Value)
#define IMFStreamDescriptor_DeleteItem(This,guidKey) (This)->lpVtbl->DeleteItem(This,guidKey)
#define IMFStreamDescriptor_DeleteAllItems(This) (This)->lpVtbl->DeleteAllItems(This)
#define IMFStreamDescriptor_SetUINT32(This,guidKey,unValue) (This)->lpVtbl->SetUINT32(This,guidKey,unValue)
#define IMFStreamDescriptor_SetUINT64(This,guidKey,unValue) (This)->lpVtbl->SetUINT64(This,guidKey,unValue)
#define IMFStreamDescriptor_SetDouble(This,guidKey,fValue) (This)->lpVtbl->SetDouble(This,guidKey,fValue)
#define IMFStreamDescriptor_SetGUID(This,guidKey,guidValue) (This)->lpVtbl->SetGUID(This,guidKey,guidValue)
#define IMFStreamDescriptor_SetString(This,guidKey,wszValue) (This)->lpVtbl->SetString(This,guidKey,wszValue)
#define IMFStreamDescriptor_SetBlob(This,guidKey,pBuf,cbBufSize) (This)->lpVtbl->SetBlob(This,guidKey,pBuf,cbBufSize)
#define IMFStreamDescriptor_SetUnknown(This,guidKey,pUnknown) (This)->lpVtbl->SetUnknown(This,guidKey,pUnknown)
#define IMFStreamDescriptor_LockStore(This) (This)->lpVtbl->LockStore(This)
#define IMFStreamDescriptor_UnlockStore(This) (This)->lpVtbl->UnlockStore(This)
#define IMFStreamDescriptor_GetCount(This,pcItems) (This)->lpVtbl->GetCount(This,pcItems)
#define IMFStreamDescriptor_GetItemByIndex(This,unIndex,pguidKey,pValue) (This)->lpVtbl->GetItemByIndex(This,unIndex,pguidKey,pValue)
#define IMFStreamDescriptor_CopyAllItems(This,pDest) (This)->lpVtbl->CopyAllItems(This,pDest)
/*** IMFStreamDescriptor methods ***/
#define IMFStreamDescriptor_GetStreamIdentifier(This,pdwStreamIdentifier) (This)->lpVtbl->GetStreamIdentifier(This,pdwStreamIdentifier)
#define IMFStreamDescriptor_GetMediaTypeHandler(This,ppMediaTypeHandler) (This)->lpVtbl->GetMediaTypeHandler(This,ppMediaTypeHandler)
#else
/*** IUnknown methods ***/
static FORCEINLINE HRESULT IMFStreamDescriptor_QueryInterface(IMFStreamDescriptor* This,REFIID riid,void **ppvObject) {
    return This->lpVtbl->QueryInterface(This,riid,ppvObject);
}
static FORCEINLINE ULONG IMFStreamDescriptor_AddRef(IMFStreamDescriptor* This) {
    return This->lpVtbl->AddRef(This);
}
static FORCEINLINE ULONG IMFStreamDescriptor_Release(IMFStreamDescriptor* This) {
    return This->lpVtbl->Release(This);
}
/*** IMFAttributes methods ***/
static FORCEINLINE HRESULT IMFStreamDescriptor_GetItem(IMFStreamDescriptor* This,REFGUID guidKey,PROPVARIANT *pValue) {
    return This->lpVtbl->GetItem(This,guidKey,pValue);
}
static FORCEINLINE HRESULT IMFStreamDescriptor_GetItemType(IMFStreamDescriptor* This,REFGUID guidKey,MF_ATTRIBUTE_TYPE *pType) {
    return This->lpVtbl->GetItemType(This,guidKey,pType);
}
static FORCEINLINE HRESULT IMFStreamDescriptor_CompareItem(IMFStreamDescriptor* This,REFGUID guidKey,REFPROPVARIANT Value,WINBOOL *pbResult) {
    return This->lpVtbl->CompareItem(This,guidKey,Value,pbResult);
}
static FORCEINLINE HRESULT IMFStreamDescriptor_Compare(IMFStreamDescriptor* This,IMFAttributes *pTheirs,MF_ATTRIBUTES_MATCH_TYPE MatchType,WINBOOL *pbResult) {
    return This->lpVtbl->Compare(This,pTheirs,MatchType,pbResult);
}
static FORCEINLINE HRESULT IMFStreamDescriptor_GetUINT32(IMFStreamDescriptor* This,REFGUID guidKey,UINT32 *punValue) {
    return This->lpVtbl->GetUINT32(This,guidKey,punValue);
}
static FORCEINLINE HRESULT IMFStreamDescriptor_GetUINT64(IMFStreamDescriptor* This,REFGUID guidKey,UINT64 *punValue) {
    return This->lpVtbl->GetUINT64(This,guidKey,punValue);
}
static FORCEINLINE HRESULT IMFStreamDescriptor_GetDouble(IMFStreamDescriptor* This,REFGUID guidKey,double *pfValue) {
    return This->lpVtbl->GetDouble(This,guidKey,pfValue);
}
static FORCEINLINE HRESULT IMFStreamDescriptor_GetGUID(IMFStreamDescriptor* This,REFGUID guidKey,GUID *pguidValue) {
    return This->lpVtbl->GetGUID(This,guidKey,pguidValue);
}
static FORCEINLINE HRESULT IMFStreamDescriptor_GetStringLength(IMFStreamDescriptor* This,REFGUID guidKey,UINT32 *pcchLength) {
    return This->lpVtbl->GetStringLength(This,guidKey,pcchLength);
}
static FORCEINLINE HRESULT IMFStreamDescriptor_GetString(IMFStreamDescriptor* This,REFGUID guidKey,LPWSTR pwszValue,UINT32 cchBufSize,UINT32 *pcchLength) {
    return This->lpVtbl->GetString(This,guidKey,pwszValue,cchBufSize,pcchLength);
}
static FORCEINLINE HRESULT IMFStreamDescriptor_GetAllocatedString(IMFStreamDescriptor* This,REFGUID guidKey,LPWSTR *ppwszValue,UINT32 *pcchLength) {
    return This->lpVtbl->GetAllocatedString(This,guidKey,ppwszValue,pcchLength);
}
static FORCEINLINE HRESULT IMFStreamDescriptor_GetBlobSize(IMFStreamDescriptor* This,REFGUID guidKey,UINT32 *pcbBlobSize) {
    return This->lpVtbl->GetBlobSize(This,guidKey,pcbBlobSize);
}
static FORCEINLINE HRESULT IMFStreamDescriptor_GetBlob(IMFStreamDescriptor* This,REFGUID guidKey,UINT8 *pBuf,UINT32 cbBufSize,UINT32 *pcbBlobSize) {
    return This->lpVtbl->GetBlob(This,guidKey,pBuf,cbBufSize,pcbBlobSize);
}
static FORCEINLINE HRESULT IMFStreamDescriptor_GetAllocatedBlob(IMFStreamDescriptor* This,REFGUID guidKey,UINT8 **ppBuf,UINT32 *pcbSize) {
    return This->lpVtbl->GetAllocatedBlob(This,guidKey,ppBuf,pcbSize);
}
static FORCEINLINE HRESULT IMFStreamDescriptor_GetUnknown(IMFStreamDescriptor* This,REFGUID guidKey,REFIID riid,LPVOID *ppv) {
    return This->lpVtbl->GetUnknown(This,guidKey,riid,ppv);
}
static FORCEINLINE HRESULT IMFStreamDescriptor_SetItem(IMFStreamDescriptor* This,REFGUID guidKey,REFPROPVARIANT Value) {
    return This->lpVtbl->SetItem(This,guidKey,Value);
}
static FORCEINLINE HRESULT IMFStreamDescriptor_DeleteItem(IMFStreamDescriptor* This,REFGUID guidKey) {
    return This->lpVtbl->DeleteItem(This,guidKey);
}
static FORCEINLINE HRESULT IMFStreamDescriptor_DeleteAllItems(IMFStreamDescriptor* This) {
    return This->lpVtbl->DeleteAllItems(This);
}
static FORCEINLINE HRESULT IMFStreamDescriptor_SetUINT32(IMFStreamDescriptor* This,REFGUID guidKey,UINT32 unValue) {
    return This->lpVtbl->SetUINT32(This,guidKey,unValue);
}
static FORCEINLINE HRESULT IMFStreamDescriptor_SetUINT64(IMFStreamDescriptor* This,REFGUID guidKey,UINT64 unValue) {
    return This->lpVtbl->SetUINT64(This,guidKey,unValue);
}
static FORCEINLINE HRESULT IMFStreamDescriptor_SetDouble(IMFStreamDescriptor* This,REFGUID guidKey,double fValue) {
    return This->lpVtbl->SetDouble(This,guidKey,fValue);
}
static FORCEINLINE HRESULT IMFStreamDescriptor_SetGUID(IMFStreamDescriptor* This,REFGUID guidKey,REFGUID guidValue) {
    return This->lpVtbl->SetGUID(This,guidKey,guidValue);
}
static FORCEINLINE HRESULT IMFStreamDescriptor_SetString(IMFStreamDescriptor* This,REFGUID guidKey,LPCWSTR wszValue) {
    return This->lpVtbl->SetString(This,guidKey,wszValue);
}
static FORCEINLINE HRESULT IMFStreamDescriptor_SetBlob(IMFStreamDescriptor* This,REFGUID guidKey,const UINT8 *pBuf,UINT32 cbBufSize) {
    return This->lpVtbl->SetBlob(This,guidKey,pBuf,cbBufSize);
}
static FORCEINLINE HRESULT IMFStreamDescriptor_SetUnknown(IMFStreamDescriptor* This,REFGUID guidKey,IUnknown *pUnknown) {
    return This->lpVtbl->SetUnknown(This,guidKey,pUnknown);
}
static FORCEINLINE HRESULT IMFStreamDescriptor_LockStore(IMFStreamDescriptor* This) {
    return This->lpVtbl->LockStore(This);
}
static FORCEINLINE HRESULT IMFStreamDescriptor_UnlockStore(IMFStreamDescriptor* This) {
    return This->lpVtbl->UnlockStore(This);
}
static FORCEINLINE HRESULT IMFStreamDescriptor_GetCount(IMFStreamDescriptor* This,UINT32 *pcItems) {
    return This->lpVtbl->GetCount(This,pcItems);
}
static FORCEINLINE HRESULT IMFStreamDescriptor_GetItemByIndex(IMFStreamDescriptor* This,UINT32 unIndex,GUID *pguidKey,PROPVARIANT *pValue) {
    return This->lpVtbl->GetItemByIndex(This,unIndex,pguidKey,pValue);
}
static FORCEINLINE HRESULT IMFStreamDescriptor_CopyAllItems(IMFStreamDescriptor* This,IMFAttributes *pDest) {
    return This->lpVtbl->CopyAllItems(This,pDest);
}
/*** IMFStreamDescriptor methods ***/
static FORCEINLINE HRESULT IMFStreamDescriptor_GetStreamIdentifier(IMFStreamDescriptor* This,DWORD *pdwStreamIdentifier) {
    return This->lpVtbl->GetStreamIdentifier(This,pdwStreamIdentifier);
}
static FORCEINLINE HRESULT IMFStreamDescriptor_GetMediaTypeHandler(IMFStreamDescriptor* This,IMFMediaTypeHandler **ppMediaTypeHandler) {
    return This->lpVtbl->GetMediaTypeHandler(This,ppMediaTypeHandler);
}
#endif
#endif

#endif

HRESULT STDMETHODCALLTYPE IMFStreamDescriptor_GetStreamIdentifier_Proxy(
    IMFStreamDescriptor* This,
    DWORD *pdwStreamIdentifier);
void __RPC_STUB IMFStreamDescriptor_GetStreamIdentifier_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFStreamDescriptor_GetMediaTypeHandler_Proxy(
    IMFStreamDescriptor* This,
    IMFMediaTypeHandler **ppMediaTypeHandler);
void __RPC_STUB IMFStreamDescriptor_GetMediaTypeHandler_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IMFStreamDescriptor_INTERFACE_DEFINED__ */

/*****************************************************************************
 * IMFPresentationDescriptor interface
 */
#ifndef __IMFPresentationDescriptor_INTERFACE_DEFINED__
#define __IMFPresentationDescriptor_INTERFACE_DEFINED__

DEFINE_GUID(IID_IMFPresentationDescriptor, 0x03cb2711, 0x24d7, 0x4db6, 0xa1,0x7f, 0xf3,0xa7,0xa4,0x79,0xa5,0x36);
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("03cb2711-24d7-4db6-a17f-f3a7a479a536")
IMFPresentationDescriptor : public IMFAttributes
{
    virtual HRESULT STDMETHODCALLTYPE GetStreamDescriptorCount(
        DWORD *pdwDescriptorCount) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetStreamDescriptorByIndex(
        DWORD dwIndex,
        WINBOOL *pfSelected,
        IMFStreamDescriptor **ppDescriptor) = 0;

    virtual HRESULT STDMETHODCALLTYPE SelectStream(
        DWORD dwDescriptorIndex) = 0;

    virtual HRESULT STDMETHODCALLTYPE DeselectStream(
        DWORD dwDescriptorIndex) = 0;

    virtual HRESULT STDMETHODCALLTYPE Clone(
        IMFPresentationDescriptor **ppPresentationDescriptor) = 0;

};
#ifdef __CRT_UUID_DECL
__CRT_UUID_DECL(IMFPresentationDescriptor, 0x03cb2711, 0x24d7, 0x4db6, 0xa1,0x7f, 0xf3,0xa7,0xa4,0x79,0xa5,0x36)
#endif
#else
typedef struct IMFPresentationDescriptorVtbl {
    BEGIN_INTERFACE

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

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

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

    /*** IMFAttributes methods ***/
    HRESULT (STDMETHODCALLTYPE *GetItem)(
        IMFPresentationDescriptor* This,
        REFGUID guidKey,
        PROPVARIANT *pValue);

    HRESULT (STDMETHODCALLTYPE *GetItemType)(
        IMFPresentationDescriptor* This,
        REFGUID guidKey,
        MF_ATTRIBUTE_TYPE *pType);

    HRESULT (STDMETHODCALLTYPE *CompareItem)(
        IMFPresentationDescriptor* This,
        REFGUID guidKey,
        REFPROPVARIANT Value,
        WINBOOL *pbResult);

    HRESULT (STDMETHODCALLTYPE *Compare)(
        IMFPresentationDescriptor* This,
        IMFAttributes *pTheirs,
        MF_ATTRIBUTES_MATCH_TYPE MatchType,
        WINBOOL *pbResult);

    HRESULT (STDMETHODCALLTYPE *GetUINT32)(
        IMFPresentationDescriptor* This,
        REFGUID guidKey,
        UINT32 *punValue);

    HRESULT (STDMETHODCALLTYPE *GetUINT64)(
        IMFPresentationDescriptor* This,
        REFGUID guidKey,
        UINT64 *punValue);

    HRESULT (STDMETHODCALLTYPE *GetDouble)(
        IMFPresentationDescriptor* This,
        REFGUID guidKey,
        double *pfValue);

    HRESULT (STDMETHODCALLTYPE *GetGUID)(
        IMFPresentationDescriptor* This,
        REFGUID guidKey,
        GUID *pguidValue);

    HRESULT (STDMETHODCALLTYPE *GetStringLength)(
        IMFPresentationDescriptor* This,
        REFGUID guidKey,
        UINT32 *pcchLength);

    HRESULT (STDMETHODCALLTYPE *GetString)(
        IMFPresentationDescriptor* This,
        REFGUID guidKey,
        LPWSTR pwszValue,
        UINT32 cchBufSize,
        UINT32 *pcchLength);

    HRESULT (STDMETHODCALLTYPE *GetAllocatedString)(
        IMFPresentationDescriptor* This,
        REFGUID guidKey,
        LPWSTR *ppwszValue,
        UINT32 *pcchLength);

    HRESULT (STDMETHODCALLTYPE *GetBlobSize)(
        IMFPresentationDescriptor* This,
        REFGUID guidKey,
        UINT32 *pcbBlobSize);

    HRESULT (STDMETHODCALLTYPE *GetBlob)(
        IMFPresentationDescriptor* This,
        REFGUID guidKey,
        UINT8 *pBuf,
        UINT32 cbBufSize,
        UINT32 *pcbBlobSize);

    HRESULT (STDMETHODCALLTYPE *GetAllocatedBlob)(
        IMFPresentationDescriptor* This,
        REFGUID guidKey,
        UINT8 **ppBuf,
        UINT32 *pcbSize);

    HRESULT (STDMETHODCALLTYPE *GetUnknown)(
        IMFPresentationDescriptor* This,
        REFGUID guidKey,
        REFIID riid,
        LPVOID *ppv);

    HRESULT (STDMETHODCALLTYPE *SetItem)(
        IMFPresentationDescriptor* This,
        REFGUID guidKey,
        REFPROPVARIANT Value);

    HRESULT (STDMETHODCALLTYPE *DeleteItem)(
        IMFPresentationDescriptor* This,
        REFGUID guidKey);

    HRESULT (STDMETHODCALLTYPE *DeleteAllItems)(
        IMFPresentationDescriptor* This);

    HRESULT (STDMETHODCALLTYPE *SetUINT32)(
        IMFPresentationDescriptor* This,
        REFGUID guidKey,
        UINT32 unValue);

    HRESULT (STDMETHODCALLTYPE *SetUINT64)(
        IMFPresentationDescriptor* This,
        REFGUID guidKey,
        UINT64 unValue);

    HRESULT (STDMETHODCALLTYPE *SetDouble)(
        IMFPresentationDescriptor* This,
        REFGUID guidKey,
        double fValue);

    HRESULT (STDMETHODCALLTYPE *SetGUID)(
        IMFPresentationDescriptor* This,
        REFGUID guidKey,
        REFGUID guidValue);

    HRESULT (STDMETHODCALLTYPE *SetString)(
        IMFPresentationDescriptor* This,
        REFGUID guidKey,
        LPCWSTR wszValue);

    HRESULT (STDMETHODCALLTYPE *SetBlob)(
        IMFPresentationDescriptor* This,
        REFGUID guidKey,
        const UINT8 *pBuf,
        UINT32 cbBufSize);

    HRESULT (STDMETHODCALLTYPE *SetUnknown)(
        IMFPresentationDescriptor* This,
        REFGUID guidKey,
        IUnknown *pUnknown);

    HRESULT (STDMETHODCALLTYPE *LockStore)(
        IMFPresentationDescriptor* This);

    HRESULT (STDMETHODCALLTYPE *UnlockStore)(
        IMFPresentationDescriptor* This);

    HRESULT (STDMETHODCALLTYPE *GetCount)(
        IMFPresentationDescriptor* This,
        UINT32 *pcItems);

    HRESULT (STDMETHODCALLTYPE *GetItemByIndex)(
        IMFPresentationDescriptor* This,
        UINT32 unIndex,
        GUID *pguidKey,
        PROPVARIANT *pValue);

    HRESULT (STDMETHODCALLTYPE *CopyAllItems)(
        IMFPresentationDescriptor* This,
        IMFAttributes *pDest);

    /*** IMFPresentationDescriptor methods ***/
    HRESULT (STDMETHODCALLTYPE *GetStreamDescriptorCount)(
        IMFPresentationDescriptor* This,
        DWORD *pdwDescriptorCount);

    HRESULT (STDMETHODCALLTYPE *GetStreamDescriptorByIndex)(
        IMFPresentationDescriptor* This,
        DWORD dwIndex,
        WINBOOL *pfSelected,
        IMFStreamDescriptor **ppDescriptor);

    HRESULT (STDMETHODCALLTYPE *SelectStream)(
        IMFPresentationDescriptor* This,
        DWORD dwDescriptorIndex);

    HRESULT (STDMETHODCALLTYPE *DeselectStream)(
        IMFPresentationDescriptor* This,
        DWORD dwDescriptorIndex);

    HRESULT (STDMETHODCALLTYPE *Clone)(
        IMFPresentationDescriptor* This,
        IMFPresentationDescriptor **ppPresentationDescriptor);

    END_INTERFACE
} IMFPresentationDescriptorVtbl;
interface IMFPresentationDescriptor {
    CONST_VTBL IMFPresentationDescriptorVtbl* lpVtbl;
};

#ifdef COBJMACROS
#ifndef WIDL_C_INLINE_WRAPPERS
/*** IUnknown methods ***/
#define IMFPresentationDescriptor_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
#define IMFPresentationDescriptor_AddRef(This) (This)->lpVtbl->AddRef(This)
#define IMFPresentationDescriptor_Release(This) (This)->lpVtbl->Release(This)
/*** IMFAttributes methods ***/
#define IMFPresentationDescriptor_GetItem(This,guidKey,pValue) (This)->lpVtbl->GetItem(This,guidKey,pValue)
#define IMFPresentationDescriptor_GetItemType(This,guidKey,pType) (This)->lpVtbl->GetItemType(This,guidKey,pType)
#define IMFPresentationDescriptor_CompareItem(This,guidKey,Value,pbResult) (This)->lpVtbl->CompareItem(This,guidKey,Value,pbResult)
#define IMFPresentationDescriptor_Compare(This,pTheirs,MatchType,pbResult) (This)->lpVtbl->Compare(This,pTheirs,MatchType,pbResult)
#define IMFPresentationDescriptor_GetUINT32(This,guidKey,punValue) (This)->lpVtbl->GetUINT32(This,guidKey,punValue)
#define IMFPresentationDescriptor_GetUINT64(This,guidKey,punValue) (This)->lpVtbl->GetUINT64(This,guidKey,punValue)
#define IMFPresentationDescriptor_GetDouble(This,guidKey,pfValue) (This)->lpVtbl->GetDouble(This,guidKey,pfValue)
#define IMFPresentationDescriptor_GetGUID(This,guidKey,pguidValue) (This)->lpVtbl->GetGUID(This,guidKey,pguidValue)
#define IMFPresentationDescriptor_GetStringLength(This,guidKey,pcchLength) (This)->lpVtbl->GetStringLength(This,guidKey,pcchLength)
#define IMFPresentationDescriptor_GetString(This,guidKey,pwszValue,cchBufSize,pcchLength) (This)->lpVtbl->GetString(This,guidKey,pwszValue,cchBufSize,pcchLength)
#define IMFPresentationDescriptor_GetAllocatedString(This,guidKey,ppwszValue,pcchLength) (This)->lpVtbl->GetAllocatedString(This,guidKey,ppwszValue,pcchLength)
#define IMFPresentationDescriptor_GetBlobSize(This,guidKey,pcbBlobSize) (This)->lpVtbl->GetBlobSize(This,guidKey,pcbBlobSize)
#define IMFPresentationDescriptor_GetBlob(This,guidKey,pBuf,cbBufSize,pcbBlobSize) (This)->lpVtbl->GetBlob(This,guidKey,pBuf,cbBufSize,pcbBlobSize)
#define IMFPresentationDescriptor_GetAllocatedBlob(This,guidKey,ppBuf,pcbSize) (This)->lpVtbl->GetAllocatedBlob(This,guidKey,ppBuf,pcbSize)
#define IMFPresentationDescriptor_GetUnknown(This,guidKey,riid,ppv) (This)->lpVtbl->GetUnknown(This,guidKey,riid,ppv)
#define IMFPresentationDescriptor_SetItem(This,guidKey,Value) (This)->lpVtbl->SetItem(This,guidKey,Value)
#define IMFPresentationDescriptor_DeleteItem(This,guidKey) (This)->lpVtbl->DeleteItem(This,guidKey)
#define IMFPresentationDescriptor_DeleteAllItems(This) (This)->lpVtbl->DeleteAllItems(This)
#define IMFPresentationDescriptor_SetUINT32(This,guidKey,unValue) (This)->lpVtbl->SetUINT32(This,guidKey,unValue)
#define IMFPresentationDescriptor_SetUINT64(This,guidKey,unValue) (This)->lpVtbl->SetUINT64(This,guidKey,unValue)
#define IMFPresentationDescriptor_SetDouble(This,guidKey,fValue) (This)->lpVtbl->SetDouble(This,guidKey,fValue)
#define IMFPresentationDescriptor_SetGUID(This,guidKey,guidValue) (This)->lpVtbl->SetGUID(This,guidKey,guidValue)
#define IMFPresentationDescriptor_SetString(This,guidKey,wszValue) (This)->lpVtbl->SetString(This,guidKey,wszValue)
#define IMFPresentationDescriptor_SetBlob(This,guidKey,pBuf,cbBufSize) (This)->lpVtbl->SetBlob(This,guidKey,pBuf,cbBufSize)
#define IMFPresentationDescriptor_SetUnknown(This,guidKey,pUnknown) (This)->lpVtbl->SetUnknown(This,guidKey,pUnknown)
#define IMFPresentationDescriptor_LockStore(This) (This)->lpVtbl->LockStore(This)
#define IMFPresentationDescriptor_UnlockStore(This) (This)->lpVtbl->UnlockStore(This)
#define IMFPresentationDescriptor_GetCount(This,pcItems) (This)->lpVtbl->GetCount(This,pcItems)
#define IMFPresentationDescriptor_GetItemByIndex(This,unIndex,pguidKey,pValue) (This)->lpVtbl->GetItemByIndex(This,unIndex,pguidKey,pValue)
#define IMFPresentationDescriptor_CopyAllItems(This,pDest) (This)->lpVtbl->CopyAllItems(This,pDest)
/*** IMFPresentationDescriptor methods ***/
#define IMFPresentationDescriptor_GetStreamDescriptorCount(This,pdwDescriptorCount) (This)->lpVtbl->GetStreamDescriptorCount(This,pdwDescriptorCount)
#define IMFPresentationDescriptor_GetStreamDescriptorByIndex(This,dwIndex,pfSelected,ppDescriptor) (This)->lpVtbl->GetStreamDescriptorByIndex(This,dwIndex,pfSelected,ppDescriptor)
#define IMFPresentationDescriptor_SelectStream(This,dwDescriptorIndex) (This)->lpVtbl->SelectStream(This,dwDescriptorIndex)
#define IMFPresentationDescriptor_DeselectStream(This,dwDescriptorIndex) (This)->lpVtbl->DeselectStream(This,dwDescriptorIndex)
#define IMFPresentationDescriptor_Clone(This,ppPresentationDescriptor) (This)->lpVtbl->Clone(This,ppPresentationDescriptor)
#else
/*** IUnknown methods ***/
static FORCEINLINE HRESULT IMFPresentationDescriptor_QueryInterface(IMFPresentationDescriptor* This,REFIID riid,void **ppvObject) {
    return This->lpVtbl->QueryInterface(This,riid,ppvObject);
}
static FORCEINLINE ULONG IMFPresentationDescriptor_AddRef(IMFPresentationDescriptor* This) {
    return This->lpVtbl->AddRef(This);
}
static FORCEINLINE ULONG IMFPresentationDescriptor_Release(IMFPresentationDescriptor* This) {
    return This->lpVtbl->Release(This);
}
/*** IMFAttributes methods ***/
static FORCEINLINE HRESULT IMFPresentationDescriptor_GetItem(IMFPresentationDescriptor* This,REFGUID guidKey,PROPVARIANT *pValue) {
    return This->lpVtbl->GetItem(This,guidKey,pValue);
}
static FORCEINLINE HRESULT IMFPresentationDescriptor_GetItemType(IMFPresentationDescriptor* This,REFGUID guidKey,MF_ATTRIBUTE_TYPE *pType) {
    return This->lpVtbl->GetItemType(This,guidKey,pType);
}
static FORCEINLINE HRESULT IMFPresentationDescriptor_CompareItem(IMFPresentationDescriptor* This,REFGUID guidKey,REFPROPVARIANT Value,WINBOOL *pbResult) {
    return This->lpVtbl->CompareItem(This,guidKey,Value,pbResult);
}
static FORCEINLINE HRESULT IMFPresentationDescriptor_Compare(IMFPresentationDescriptor* This,IMFAttributes *pTheirs,MF_ATTRIBUTES_MATCH_TYPE MatchType,WINBOOL *pbResult) {
    return This->lpVtbl->Compare(This,pTheirs,MatchType,pbResult);
}
static FORCEINLINE HRESULT IMFPresentationDescriptor_GetUINT32(IMFPresentationDescriptor* This,REFGUID guidKey,UINT32 *punValue) {
    return This->lpVtbl->GetUINT32(This,guidKey,punValue);
}
static FORCEINLINE HRESULT IMFPresentationDescriptor_GetUINT64(IMFPresentationDescriptor* This,REFGUID guidKey,UINT64 *punValue) {
    return This->lpVtbl->GetUINT64(This,guidKey,punValue);
}
static FORCEINLINE HRESULT IMFPresentationDescriptor_GetDouble(IMFPresentationDescriptor* This,REFGUID guidKey,double *pfValue) {
    return This->lpVtbl->GetDouble(This,guidKey,pfValue);
}
static FORCEINLINE HRESULT IMFPresentationDescriptor_GetGUID(IMFPresentationDescriptor* This,REFGUID guidKey,GUID *pguidValue) {
    return This->lpVtbl->GetGUID(This,guidKey,pguidValue);
}
static FORCEINLINE HRESULT IMFPresentationDescriptor_GetStringLength(IMFPresentationDescriptor* This,REFGUID guidKey,UINT32 *pcchLength) {
    return This->lpVtbl->GetStringLength(This,guidKey,pcchLength);
}
static FORCEINLINE HRESULT IMFPresentationDescriptor_GetString(IMFPresentationDescriptor* This,REFGUID guidKey,LPWSTR pwszValue,UINT32 cchBufSize,UINT32 *pcchLength) {
    return This->lpVtbl->GetString(This,guidKey,pwszValue,cchBufSize,pcchLength);
}
static FORCEINLINE HRESULT IMFPresentationDescriptor_GetAllocatedString(IMFPresentationDescriptor* This,REFGUID guidKey,LPWSTR *ppwszValue,UINT32 *pcchLength) {
    return This->lpVtbl->GetAllocatedString(This,guidKey,ppwszValue,pcchLength);
}
static FORCEINLINE HRESULT IMFPresentationDescriptor_GetBlobSize(IMFPresentationDescriptor* This,REFGUID guidKey,UINT32 *pcbBlobSize) {
    return This->lpVtbl->GetBlobSize(This,guidKey,pcbBlobSize);
}
static FORCEINLINE HRESULT IMFPresentationDescriptor_GetBlob(IMFPresentationDescriptor* This,REFGUID guidKey,UINT8 *pBuf,UINT32 cbBufSize,UINT32 *pcbBlobSize) {
    return This->lpVtbl->GetBlob(This,guidKey,pBuf,cbBufSize,pcbBlobSize);
}
static FORCEINLINE HRESULT IMFPresentationDescriptor_GetAllocatedBlob(IMFPresentationDescriptor* This,REFGUID guidKey,UINT8 **ppBuf,UINT32 *pcbSize) {
    return This->lpVtbl->GetAllocatedBlob(This,guidKey,ppBuf,pcbSize);
}
static FORCEINLINE HRESULT IMFPresentationDescriptor_GetUnknown(IMFPresentationDescriptor* This,REFGUID guidKey,REFIID riid,LPVOID *ppv) {
    return This->lpVtbl->GetUnknown(This,guidKey,riid,ppv);
}
static FORCEINLINE HRESULT IMFPresentationDescriptor_SetItem(IMFPresentationDescriptor* This,REFGUID guidKey,REFPROPVARIANT Value) {
    return This->lpVtbl->SetItem(This,guidKey,Value);
}
static FORCEINLINE HRESULT IMFPresentationDescriptor_DeleteItem(IMFPresentationDescriptor* This,REFGUID guidKey) {
    return This->lpVtbl->DeleteItem(This,guidKey);
}
static FORCEINLINE HRESULT IMFPresentationDescriptor_DeleteAllItems(IMFPresentationDescriptor* This) {
    return This->lpVtbl->DeleteAllItems(This);
}
static FORCEINLINE HRESULT IMFPresentationDescriptor_SetUINT32(IMFPresentationDescriptor* This,REFGUID guidKey,UINT32 unValue) {
    return This->lpVtbl->SetUINT32(This,guidKey,unValue);
}
static FORCEINLINE HRESULT IMFPresentationDescriptor_SetUINT64(IMFPresentationDescriptor* This,REFGUID guidKey,UINT64 unValue) {
    return This->lpVtbl->SetUINT64(This,guidKey,unValue);
}
static FORCEINLINE HRESULT IMFPresentationDescriptor_SetDouble(IMFPresentationDescriptor* This,REFGUID guidKey,double fValue) {
    return This->lpVtbl->SetDouble(This,guidKey,fValue);
}
static FORCEINLINE HRESULT IMFPresentationDescriptor_SetGUID(IMFPresentationDescriptor* This,REFGUID guidKey,REFGUID guidValue) {
    return This->lpVtbl->SetGUID(This,guidKey,guidValue);
}
static FORCEINLINE HRESULT IMFPresentationDescriptor_SetString(IMFPresentationDescriptor* This,REFGUID guidKey,LPCWSTR wszValue) {
    return This->lpVtbl->SetString(This,guidKey,wszValue);
}
static FORCEINLINE HRESULT IMFPresentationDescriptor_SetBlob(IMFPresentationDescriptor* This,REFGUID guidKey,const UINT8 *pBuf,UINT32 cbBufSize) {
    return This->lpVtbl->SetBlob(This,guidKey,pBuf,cbBufSize);
}
static FORCEINLINE HRESULT IMFPresentationDescriptor_SetUnknown(IMFPresentationDescriptor* This,REFGUID guidKey,IUnknown *pUnknown) {
    return This->lpVtbl->SetUnknown(This,guidKey,pUnknown);
}
static FORCEINLINE HRESULT IMFPresentationDescriptor_LockStore(IMFPresentationDescriptor* This) {
    return This->lpVtbl->LockStore(This);
}
static FORCEINLINE HRESULT IMFPresentationDescriptor_UnlockStore(IMFPresentationDescriptor* This) {
    return This->lpVtbl->UnlockStore(This);
}
static FORCEINLINE HRESULT IMFPresentationDescriptor_GetCount(IMFPresentationDescriptor* This,UINT32 *pcItems) {
    return This->lpVtbl->GetCount(This,pcItems);
}
static FORCEINLINE HRESULT IMFPresentationDescriptor_GetItemByIndex(IMFPresentationDescriptor* This,UINT32 unIndex,GUID *pguidKey,PROPVARIANT *pValue) {
    return This->lpVtbl->GetItemByIndex(This,unIndex,pguidKey,pValue);
}
static FORCEINLINE HRESULT IMFPresentationDescriptor_CopyAllItems(IMFPresentationDescriptor* This,IMFAttributes *pDest) {
    return This->lpVtbl->CopyAllItems(This,pDest);
}
/*** IMFPresentationDescriptor methods ***/
static FORCEINLINE HRESULT IMFPresentationDescriptor_GetStreamDescriptorCount(IMFPresentationDescriptor* This,DWORD *pdwDescriptorCount) {
    return This->lpVtbl->GetStreamDescriptorCount(This,pdwDescriptorCount);
}
static FORCEINLINE HRESULT IMFPresentationDescriptor_GetStreamDescriptorByIndex(IMFPresentationDescriptor* This,DWORD dwIndex,WINBOOL *pfSelected,IMFStreamDescriptor **ppDescriptor) {
    return This->lpVtbl->GetStreamDescriptorByIndex(This,dwIndex,pfSelected,ppDescriptor);
}
static FORCEINLINE HRESULT IMFPresentationDescriptor_SelectStream(IMFPresentationDescriptor* This,DWORD dwDescriptorIndex) {
    return This->lpVtbl->SelectStream(This,dwDescriptorIndex);
}
static FORCEINLINE HRESULT IMFPresentationDescriptor_DeselectStream(IMFPresentationDescriptor* This,DWORD dwDescriptorIndex) {
    return This->lpVtbl->DeselectStream(This,dwDescriptorIndex);
}
static FORCEINLINE HRESULT IMFPresentationDescriptor_Clone(IMFPresentationDescriptor* This,IMFPresentationDescriptor **ppPresentationDescriptor) {
    return This->lpVtbl->Clone(This,ppPresentationDescriptor);
}
#endif
#endif

#endif

HRESULT STDMETHODCALLTYPE IMFPresentationDescriptor_GetStreamDescriptorCount_Proxy(
    IMFPresentationDescriptor* This,
    DWORD *pdwDescriptorCount);
void __RPC_STUB IMFPresentationDescriptor_GetStreamDescriptorCount_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFPresentationDescriptor_GetStreamDescriptorByIndex_Proxy(
    IMFPresentationDescriptor* This,
    DWORD dwIndex,
    WINBOOL *pfSelected,
    IMFStreamDescriptor **ppDescriptor);
void __RPC_STUB IMFPresentationDescriptor_GetStreamDescriptorByIndex_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFPresentationDescriptor_SelectStream_Proxy(
    IMFPresentationDescriptor* This,
    DWORD dwDescriptorIndex);
void __RPC_STUB IMFPresentationDescriptor_SelectStream_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFPresentationDescriptor_DeselectStream_Proxy(
    IMFPresentationDescriptor* This,
    DWORD dwDescriptorIndex);
void __RPC_STUB IMFPresentationDescriptor_DeselectStream_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFPresentationDescriptor_Clone_Proxy(
    IMFPresentationDescriptor* This,
    IMFPresentationDescriptor **ppPresentationDescriptor);
void __RPC_STUB IMFPresentationDescriptor_Clone_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IMFPresentationDescriptor_INTERFACE_DEFINED__ */

/*****************************************************************************
 * IMFMediaSource interface
 */
#ifndef __IMFMediaSource_INTERFACE_DEFINED__
#define __IMFMediaSource_INTERFACE_DEFINED__

DEFINE_GUID(IID_IMFMediaSource, 0x279a808d, 0xaec7, 0x40c8, 0x9c,0x6b, 0xa6,0xb4,0x92,0xc7,0x8a,0x66);
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("279a808d-aec7-40c8-9c6b-a6b492c78a66")
IMFMediaSource : public IMFMediaEventGenerator
{
    virtual HRESULT STDMETHODCALLTYPE GetCharacteristics(
        DWORD *pdwCharacteristics) = 0;

    virtual HRESULT STDMETHODCALLTYPE CreatePresentationDescriptor(
        IMFPresentationDescriptor **ppPresentationDescriptor) = 0;

    virtual HRESULT STDMETHODCALLTYPE Start(
        IMFPresentationDescriptor *pPresentationDescriptor,
        const GUID *pguidTimeFormat,
        const PROPVARIANT *pvarStartPosition) = 0;

    virtual HRESULT STDMETHODCALLTYPE Stop(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE Pause(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE Shutdown(
        ) = 0;

};
#ifdef __CRT_UUID_DECL
__CRT_UUID_DECL(IMFMediaSource, 0x279a808d, 0xaec7, 0x40c8, 0x9c,0x6b, 0xa6,0xb4,0x92,0xc7,0x8a,0x66)
#endif
#else
typedef struct IMFMediaSourceVtbl {
    BEGIN_INTERFACE

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

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

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

    /*** IMFMediaEventGenerator methods ***/
    HRESULT (STDMETHODCALLTYPE *GetEvent)(
        IMFMediaSource* This,
        DWORD dwFlags,
        IMFMediaEvent **ppEvent);

    HRESULT (STDMETHODCALLTYPE *BeginGetEvent)(
        IMFMediaSource* This,
        IMFAsyncCallback *pCallback,
        IUnknown *punkState);

    HRESULT (STDMETHODCALLTYPE *EndGetEvent)(
        IMFMediaSource* This,
        IMFAsyncResult *pResult,
        IMFMediaEvent **ppEvent);

    HRESULT (STDMETHODCALLTYPE *QueueEvent)(
        IMFMediaSource* This,
        MediaEventType met,
        REFGUID guidExtendedType,
        HRESULT hrStatus,
        const PROPVARIANT *pvValue);

    /*** IMFMediaSource methods ***/
    HRESULT (STDMETHODCALLTYPE *GetCharacteristics)(
        IMFMediaSource* This,
        DWORD *pdwCharacteristics);

    HRESULT (STDMETHODCALLTYPE *CreatePresentationDescriptor)(
        IMFMediaSource* This,
        IMFPresentationDescriptor **ppPresentationDescriptor);

    HRESULT (STDMETHODCALLTYPE *Start)(
        IMFMediaSource* This,
        IMFPresentationDescriptor *pPresentationDescriptor,
        const GUID *pguidTimeFormat,
        const PROPVARIANT *pvarStartPosition);

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

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

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

    END_INTERFACE
} IMFMediaSourceVtbl;
interface IMFMediaSource {
    CONST_VTBL IMFMediaSourceVtbl* lpVtbl;
};

#ifdef COBJMACROS
#ifndef WIDL_C_INLINE_WRAPPERS
/*** IUnknown methods ***/
#define IMFMediaSource_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
#define IMFMediaSource_AddRef(This) (This)->lpVtbl->AddRef(This)
#define IMFMediaSource_Release(This) (This)->lpVtbl->Release(This)
/*** IMFMediaEventGenerator methods ***/
#define IMFMediaSource_GetEvent(This,dwFlags,ppEvent) (This)->lpVtbl->GetEvent(This,dwFlags,ppEvent)
#define IMFMediaSource_BeginGetEvent(This,pCallback,punkState) (This)->lpVtbl->BeginGetEvent(This,pCallback,punkState)
#define IMFMediaSource_EndGetEvent(This,pResult,ppEvent) (This)->lpVtbl->EndGetEvent(This,pResult,ppEvent)
#define IMFMediaSource_QueueEvent(This,met,guidExtendedType,hrStatus,pvValue) (This)->lpVtbl->QueueEvent(This,met,guidExtendedType,hrStatus,pvValue)
/*** IMFMediaSource methods ***/
#define IMFMediaSource_GetCharacteristics(This,pdwCharacteristics) (This)->lpVtbl->GetCharacteristics(This,pdwCharacteristics)
#define IMFMediaSource_CreatePresentationDescriptor(This,ppPresentationDescriptor) (This)->lpVtbl->CreatePresentationDescriptor(This,ppPresentationDescriptor)
#define IMFMediaSource_Start(This,pPresentationDescriptor,pguidTimeFormat,pvarStartPosition) (This)->lpVtbl->Start(This,pPresentationDescriptor,pguidTimeFormat,pvarStartPosition)
#define IMFMediaSource_Stop(This) (This)->lpVtbl->Stop(This)
#define IMFMediaSource_Pause(This) (This)->lpVtbl->Pause(This)
#define IMFMediaSource_Shutdown(This) (This)->lpVtbl->Shutdown(This)
#else
/*** IUnknown methods ***/
static FORCEINLINE HRESULT IMFMediaSource_QueryInterface(IMFMediaSource* This,REFIID riid,void **ppvObject) {
    return This->lpVtbl->QueryInterface(This,riid,ppvObject);
}
static FORCEINLINE ULONG IMFMediaSource_AddRef(IMFMediaSource* This) {
    return This->lpVtbl->AddRef(This);
}
static FORCEINLINE ULONG IMFMediaSource_Release(IMFMediaSource* This) {
    return This->lpVtbl->Release(This);
}
/*** IMFMediaEventGenerator methods ***/
static FORCEINLINE HRESULT IMFMediaSource_GetEvent(IMFMediaSource* This,DWORD dwFlags,IMFMediaEvent **ppEvent) {
    return This->lpVtbl->GetEvent(This,dwFlags,ppEvent);
}
static FORCEINLINE HRESULT IMFMediaSource_BeginGetEvent(IMFMediaSource* This,IMFAsyncCallback *pCallback,IUnknown *punkState) {
    return This->lpVtbl->BeginGetEvent(This,pCallback,punkState);
}
static FORCEINLINE HRESULT IMFMediaSource_EndGetEvent(IMFMediaSource* This,IMFAsyncResult *pResult,IMFMediaEvent **ppEvent) {
    return This->lpVtbl->EndGetEvent(This,pResult,ppEvent);
}
static FORCEINLINE HRESULT IMFMediaSource_QueueEvent(IMFMediaSource* This,MediaEventType met,REFGUID guidExtendedType,HRESULT hrStatus,const PROPVARIANT *pvValue) {
    return This->lpVtbl->QueueEvent(This,met,guidExtendedType,hrStatus,pvValue);
}
/*** IMFMediaSource methods ***/
static FORCEINLINE HRESULT IMFMediaSource_GetCharacteristics(IMFMediaSource* This,DWORD *pdwCharacteristics) {
    return This->lpVtbl->GetCharacteristics(This,pdwCharacteristics);
}
static FORCEINLINE HRESULT IMFMediaSource_CreatePresentationDescriptor(IMFMediaSource* This,IMFPresentationDescriptor **ppPresentationDescriptor) {
    return This->lpVtbl->CreatePresentationDescriptor(This,ppPresentationDescriptor);
}
static FORCEINLINE HRESULT IMFMediaSource_Start(IMFMediaSource* This,IMFPresentationDescriptor *pPresentationDescriptor,const GUID *pguidTimeFormat,const PROPVARIANT *pvarStartPosition) {
    return This->lpVtbl->Start(This,pPresentationDescriptor,pguidTimeFormat,pvarStartPosition);
}
static FORCEINLINE HRESULT IMFMediaSource_Stop(IMFMediaSource* This) {
    return This->lpVtbl->Stop(This);
}
static FORCEINLINE HRESULT IMFMediaSource_Pause(IMFMediaSource* This) {
    return This->lpVtbl->Pause(This);
}
static FORCEINLINE HRESULT IMFMediaSource_Shutdown(IMFMediaSource* This) {
    return This->lpVtbl->Shutdown(This);
}
#endif
#endif

#endif

HRESULT STDMETHODCALLTYPE IMFMediaSource_GetCharacteristics_Proxy(
    IMFMediaSource* This,
    DWORD *pdwCharacteristics);
void __RPC_STUB IMFMediaSource_GetCharacteristics_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFMediaSource_RemoteCreatePresentationDescriptor_Proxy(
    IMFMediaSource* This,
    DWORD *pcbPD,
    BYTE **pbPD,
    IMFPresentationDescriptor **ppRemotePD);
void __RPC_STUB IMFMediaSource_RemoteCreatePresentationDescriptor_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFMediaSource_Start_Proxy(
    IMFMediaSource* This,
    IMFPresentationDescriptor *pPresentationDescriptor,
    const GUID *pguidTimeFormat,
    const PROPVARIANT *pvarStartPosition);
void __RPC_STUB IMFMediaSource_Start_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFMediaSource_Stop_Proxy(
    IMFMediaSource* This);
void __RPC_STUB IMFMediaSource_Stop_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFMediaSource_Pause_Proxy(
    IMFMediaSource* This);
void __RPC_STUB IMFMediaSource_Pause_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFMediaSource_Shutdown_Proxy(
    IMFMediaSource* This);
void __RPC_STUB IMFMediaSource_Shutdown_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMFMediaSource_CreatePresentationDescriptor_Proxy(
    IMFMediaSource* This,
    IMFPresentationDescriptor **ppPresentationDescriptor);
HRESULT __RPC_STUB IMFMediaSource_CreatePresentationDescriptor_Stub(
    IMFMediaSource* This,
    DWORD *pcbPD,
    BYTE **pbPD,
    IMFPresentationDescriptor **ppRemotePD);

#endif  /* __IMFMediaSource_INTERFACE_DEFINED__ */

typedef struct _MF_LEAKY_BUCKET_PAIR {
    DWORD dwBitrate;
    DWORD msBufferWindow;
} MF_LEAKY_BUCKET_PAIR;
typedef struct _MFBYTESTREAM_BUFFERING_PARAMS {
    QWORD cbTotalFileSize;
    QWORD cbPlayableDataSize;
    MF_LEAKY_BUCKET_PAIR *prgBuckets;
    DWORD cBuckets;
    QWORD qwNetBufferingTime;
    QWORD qwExtraBufferingTimeDuringSeek;
    QWORD qwPlayDuration;
    float dRate;
} MFBYTESTREAM_BUFFERING_PARAMS;
/*****************************************************************************
 * IMFByteStreamBuffering interface
 */
#ifndef __IMFByteStreamBuffering_INTERFACE_DEFINED__
#define __IMFByteStreamBuffering_INTERFACE_DEFINED__

DEFINE_GUID(IID_IMFByteStreamBuffering, 0x6d66d782, 0x1d4f, 0x4db7, 0x8c,0x63, 0xcb,0x8c,0x77,0xf1,0xef,0x5e);
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("6d66d782-1d4f-4db7-8c63-cb8c77f1ef5e")
IMFByteStreamBuffering : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE SetBufferingParams(
        MFBYTESTREAM_BUFFERING_PARAMS *pParams) = 0;

    virtual HRESULT STDMETHODCALLTYPE EnableBuffering(
        WINBOOL fEnable) = 0;

    virtual HRESULT STDMETHODCALLTYPE StopBuffering(
        ) = 0;

};
#ifdef __CRT_UUID_DECL
__CRT_UUID_DECL(IMFByteStreamBuffering, 0x6d66d782, 0x1d4f, 0x4db7, 0x8c,0x63, 0xcb,0x8c,0x77,0xf1,0xef,0x5e)
#endif
#else
typedef struct IMFByteStreamBufferingVtbl {
    BEGIN_INTERFACE

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

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

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

    /*** IMFByteStreamBuffering methods ***/
    HRESULT (STDMETHODCALLTYPE *SetBufferingParams)(
        IMFByteStreamBuffering* This,
        MFBYTESTREAM_BUFFERING_PARAMS *pParams);

    HRESULT (STDMETHODCALLTYPE *EnableBuffering)(
        IMFByteStreamBuffering* This,
        WINBOOL fEnable);

    HRESULT (STDMETHODCALLTYPE *StopBuffering)(
        IMFByteStreamBuffering* This);

    END_INTERFACE
} IMFByteStreamBufferingVtbl;
interface IMFByteStreamBuffering {
    CONST_VTBL IMFByteStreamBufferingVtbl* lpVtbl;
};

#ifdef COBJMACROS
#ifndef WIDL_C_INLINE_WRAPPERS
/*** IUnknown methods ***/
#define IMFByteStreamBuffering_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
#define IMFByteStreamBuffering_AddRef(This) (This)->lpVtbl->AddRef(This)
#define IMFByteStreamBuffering_Release(This) (This)->lpVtbl->Release(This)
/*** IMFByteStreamBuffering methods ***/
#define IMFByteStreamBuffering_SetBufferingParams(This,pParams) (This)->lpVtbl->SetBufferingParams(This,pParams)
#define IMFByteStreamBuffering_EnableBuffering(This,fEnable) (This)->lpVtbl->EnableBuffering(This,fEnable)
#define IMFByteStreamBuffering_StopBuffering(This) (This)->lpVtbl->StopBuffering(This)
#else
/*** IUnknown methods ***/
static FORCEINLINE HRESULT IMFByteStreamBuffering_QueryInterface(IMFByteStreamBuffering* This,REFIID riid,void **ppvObject) {
    return This->lpVtbl->QueryInterface(This,riid,ppvObject);
}
static FORCEINLINE ULONG IMFByteStreamBuffering_AddRef(IMFByteStreamBuffering* This) {
    return This->lpVtbl->AddRef(This);
}
static FORCEINLINE ULONG IMFByteStreamBuffering_Release(IMFByteStreamBuffering* This) {
    return This->lpVtbl->Release(This);
}
/*** IMFByteStreamBuffering methods ***/
static FORCEINLINE HRESULT IMFByteStreamBuffering_SetBufferingParams(IMFByteStreamBuffering* This,MFBYTESTREAM_BUFFERING_PARAMS *pParams) {
    return This->lpVtbl->SetBufferingParams(This,pParams);
}
static FORCEINLINE HRESULT IMFByteStreamBuffering_EnableBuffering(IMFByteStreamBuffering* This,WINBOOL fEnable) {
    return This->lpVtbl->EnableBuffering(This,fEnable);
}
static FORCEINLINE HRESULT IMFByteStreamBuffering_StopBuffering(IMFByteStreamBuffering* This) {
    return This->lpVtbl->StopBuffering(This);
}
#endif
#endif

#endif

HRESULT STDMETHODCALLTYPE IMFByteStreamBuffering_SetBufferingParams_Proxy(
    IMFByteStreamBuffering* This,
    MFBYTESTREAM_BUFFERING_PARAMS *pParams);
void __RPC_STUB IMFByteStreamBuffering_SetBufferingParams_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFByteStreamBuffering_EnableBuffering_Proxy(
    IMFByteStreamBuffering* This,
    WINBOOL fEnable);
void __RPC_STUB IMFByteStreamBuffering_EnableBuffering_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFByteStreamBuffering_StopBuffering_Proxy(
    IMFByteStreamBuffering* This);
void __RPC_STUB IMFByteStreamBuffering_StopBuffering_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IMFByteStreamBuffering_INTERFACE_DEFINED__ */

HRESULT WINAPI MFRequireProtectedEnvironment(IMFPresentationDescriptor *pPresentationDescriptor);
HRESULT WINAPI MFSerializePresentationDescriptor(IMFPresentationDescriptor *pPD,DWORD *pcbData,BYTE **ppbData);
typedef DWORD MFSequencerElementId; /*Unknown type*/

typedef enum MFCLOCK_CHARACTERISTICS_FLAGS {
  MFCLOCK_CHARACTERISTICS_FLAG_FREQUENCY_10MHZ   = 0x2,
  MFCLOCK_CHARACTERISTICS_FLAG_ALWAYS_RUNNING    = 0x4,
  MFCLOCK_CHARACTERISTICS_FLAG_IS_SYSTEM_CLOCK   = 0x8
} MFCLOCK_CHARACTERISTICS_FLAGS;

#if (WINVER >= 0x0601)

typedef enum _MF_QUALITY_ADVISE_FLAGS {
  MF_QUALITY_CANNOT_KEEP_UP   = 0x1
} MF_QUALITY_ADVISE_FLAGS;

#endif /*(WINVER >= 0x0601)*/

typedef enum _MF_QUALITY_DROP_MODE {
  MF_DROP_MODE_NONE   = 0x0,
  MF_DROP_MODE_1      = 0x1,
  MF_DROP_MODE_2      = 0x2,
  MF_DROP_MODE_3      = 0x3,
  MF_DROP_MODE_4      = 0x4,
  MF_DROP_MODE_5      = 0x5,
  MF_NUM_DROP_MODES   = 0x6
} MF_QUALITY_DROP_MODE;

typedef enum _MF_QUALITY_LEVEL {
  MF_QUALITY_NORMAL           = 0x0,
  MF_QUALITY_NORMAL_MINUS_1   = 0x1,
  MF_QUALITY_NORMAL_MINUS_2   = 0x2,
  MF_QUALITY_NORMAL_MINUS_3   = 0x3,
  MF_QUALITY_NORMAL_MINUS_4   = 0x4,
  MF_QUALITY_NORMAL_MINUS_5   = 0x5,
  MF_NUM_QUALITY_LEVELS       = 0x6
} MF_QUALITY_LEVEL;

typedef enum MF_SOURCE_READER_CONTROL_FLAG {
  MF_SOURCE_READER_CONTROLF_DRAIN   = 0x00000001
} MF_SOURCE_READER_CONTROL_FLAG;

typedef enum _MF_TOPOLOGY_RESOLUTION_STATUS_FLAGS {
  MF_TOPOLOGY_RESOLUTION_SUCCEEDED              = 0x00000000,
  MF_OPTIONAL_NODE_REJECTED_MEDIA_TYPE          = 0x00000001,
  MF_OPTIONAL_NODE_REJECTED_PROTECTED_PROCESS   = 0x00000002
} MF_TOPOLOGY_RESOLUTION_STATUS_FLAGS;

typedef enum _MF_TOPONODE_DRAIN_MODE {
  MF_TOPONODE_DRAIN_DEFAULT,
  MF_TOPONODE_DRAIN_ALWAYS,
  MF_TOPONODE_DRAIN_NEVER
} MF_TOPONODE_DRAIN_MODE;

typedef enum _MF_TOPONODE_FLUSH_MODE {
  MF_TOPONODE_FLUSH_ALWAYS,
  MF_TOPONODE_FLUSH_SEEK,
  MF_TOPONODE_FLUSH_NEVER
} MF_TOPONODE_FLUSH_MODE;

#if (WINVER >= 0x0601)

typedef enum _MF_TRANSCODE_TOPOLOGY_MODE_FLAGS {
  MF_TRANSCODE_TOPOLOGYMODE_SOFTWARE_ONLY      = 0,
  MF_TRANSCODE_TOPOLOGYMODE_HARDWARE_ALLOWED   = 1
} MF_TRANSCODE_TOPOLOGYMODE_FLAGS;

#endif

typedef enum  {
  MF_LICENSE_URL_UNTRUSTED,
  MF_LICENSE_URL_TRUSTED,
  MF_LICENSE_URL_TAMPERED
} MF_URL_TRUST_STATUS;

typedef enum MFASF_INDEXERFLAGS {
  MFASF_INDEXER_WRITE_NEW_INDEX            = 0x00000001,
  MFASF_INDEXER_READ_FOR_REVERSEPLAYBACK   = 0x00000004,
  MFASF_INDEXER_WRITE_FOR_LIVEREAD         = 0x00000008
} MFASF_INDEXERFLAGS;

typedef enum _MFCLOCK_RELATIONAL_FLAGS {
  MFCLOCK_RELATIONAL_FLAG_JITTER_NEVER_AHEAD   = 0x1
} MFCLOCK_RELATIONAL_FLAGS;

typedef enum _MFMEDIASOURCE_CHARACTERISTICS {
  MFMEDIASOURCE_IS_LIVE                      = 0x1,
  MFMEDIASOURCE_CAN_SEEK                     = 0x2,
  MFMEDIASOURCE_CAN_PAUSE                    = 0x4,
  MFMEDIASOURCE_HAS_SLOW_SEEK                = 0x8,
  MFMEDIASOURCE_HAS_MULTIPLE_PRESENTATIONS   = 0x10,
  MFMEDIASOURCE_CAN_SKIPFORWARD              = 0x20,
  MFMEDIASOURCE_CAN_SKIPBACKWARD             = 0x40
} MFMEDIASOURCE_CHARACTERISTICS;

typedef enum _MFNET_PROXYSETTINGS {
  MFNET_PROXYSETTING_NONE      = 0,
  MFNET_PROXYSETTING_MANUAL    = 1,
  MFNET_PROXYSETTING_AUTO      = 2,
  MFNET_PROXYSETTING_BROWSER   = 3
} MFNET_PROXYSETTINGS;

typedef enum _MFNetAuthenticationFlags {
  MFNET_AUTHENTICATION_PROXY            = 0x00000001,
  MFNET_AUTHENTICATION_CLEAR_TEXT       = 0x00000002,
  MFNET_AUTHENTICATION_LOGGED_ON_USER
} MFNetAuthenticationFlags;

typedef enum _MFNetCredentialOptions {
  MFNET_CREDENTIAL_SAVE               = 0x00000001,
  MFNET_CREDENTIAL_DONT_CACHE         = 0x00000002,
  MFNET_CREDENTIAL_ALLOW_CLEAR_TEXT   = 0x00000004
} MFNetCredentialOptions;

typedef enum _MFNetCredentialRequirements {
  REQUIRE_PROMPT          = 0x00000001,
  REQUIRE_SAVE_SELECTED   = 0x00000002
} MFNetCredentialRequirements;

typedef enum _MFNETSOURCE_CACHE_STATE {
  MFNETSOURCE_CACHE_UNAVAILABLE,
  MFNETSOURCE_CACHE_ACTIVE_WRITING,
  MFNETSOURCE_CACHE_ACTIVE_COMPLETE
} MFNETSOURCE_CACHE_STATE;

typedef enum _MFNETSOURCE_PROTOCOL_TYPE {
  MFNETSOURCE_UNDEFINED   = 0x0,
  MFNETSOURCE_HTTP        = 0x1,
  MFNETSOURCE_RTSP        = 0x2,
  MFNETSOURCE_FILE        = 0x3,
  MFNETSOURCE_MULTICAST   = 0x4
} MFNETSOURCE_PROTOCOL_TYPE;

typedef enum _MFNETSOURCE_STATISTICS_IDS {
  MFNETSOURCE_RECVPACKETS_ID                = 0,
  MFNETSOURCE_LOSTPACKETS_ID,
  MFNETSOURCE_RESENDSREQUESTED_ID,
  MFNETSOURCE_RESENDSRECEIVED_ID,
  MFNETSOURCE_RECOVEREDBYECCPACKETS_ID,
  MFNETSOURCE_RECOVEREDBYRTXPACKETS_ID,
  MFNETSOURCE_OUTPACKETS_ID,
  MFNETSOURCE_RECVRATE_ID,
  MFNETSOURCE_AVGBANDWIDTHBPS_ID,
  MFNETSOURCE_BYTESRECEIVED_ID,
  MFNETSOURCE_PROTOCOL_ID,
  MFNETSOURCE_TRANSPORT_ID,
  MFNETSOURCE_CACHE_STATE_ID,
  MFNETSOURCE_LINKBANDWIDTH_ID,
  MFNETSOURCE_CONTENTBITRATE_ID,
  MFNETSOURCE_SPEEDFACTOR_ID,
  MFNETSOURCE_BUFFERSIZE_ID,
  MFNETSOURCE_BUFFERPROGRESS_ID,
  MFNETSOURCE_LASTBWSWITCHTS_ID,
  MFNETSOURCE_SEEKRANGESTART_ID,
  MFNETSOURCE_SEEKRANGEEND_ID,
  MFNETSOURCE_BUFFERINGCOUNT_ID,
  MFNETSOURCE_INCORRECTLYSIGNEDPACKETS_ID,
  MFNETSOURCE_SIGNEDSESSION_ID,
  MFNETSOURCE_MAXBITRATE_ID,
  MFNETSOURCE_RECEPTION_QUALITY_ID,
  MFNETSOURCE_RECOVEREDPACKETS_ID,
  MFNETSOURCE_VBR_ID,
  MFNETSOURCE_DOWNLOADPROGRESS_ID
} MFNETSOURCE_STATISTICS_IDS;

typedef enum _MFNETSOURCE_TRANSPORT_TYPE {
  MFNETSOURCE_UDP,
  MFNETSOURCE_TCP
} MFNETSOURCE_TRANSPORT_TYPE;

typedef enum MF_OBJECT_TYPE {
  MF_OBJECT_MEDIASOURCE,
  MF_OBJECT_BYTESTREAM,
  MF_OBJECT_INVALID
} MF_OBJECT_TYPE;

typedef enum _MFPOLICYMANAGER_ACTION {
  PEACTION_NO          = 0,
  PEACTION_PLAY        = 1,
  PEACTION_COPY        = 2,
  PEACTION_EXPORT      = 3,
  PEACTION_EXTRACT     = 4,
  PEACTION_RESERVED1   = 5,
  PEACTION_RESERVED2   = 6,
  PEACTION_RESERVED3   = 7,
  PEACTION_LAST        = 7
} MFPOLICYMANAGER_ACTION;

typedef enum _MFRATE_DIRECTION {
  MFRATE_FORWARD,
  MFRATE_REVERSE
} MFRATE_DIRECTION;

typedef enum _MFSequencerTopologyFlags {
  SequencerTopologyFlags_Last   = 0x00000001
} MFSequencerTopologyFlags;

typedef enum _MFSHUTDOWN_STATUS {
  MFSHUTDOWN_INITIATED,
  MFSHUTDOWN_COMPLETED
} MFSHUTDOWN_STATUS;

typedef enum _MFSINK_WMDRMACTION {
  MFSINK_WMDRMACTION_UNDEFINED    = 0,
  MFSINK_WMDRMACTION_ENCODE       = 1,
  MFSINK_WMDRMACTION_TRANSCODE    = 2,
  MFSINK_WMDRMACTION_TRANSCRYPT   = 3,
  MFSINK_WMDRMACTION_LAST         = 3
} MFSINK_WMDRMACTION;

typedef enum MFSTREAMSINK_MARKER_TYPE {
  MFSTREAMSINK_MARKER_DEFAULT,
  MFSTREAMSINK_MARKER_ENDOFSEGMENT,
  MFSTREAMSINK_MARKER_TICK,
  MFSTREAMSINK_MARKER_EVENT
} MFSTREAMSINK_MARKER_TYPE;

typedef enum MFTIMER_FLAGS {
  MFTIMER_RELATIVE   = 0x00000001
} MFTIMER_FLAGS;

#if (WINVER >= 0x0601)

typedef enum MFTOPLOGY_DXVA_MODE {
  MFTOPOLOGY_DXVA_DEFAULT   = 0,
  MFTOPOLOGY_DXVA_NONE      = 1,
  MFTOPOLOGY_DXVA_FULL      = 2
} MFTOPOLOGY_DXVA_MODE;

typedef enum MFTOPOLOGY_HARDWARE_MODE {
  MFTOPOLOGY_HWMODE_SOFTWARE_ONLY   = 0,
  MFTOPOLOGY_HWMODE_USE_HARDWARE    = 1
} MFTOPOLOGY_HARDWARE_MODE;

typedef struct _MFT_REGISTRATION_INFO {
  CLSID                  clsid;
  GUID                   guidCategory;
  UINT32                 uiFlags;
  LPCWSTR                pszName;
  DWORD                  cInTypes;
  MFT_REGISTER_TYPE_INFO *pInTypes;
  DWORD                  cOutTypes;
  MFT_REGISTER_TYPE_INFO *pOutTypes;
} MFT_REGISTRATION_INFO;

#endif /*(WINVER >= 0x0601)*/

typedef struct _ASFFlatPicture {
  BYTE  bPictureType;
  DWORD dwDataLen;
} ASF_FLAT_PICTURE;

typedef struct _ASFFlatSynchronisedLyrics {
  BYTE  bTimeStampFormat;
  BYTE  bContentType;
  DWORD dwLyricsLen;
} ASF_FLAT_SYNCHRONISED_LYRICS;

typedef enum SAMPLE_PROTECTION_VERSION {
  SAMPLE_PROTECTION_VERSION_NO           = 0,
  SAMPLE_PROTECTION_VERSION_BASIC_LOKI   = 1,
  SAMPLE_PROTECTION_VERSION_SCATTER      = 2,
  SAMPLE_PROTECTION_VERSION_RC4          = 3
} SAMPLE_PROTECTION_VERSION;

typedef struct _MFINPUTTRUSTAUTHORITY_ACTION {
  MFPOLICYMANAGER_ACTION Action;
  BYTE                   *pbTicket;
  DWORD                  cbTicket;
} MFINPUTTRUSTAUTHORITY_ACCESS_ACTION;

typedef struct _MFINPUTTRUSTAUTHORITY_ACCESS_PARAMS {
  DWORD                               dwSize;
  DWORD                               dwVer;
  DWORD                               cbSignatureOffset;
  DWORD                               cbSignatureSize;
  DWORD                               cbExtensionOffset;
  DWORD                               cbExtensionSize;
  DWORD                               cActions;
  MFINPUTTRUSTAUTHORITY_ACCESS_ACTION rgOutputActions[1];
} MFINPUTTRUSTAUTHORITY_ACCESS_PARAMS;

typedef struct _MFNetCredentialManagerGetParam {
  HRESULT hrOp;
  WINBOOL    fAllowLoggedOnUser;
  WINBOOL    fClearTextPackage;
  LPCWSTR pszUrl;
  LPCWSTR pszSite;
  LPCWSTR pszRealm;
  LPCWSTR pszPackage;
  LONG    nRetries;
} MFNetCredentialManagerGetParam;

#define MF_1_BYTE_ALIGNMENT     0x00000000
#define MF_2_BYTE_ALIGNMENT     0x00000001
#define MF_4_BYTE_ALIGNMENT     0x00000003
#define MF_8_BYTE_ALIGNMENT     0x00000007
#define MF_16_BYTE_ALIGNMENT    0x0000000F
#define MF_32_BYTE_ALIGNMENT    0x0000001F
#define MF_64_BYTE_ALIGNMENT    0x0000003F
#define MF_128_BYTE_ALIGNMENT   0x0000007F
#define MF_256_BYTE_ALIGNMENT   0x000000FF
#define MF_512_BYTE_ALIGNMENT   0x000001FF

#define MEDIASINK_FIXED_STREAMS                 0x00000001
#define MEDIASINK_CANNOT_MATCH_CLOCK            0x00000002
#define MEDIASINK_RATELESS                      0x00000004
#define MEDIASINK_CLOCK_REQUIRED                0x00000008
#define MEDIASINK_CAN_PREROLL                   0x00000010
#define MEDIASINK_REQUIRE_REFERENCE_MEDIATYPE   0x00000020

#define MF_RESOLUTION_MEDIASOURCE                                           0x00000001
#define MF_RESOLUTION_BYTESTREAM                                            0x00000002
#define MF_RESOLUTION_CONTENT_DOES_NOT_HAVE_TO_MATCH_EXTENSION_OR_MIME_TYPE 0x00000010
#define MF_RESOLUTION_KEEP_BYTE_STREAM_ALIVE_ON_FAIL                        0x00000020
#define MF_RESOLUTION_READ                                                  0x00010000
#define MF_RESOLUTION_WRITE                                                 0x00020000
#ifndef __IMFMediaSink_FWD_DEFINED__
#define __IMFMediaSink_FWD_DEFINED__
typedef interface IMFMediaSink IMFMediaSink;
#endif

#ifndef __IMFASFContentInfo_FWD_DEFINED__
#define __IMFASFContentInfo_FWD_DEFINED__
typedef interface IMFASFContentInfo IMFASFContentInfo;
#endif

#ifndef __IMFASFIndexer_FWD_DEFINED__
#define __IMFASFIndexer_FWD_DEFINED__
typedef interface IMFASFIndexer IMFASFIndexer;
#endif

#ifndef __IMFASFMultiplexer_FWD_DEFINED__
#define __IMFASFMultiplexer_FWD_DEFINED__
typedef interface IMFASFMultiplexer IMFASFMultiplexer;
#endif

#ifndef __IMFASFProfile_FWD_DEFINED__
#define __IMFASFProfile_FWD_DEFINED__
typedef interface IMFASFProfile IMFASFProfile;
#endif

#ifndef __IMFASFSplitter_FWD_DEFINED__
#define __IMFASFSplitter_FWD_DEFINED__
typedef interface IMFASFSplitter IMFASFSplitter;
#endif

#ifndef __IMFPMPServer_FWD_DEFINED__
#define __IMFPMPServer_FWD_DEFINED__
typedef interface IMFPMPServer IMFPMPServer;
#endif

#ifndef __IMFPresentationClock_FWD_DEFINED__
#define __IMFPresentationClock_FWD_DEFINED__
typedef interface IMFPresentationClock IMFPresentationClock;
#endif

#ifndef __IMFNetProxyLocator_FWD_DEFINED__
#define __IMFNetProxyLocator_FWD_DEFINED__
typedef interface IMFNetProxyLocator IMFNetProxyLocator;
#endif

#ifndef __IMFRemoteDesktopPlugin_FWD_DEFINED__
#define __IMFRemoteDesktopPlugin_FWD_DEFINED__
typedef interface IMFRemoteDesktopPlugin IMFRemoteDesktopPlugin;
#endif

#ifndef __IMFTransform_FWD_DEFINED__
#define __IMFTransform_FWD_DEFINED__
typedef interface IMFTransform IMFTransform;
#endif

#ifndef __IMFSampleGrabberSinkCallback_FWD_DEFINED__
#define __IMFSampleGrabberSinkCallback_FWD_DEFINED__
typedef interface IMFSampleGrabberSinkCallback IMFSampleGrabberSinkCallback;
#endif

#ifndef __IMFSequencerSource_FWD_DEFINED__
#define __IMFSequencerSource_FWD_DEFINED__
typedef interface IMFSequencerSource IMFSequencerSource;
#endif

#ifndef __IMFQualityManager_FWD_DEFINED__
#define __IMFQualityManager_FWD_DEFINED__
typedef interface IMFQualityManager IMFQualityManager;
#endif

#ifndef __IMFSourceResolver_FWD_DEFINED__
#define __IMFSourceResolver_FWD_DEFINED__
typedef interface IMFSourceResolver IMFSourceResolver;
#endif

#ifndef __IMFPresentationTimeSource_FWD_DEFINED__
#define __IMFPresentationTimeSource_FWD_DEFINED__
typedef interface IMFPresentationTimeSource IMFPresentationTimeSource;
#endif

#ifndef __IMFTopoLoader_FWD_DEFINED__
#define __IMFTopoLoader_FWD_DEFINED__
typedef interface IMFTopoLoader IMFTopoLoader;
#endif

#ifndef __IMFTranscodeProfile_FWD_DEFINED__
#define __IMFTranscodeProfile_FWD_DEFINED__
typedef interface IMFTranscodeProfile IMFTranscodeProfile;
#endif

HRESULT MFCreate3GPMediaSink(IMFByteStream *pIByteStream,IMFMediaType *pVideoMediaType,IMFMediaType *pAudioMediaType,IMFMediaSink **ppIMediaSink);
HRESULT MFCreateAggregateSource(IMFCollection *pSourceCollection,IMFMediaSource **ppAggSource);

HRESULT WINAPI MFCreateAlignedMemoryBuffer(DWORD cbMaxLength,DWORD fAlignmentFlags,IMFMediaBuffer **ppBuffer);
HRESULT WINAPI MFCreateASFContentInfo(IMFASFContentInfo **ppIContentInfo);
HRESULT WINAPI MFCreateASFIndexer(IMFASFIndexer **ppIIndexer);
HRESULT WINAPI MFCreateASFIndexerByteStream(IMFByteStream *pIContentByteStream,QWORD cbIndexStartOffset,IMFByteStream **pIIndexByteStream);
HRESULT WINAPI MFCreateASFMediaSink(IMFByteStream *pIByteStream,IMFMediaSink **ppIMediaSink);
HRESULT WINAPI MFCreateASFMediaSinkActivate(LPCWSTR pwszFileName,IMFASFContentInfo *pContentInfo,IMFActivate **ppIActivate);
HRESULT WINAPI MFCreateASFMultiplexer(IMFASFMultiplexer **ppIMultiplexer);
HRESULT WINAPI MFCreateASFProfile(IMFASFProfile **ppIProfile);
HRESULT WINAPI MFCreateASFProfileFromPresentationDescriptor(IMFPresentationDescriptor *pIPD,IMFASFProfile **ppIProfile);
HRESULT WINAPI MFCreateASFSplitter(IMFASFSplitter **ppISplitter);
HRESULT WINAPI MFCreateMediaSession(IMFAttributes *pConfiguration,IMFMediaSession **ppMS);
HRESULT WINAPI MFCreateMP3MediaSink(IMFByteStream *pTargetByteStream,IMFMediaSink **ppMediaSink);
HRESULT WINAPI MFCreateMPEG4MediaSink(IMFByteStream *pIByteStream,IMFMediaType *pVideoMediaType,IMFMediaType *pAudioMediaType,IMFMediaSink **ppIMediaSink);
HRESULT WINAPI MFCreateNetSchemePlugin(REFIID riid,LPVOID *ppvHandler);
HRESULT WINAPI MFCreatePMPServer(DWORD dwCreationFlags,IMFPMPServer **ppPMPServer);
HRESULT WINAPI MFCreatePMPMediaSession(DWORD dwCreationFlags,IMFAttributes *pConfiguration,IMFMediaSession **ppMediaSession,IMFActivate **ppEnablerActivate);
HRESULT WINAPI MFCreatePathFromURL(LPCWSTR pwszFileURL,LPWSTR *ppwszFilePath);
HRESULT WINAPI MFCreatePresentationClock(IMFPresentationClock **ppPresentationClock);
HRESULT WINAPI MFCreatePresentationDescriptor(DWORD cStreamDescriptors,IMFStreamDescriptor **apStreamDescriptors,IMFPresentationDescriptor **ppPresentationDescriptor);
HRESULT WINAPI MFCreatePresentationDescriptorFromASFProfile(IMFASFProfile *pIProfile,IMFPresentationDescriptor **ppIPD);
HRESULT WINAPI MFCreateProxyLocator(LPCWSTR pszProtocol,IPropertyStore *pProxyConfig,IMFNetProxyLocator **ppProxyLocator);
HRESULT WINAPI MFCreateRemoteDesktopPlugin(IMFRemoteDesktopPlugin **ppPlugin);
HRESULT WINAPI MFCreateSample(IMFSample **ppIMFSample);
HRESULT WINAPI MFCreateSampleCopierMFT(IMFTransform **ppCopierMFT);
HRESULT WINAPI MFCreateSampleGrabberSinkActivate(IMFMediaType *pIMFMediaType,IMFSampleGrabberSinkCallback *pIMFSampleGrabberSinkCallback,IMFActivate **ppIActivate);
HRESULT WINAPI MFCreateSequencerSource(IUnknown *pReserved,IMFSequencerSource **ppSequencerSource);
HRESULT WINAPI MFCreateSimpleTypeHandler(IMFMediaTypeHandler **ppHandler);
HRESULT WINAPI MFCreateStandardQualityManager(IMFQualityManager **ppQualityManager);
HRESULT WINAPI MFCreateStreamDescriptor(DWORD dwStreamIdentifier,DWORD cMediaTypes,IMFMediaType **apMediaTypes,IMFStreamDescriptor **ppDescriptor);
HRESULT WINAPI MFCreateSourceResolver(IMFSourceResolver **ppISourceResolver);
HRESULT WINAPI MFCreateSystemTimeSource(IMFPresentationTimeSource **ppSystemTimeSource);
HRESULT WINAPI MFCreateTopoLoader(IMFTopoLoader **ppObj);
HRESULT WINAPI MFCreateTopology(IMFTopology **ppTopo);
HRESULT WINAPI MFCreateTopologyNode(MF_TOPOLOGY_TYPE NodeType,IMFTopologyNode **ppNode);
HRESULT WINAPI MFCreateVideoRenderer(REFIID riidRenderer,void **ppVideoRenderer);
HRESULT WINAPI MFCreateVideoRendererActivate(HWND hwndVideo,IMFActivate **ppActivate);
HRESULT WINAPI MFGetService(IUnknown *punkObject,REFGUID guidService,REFIID riid,LPVOID *ppvObject);
HRESULT WINAPI MFGetSupportedMimeTypes(PROPVARIANT *pPropVarMimeTypeArray);
HRESULT WINAPI MFGetSupportedSchemes(PROPVARIANT *pPropVarSchemeArray);
MFTIME WINAPI MFGetSystemTime(void);
HRESULT WINAPI MFShutdownObject(IUnknown *pUnk);
HRESULT WINAPI CreateNamedPropertyStore(INamedPropertyStore **ppStore);
HRESULT WINAPI CreatePropertyStore(IPropertyStore **ppStore);
#if (WINVER >= 0x0601)

HRESULT WINAPI MFCreateTranscodeProfile(IMFTranscodeProfile **ppTranscodeProfile);
HRESULT WINAPI MFCreateTranscodeSinkActivate(IMFActivate **ppActivate);
HRESULT WINAPI MFCreateTranscodeTopology(IMFMediaSource *pSrc,LPCWSTR pwszOutputFilePath,IMFTranscodeProfile *pProfile,IMFTopology **ppTranscodeTopo);
HRESULT WINAPI MFEnumDeviceSources(IMFAttributes *pAttributes,IMFActivate ***pppSourceActivate,UINT32 *pcSourceActivate);
HRESULT WINAPI MFGetTopoNodeCurrentType(IMFTopologyNode *pNode,DWORD dwStreamIndex,WINBOOL fOutput,IMFMediaType **ppType);
HRESULT WINAPI MFTranscodeGetAudioOutputAvailableTypes(REFGUID guidSubType,DWORD dwMFTFlags,IMFAttributes *pCodecConfig,IMFCollection **ppAvailableTypes);
#endif
/* Begin additional prototypes for all interfaces */

ULONG           __RPC_USER BSTR_UserSize     (ULONG *, ULONG, BSTR *);
unsigned char * __RPC_USER BSTR_UserMarshal  (ULONG *, unsigned char *, BSTR *);
unsigned char * __RPC_USER BSTR_UserUnmarshal(ULONG *, unsigned char *, BSTR *);
void            __RPC_USER BSTR_UserFree     (ULONG *, BSTR *);
ULONG           __RPC_USER LPSAFEARRAY_UserSize     (ULONG *, ULONG, LPSAFEARRAY *);
unsigned char * __RPC_USER LPSAFEARRAY_UserMarshal  (ULONG *, unsigned char *, LPSAFEARRAY *);
unsigned char * __RPC_USER LPSAFEARRAY_UserUnmarshal(ULONG *, unsigned char *, LPSAFEARRAY *);
void            __RPC_USER LPSAFEARRAY_UserFree     (ULONG *, LPSAFEARRAY *);

/* End additional prototypes */

#ifdef __cplusplus
}
#endif

#endif /* __mfidl_h__ */

/*** Autogenerated by WIDL 1.6 from include/mfobjects.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 __mfobjects_h__
#define __mfobjects_h__

/* Forward declarations */

#ifndef __IMFAttributes_FWD_DEFINED__
#define __IMFAttributes_FWD_DEFINED__
typedef interface IMFAttributes IMFAttributes;
#endif

#ifndef __IMFMediaBuffer_FWD_DEFINED__
#define __IMFMediaBuffer_FWD_DEFINED__
typedef interface IMFMediaBuffer IMFMediaBuffer;
#endif

#ifndef __IMFSample_FWD_DEFINED__
#define __IMFSample_FWD_DEFINED__
typedef interface IMFSample IMFSample;
#endif

#ifndef __IMF2DBuffer_FWD_DEFINED__
#define __IMF2DBuffer_FWD_DEFINED__
typedef interface IMF2DBuffer IMF2DBuffer;
#endif

#ifndef __IMF2DBuffer2_FWD_DEFINED__
#define __IMF2DBuffer2_FWD_DEFINED__
typedef interface IMF2DBuffer2 IMF2DBuffer2;
#endif

#ifndef __IMFDXGIBuffer_FWD_DEFINED__
#define __IMFDXGIBuffer_FWD_DEFINED__
typedef interface IMFDXGIBuffer IMFDXGIBuffer;
#endif

#ifndef __IMFMediaType_FWD_DEFINED__
#define __IMFMediaType_FWD_DEFINED__
typedef interface IMFMediaType IMFMediaType;
#endif

#ifndef __IMFAudioMediaType_FWD_DEFINED__
#define __IMFAudioMediaType_FWD_DEFINED__
typedef interface IMFAudioMediaType IMFAudioMediaType;
#endif

#ifndef __IMFVideoMediaType_FWD_DEFINED__
#define __IMFVideoMediaType_FWD_DEFINED__
typedef interface IMFVideoMediaType IMFVideoMediaType;
#endif

#ifndef __IMFAsyncResult_FWD_DEFINED__
#define __IMFAsyncResult_FWD_DEFINED__
typedef interface IMFAsyncResult IMFAsyncResult;
#endif

#ifndef __IMFAsyncCallback_FWD_DEFINED__
#define __IMFAsyncCallback_FWD_DEFINED__
typedef interface IMFAsyncCallback IMFAsyncCallback;
#endif

#ifndef __IMFAsyncCallbackLogging_FWD_DEFINED__
#define __IMFAsyncCallbackLogging_FWD_DEFINED__
typedef interface IMFAsyncCallbackLogging IMFAsyncCallbackLogging;
#endif

#ifndef __IMFMediaEvent_FWD_DEFINED__
#define __IMFMediaEvent_FWD_DEFINED__
typedef interface IMFMediaEvent IMFMediaEvent;
#endif

#ifndef __IMFMediaEventGenerator_FWD_DEFINED__
#define __IMFMediaEventGenerator_FWD_DEFINED__
typedef interface IMFMediaEventGenerator IMFMediaEventGenerator;
#endif

#ifndef __IMFRemoteAsyncCallback_FWD_DEFINED__
#define __IMFRemoteAsyncCallback_FWD_DEFINED__
typedef interface IMFRemoteAsyncCallback IMFRemoteAsyncCallback;
#endif

#ifndef __IMFByteStream_FWD_DEFINED__
#define __IMFByteStream_FWD_DEFINED__
typedef interface IMFByteStream IMFByteStream;
#endif

#ifndef __IMFByteStreamProxyClassFactory_FWD_DEFINED__
#define __IMFByteStreamProxyClassFactory_FWD_DEFINED__
typedef interface IMFByteStreamProxyClassFactory IMFByteStreamProxyClassFactory;
#endif

#ifndef __IMFSampleOutputStream_FWD_DEFINED__
#define __IMFSampleOutputStream_FWD_DEFINED__
typedef interface IMFSampleOutputStream IMFSampleOutputStream;
#endif

#ifndef __IMFCollection_FWD_DEFINED__
#define __IMFCollection_FWD_DEFINED__
typedef interface IMFCollection IMFCollection;
#endif

#ifndef __IMFMediaEventQueue_FWD_DEFINED__
#define __IMFMediaEventQueue_FWD_DEFINED__
typedef interface IMFMediaEventQueue IMFMediaEventQueue;
#endif

#ifndef __IMFActivate_FWD_DEFINED__
#define __IMFActivate_FWD_DEFINED__
typedef interface IMFActivate IMFActivate;
#endif

#ifndef __IMFPluginControl_FWD_DEFINED__
#define __IMFPluginControl_FWD_DEFINED__
typedef interface IMFPluginControl IMFPluginControl;
#endif

#ifndef __IMFPluginControl2_FWD_DEFINED__
#define __IMFPluginControl2_FWD_DEFINED__
typedef interface IMFPluginControl2 IMFPluginControl2;
#endif

#ifndef __IMFDXGIDeviceManager_FWD_DEFINED__
#define __IMFDXGIDeviceManager_FWD_DEFINED__
typedef interface IMFDXGIDeviceManager IMFDXGIDeviceManager;
#endif

/* Headers for imported files */

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

#ifdef __cplusplus
extern "C" {
#endif

/**
 * This file is part of the mingw-w64 runtime package.
 * No warranty is given; refer to the file DISCLAIMER within this package.
 */

#include <winapifamily.h>


typedef ULONGLONG QWORD;

#include <mmreg.h>
#if 0
typedef struct tWAVEFORMATEX {
    WORD wFormatTag;
    WORD nChannels;
    DWORD nSamplesPerSec;
    DWORD nAvgBytesPerSec;
    WORD nBlockAlign;
    WORD wBitsPerSample;
    WORD cbSize;
    BYTE pExtraBytes[1];
} WAVEFORMATEX;
typedef struct tWAVEFORMATEX *PWAVEFORMATEX;
typedef struct tWAVEFORMATEX *NPWAVEFORMATEX;
typedef struct tWAVEFORMATEX *LPWAVEFORMATEX;
typedef struct __WIDL_mfobjects_generated_name_00000013 {
    WORD wFormatTag;
    WORD nChannels;
    DWORD nSamplesPerSec;
    DWORD nAvgBytesPerSec;
    WORD nBlockAlign;
    WORD wBitsPerSample;
    WORD cbSize;
    WORD wValidBitsPerSample;
    DWORD dwChannelMask;
    GUID SubFormat;
} WAVEFORMATEXTENSIBLE;
typedef struct __WIDL_mfobjects_generated_name_00000013 *PWAVEFORMATEXTENSIBLE;
#endif

#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
typedef enum _MF_ATTRIBUTE_TYPE {
    MF_ATTRIBUTE_UINT32 = VT_UI4,
    MF_ATTRIBUTE_UINT64 = VT_UI8,
    MF_ATTRIBUTE_DOUBLE = VT_R8,
    MF_ATTRIBUTE_GUID = VT_CLSID,
    MF_ATTRIBUTE_STRING = VT_LPWSTR,
    MF_ATTRIBUTE_BLOB = VT_VECTOR | VT_UI1,
    MF_ATTRIBUTE_IUNKNOWN = VT_UNKNOWN
} MF_ATTRIBUTE_TYPE;

typedef enum _MF_ATTRIBUTES_MATCH_TYPE {
    MF_ATTRIBUTES_MATCH_OUR_ITEMS = 0,
    MF_ATTRIBUTES_MATCH_THEIR_ITEMS = 1,
    MF_ATTRIBUTES_MATCH_ALL_ITEMS = 2,
    MF_ATTRIBUTES_MATCH_INTERSECTION = 3,
    MF_ATTRIBUTES_MATCH_SMALLER = 4
} MF_ATTRIBUTES_MATCH_TYPE;

/*****************************************************************************
 * IMFAttributes interface
 */
#ifndef __IMFAttributes_INTERFACE_DEFINED__
#define __IMFAttributes_INTERFACE_DEFINED__

DEFINE_GUID(IID_IMFAttributes, 0x2cd2d921, 0xc447, 0x44a7, 0xa1,0x3c, 0x4a,0xda,0xbf,0xc2,0x47,0xe3);
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("2cd2d921-c447-44a7-a13c-4adabfc247e3")
IMFAttributes : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE GetItem(
        REFGUID guidKey,
        PROPVARIANT *pValue) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetItemType(
        REFGUID guidKey,
        MF_ATTRIBUTE_TYPE *pType) = 0;

    virtual HRESULT STDMETHODCALLTYPE CompareItem(
        REFGUID guidKey,
        REFPROPVARIANT Value,
        WINBOOL *pbResult) = 0;

    virtual HRESULT STDMETHODCALLTYPE Compare(
        IMFAttributes *pTheirs,
        MF_ATTRIBUTES_MATCH_TYPE MatchType,
        WINBOOL *pbResult) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetUINT32(
        REFGUID guidKey,
        UINT32 *punValue) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetUINT64(
        REFGUID guidKey,
        UINT64 *punValue) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetDouble(
        REFGUID guidKey,
        double *pfValue) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetGUID(
        REFGUID guidKey,
        GUID *pguidValue) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetStringLength(
        REFGUID guidKey,
        UINT32 *pcchLength) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetString(
        REFGUID guidKey,
        LPWSTR pwszValue,
        UINT32 cchBufSize,
        UINT32 *pcchLength) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetAllocatedString(
        REFGUID guidKey,
        LPWSTR *ppwszValue,
        UINT32 *pcchLength) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetBlobSize(
        REFGUID guidKey,
        UINT32 *pcbBlobSize) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetBlob(
        REFGUID guidKey,
        UINT8 *pBuf,
        UINT32 cbBufSize,
        UINT32 *pcbBlobSize) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetAllocatedBlob(
        REFGUID guidKey,
        UINT8 **ppBuf,
        UINT32 *pcbSize) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetUnknown(
        REFGUID guidKey,
        REFIID riid,
        LPVOID *ppv) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetItem(
        REFGUID guidKey,
        REFPROPVARIANT Value) = 0;

    virtual HRESULT STDMETHODCALLTYPE DeleteItem(
        REFGUID guidKey) = 0;

    virtual HRESULT STDMETHODCALLTYPE DeleteAllItems(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetUINT32(
        REFGUID guidKey,
        UINT32 unValue) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetUINT64(
        REFGUID guidKey,
        UINT64 unValue) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetDouble(
        REFGUID guidKey,
        double fValue) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetGUID(
        REFGUID guidKey,
        REFGUID guidValue) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetString(
        REFGUID guidKey,
        LPCWSTR wszValue) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetBlob(
        REFGUID guidKey,
        const UINT8 *pBuf,
        UINT32 cbBufSize) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetUnknown(
        REFGUID guidKey,
        IUnknown *pUnknown) = 0;

    virtual HRESULT STDMETHODCALLTYPE LockStore(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE UnlockStore(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetCount(
        UINT32 *pcItems) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetItemByIndex(
        UINT32 unIndex,
        GUID *pguidKey,
        PROPVARIANT *pValue) = 0;

    virtual HRESULT STDMETHODCALLTYPE CopyAllItems(
        IMFAttributes *pDest) = 0;

};
#ifdef __CRT_UUID_DECL
__CRT_UUID_DECL(IMFAttributes, 0x2cd2d921, 0xc447, 0x44a7, 0xa1,0x3c, 0x4a,0xda,0xbf,0xc2,0x47,0xe3)
#endif
#else
typedef struct IMFAttributesVtbl {
    BEGIN_INTERFACE

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

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

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

    /*** IMFAttributes methods ***/
    HRESULT (STDMETHODCALLTYPE *GetItem)(
        IMFAttributes* This,
        REFGUID guidKey,
        PROPVARIANT *pValue);

    HRESULT (STDMETHODCALLTYPE *GetItemType)(
        IMFAttributes* This,
        REFGUID guidKey,
        MF_ATTRIBUTE_TYPE *pType);

    HRESULT (STDMETHODCALLTYPE *CompareItem)(
        IMFAttributes* This,
        REFGUID guidKey,
        REFPROPVARIANT Value,
        WINBOOL *pbResult);

    HRESULT (STDMETHODCALLTYPE *Compare)(
        IMFAttributes* This,
        IMFAttributes *pTheirs,
        MF_ATTRIBUTES_MATCH_TYPE MatchType,
        WINBOOL *pbResult);

    HRESULT (STDMETHODCALLTYPE *GetUINT32)(
        IMFAttributes* This,
        REFGUID guidKey,
        UINT32 *punValue);

    HRESULT (STDMETHODCALLTYPE *GetUINT64)(
        IMFAttributes* This,
        REFGUID guidKey,
        UINT64 *punValue);

    HRESULT (STDMETHODCALLTYPE *GetDouble)(
        IMFAttributes* This,
        REFGUID guidKey,
        double *pfValue);

    HRESULT (STDMETHODCALLTYPE *GetGUID)(
        IMFAttributes* This,
        REFGUID guidKey,
        GUID *pguidValue);

    HRESULT (STDMETHODCALLTYPE *GetStringLength)(
        IMFAttributes* This,
        REFGUID guidKey,
        UINT32 *pcchLength);

    HRESULT (STDMETHODCALLTYPE *GetString)(
        IMFAttributes* This,
        REFGUID guidKey,
        LPWSTR pwszValue,
        UINT32 cchBufSize,
        UINT32 *pcchLength);

    HRESULT (STDMETHODCALLTYPE *GetAllocatedString)(
        IMFAttributes* This,
        REFGUID guidKey,
        LPWSTR *ppwszValue,
        UINT32 *pcchLength);

    HRESULT (STDMETHODCALLTYPE *GetBlobSize)(
        IMFAttributes* This,
        REFGUID guidKey,
        UINT32 *pcbBlobSize);

    HRESULT (STDMETHODCALLTYPE *GetBlob)(
        IMFAttributes* This,
        REFGUID guidKey,
        UINT8 *pBuf,
        UINT32 cbBufSize,
        UINT32 *pcbBlobSize);

    HRESULT (STDMETHODCALLTYPE *GetAllocatedBlob)(
        IMFAttributes* This,
        REFGUID guidKey,
        UINT8 **ppBuf,
        UINT32 *pcbSize);

    HRESULT (STDMETHODCALLTYPE *GetUnknown)(
        IMFAttributes* This,
        REFGUID guidKey,
        REFIID riid,
        LPVOID *ppv);

    HRESULT (STDMETHODCALLTYPE *SetItem)(
        IMFAttributes* This,
        REFGUID guidKey,
        REFPROPVARIANT Value);

    HRESULT (STDMETHODCALLTYPE *DeleteItem)(
        IMFAttributes* This,
        REFGUID guidKey);

    HRESULT (STDMETHODCALLTYPE *DeleteAllItems)(
        IMFAttributes* This);

    HRESULT (STDMETHODCALLTYPE *SetUINT32)(
        IMFAttributes* This,
        REFGUID guidKey,
        UINT32 unValue);

    HRESULT (STDMETHODCALLTYPE *SetUINT64)(
        IMFAttributes* This,
        REFGUID guidKey,
        UINT64 unValue);

    HRESULT (STDMETHODCALLTYPE *SetDouble)(
        IMFAttributes* This,
        REFGUID guidKey,
        double fValue);

    HRESULT (STDMETHODCALLTYPE *SetGUID)(
        IMFAttributes* This,
        REFGUID guidKey,
        REFGUID guidValue);

    HRESULT (STDMETHODCALLTYPE *SetString)(
        IMFAttributes* This,
        REFGUID guidKey,
        LPCWSTR wszValue);

    HRESULT (STDMETHODCALLTYPE *SetBlob)(
        IMFAttributes* This,
        REFGUID guidKey,
        const UINT8 *pBuf,
        UINT32 cbBufSize);

    HRESULT (STDMETHODCALLTYPE *SetUnknown)(
        IMFAttributes* This,
        REFGUID guidKey,
        IUnknown *pUnknown);

    HRESULT (STDMETHODCALLTYPE *LockStore)(
        IMFAttributes* This);

    HRESULT (STDMETHODCALLTYPE *UnlockStore)(
        IMFAttributes* This);

    HRESULT (STDMETHODCALLTYPE *GetCount)(
        IMFAttributes* This,
        UINT32 *pcItems);

    HRESULT (STDMETHODCALLTYPE *GetItemByIndex)(
        IMFAttributes* This,
        UINT32 unIndex,
        GUID *pguidKey,
        PROPVARIANT *pValue);

    HRESULT (STDMETHODCALLTYPE *CopyAllItems)(
        IMFAttributes* This,
        IMFAttributes *pDest);

    END_INTERFACE
} IMFAttributesVtbl;
interface IMFAttributes {
    CONST_VTBL IMFAttributesVtbl* lpVtbl;
};

#ifdef COBJMACROS
#ifndef WIDL_C_INLINE_WRAPPERS
/*** IUnknown methods ***/
#define IMFAttributes_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
#define IMFAttributes_AddRef(This) (This)->lpVtbl->AddRef(This)
#define IMFAttributes_Release(This) (This)->lpVtbl->Release(This)
/*** IMFAttributes methods ***/
#define IMFAttributes_GetItem(This,guidKey,pValue) (This)->lpVtbl->GetItem(This,guidKey,pValue)
#define IMFAttributes_GetItemType(This,guidKey,pType) (This)->lpVtbl->GetItemType(This,guidKey,pType)
#define IMFAttributes_CompareItem(This,guidKey,Value,pbResult) (This)->lpVtbl->CompareItem(This,guidKey,Value,pbResult)
#define IMFAttributes_Compare(This,pTheirs,MatchType,pbResult) (This)->lpVtbl->Compare(This,pTheirs,MatchType,pbResult)
#define IMFAttributes_GetUINT32(This,guidKey,punValue) (This)->lpVtbl->GetUINT32(This,guidKey,punValue)
#define IMFAttributes_GetUINT64(This,guidKey,punValue) (This)->lpVtbl->GetUINT64(This,guidKey,punValue)
#define IMFAttributes_GetDouble(This,guidKey,pfValue) (This)->lpVtbl->GetDouble(This,guidKey,pfValue)
#define IMFAttributes_GetGUID(This,guidKey,pguidValue) (This)->lpVtbl->GetGUID(This,guidKey,pguidValue)
#define IMFAttributes_GetStringLength(This,guidKey,pcchLength) (This)->lpVtbl->GetStringLength(This,guidKey,pcchLength)
#define IMFAttributes_GetString(This,guidKey,pwszValue,cchBufSize,pcchLength) (This)->lpVtbl->GetString(This,guidKey,pwszValue,cchBufSize,pcchLength)
#define IMFAttributes_GetAllocatedString(This,guidKey,ppwszValue,pcchLength) (This)->lpVtbl->GetAllocatedString(This,guidKey,ppwszValue,pcchLength)
#define IMFAttributes_GetBlobSize(This,guidKey,pcbBlobSize) (This)->lpVtbl->GetBlobSize(This,guidKey,pcbBlobSize)
#define IMFAttributes_GetBlob(This,guidKey,pBuf,cbBufSize,pcbBlobSize) (This)->lpVtbl->GetBlob(This,guidKey,pBuf,cbBufSize,pcbBlobSize)
#define IMFAttributes_GetAllocatedBlob(This,guidKey,ppBuf,pcbSize) (This)->lpVtbl->GetAllocatedBlob(This,guidKey,ppBuf,pcbSize)
#define IMFAttributes_GetUnknown(This,guidKey,riid,ppv) (This)->lpVtbl->GetUnknown(This,guidKey,riid,ppv)
#define IMFAttributes_SetItem(This,guidKey,Value) (This)->lpVtbl->SetItem(This,guidKey,Value)
#define IMFAttributes_DeleteItem(This,guidKey) (This)->lpVtbl->DeleteItem(This,guidKey)
#define IMFAttributes_DeleteAllItems(This) (This)->lpVtbl->DeleteAllItems(This)
#define IMFAttributes_SetUINT32(This,guidKey,unValue) (This)->lpVtbl->SetUINT32(This,guidKey,unValue)
#define IMFAttributes_SetUINT64(This,guidKey,unValue) (This)->lpVtbl->SetUINT64(This,guidKey,unValue)
#define IMFAttributes_SetDouble(This,guidKey,fValue) (This)->lpVtbl->SetDouble(This,guidKey,fValue)
#define IMFAttributes_SetGUID(This,guidKey,guidValue) (This)->lpVtbl->SetGUID(This,guidKey,guidValue)
#define IMFAttributes_SetString(This,guidKey,wszValue) (This)->lpVtbl->SetString(This,guidKey,wszValue)
#define IMFAttributes_SetBlob(This,guidKey,pBuf,cbBufSize) (This)->lpVtbl->SetBlob(This,guidKey,pBuf,cbBufSize)
#define IMFAttributes_SetUnknown(This,guidKey,pUnknown) (This)->lpVtbl->SetUnknown(This,guidKey,pUnknown)
#define IMFAttributes_LockStore(This) (This)->lpVtbl->LockStore(This)
#define IMFAttributes_UnlockStore(This) (This)->lpVtbl->UnlockStore(This)
#define IMFAttributes_GetCount(This,pcItems) (This)->lpVtbl->GetCount(This,pcItems)
#define IMFAttributes_GetItemByIndex(This,unIndex,pguidKey,pValue) (This)->lpVtbl->GetItemByIndex(This,unIndex,pguidKey,pValue)
#define IMFAttributes_CopyAllItems(This,pDest) (This)->lpVtbl->CopyAllItems(This,pDest)
#else
/*** IUnknown methods ***/
static FORCEINLINE HRESULT IMFAttributes_QueryInterface(IMFAttributes* This,REFIID riid,void **ppvObject) {
    return This->lpVtbl->QueryInterface(This,riid,ppvObject);
}
static FORCEINLINE ULONG IMFAttributes_AddRef(IMFAttributes* This) {
    return This->lpVtbl->AddRef(This);
}
static FORCEINLINE ULONG IMFAttributes_Release(IMFAttributes* This) {
    return This->lpVtbl->Release(This);
}
/*** IMFAttributes methods ***/
static FORCEINLINE HRESULT IMFAttributes_GetItem(IMFAttributes* This,REFGUID guidKey,PROPVARIANT *pValue) {
    return This->lpVtbl->GetItem(This,guidKey,pValue);
}
static FORCEINLINE HRESULT IMFAttributes_GetItemType(IMFAttributes* This,REFGUID guidKey,MF_ATTRIBUTE_TYPE *pType) {
    return This->lpVtbl->GetItemType(This,guidKey,pType);
}
static FORCEINLINE HRESULT IMFAttributes_CompareItem(IMFAttributes* This,REFGUID guidKey,REFPROPVARIANT Value,WINBOOL *pbResult) {
    return This->lpVtbl->CompareItem(This,guidKey,Value,pbResult);
}
static FORCEINLINE HRESULT IMFAttributes_Compare(IMFAttributes* This,IMFAttributes *pTheirs,MF_ATTRIBUTES_MATCH_TYPE MatchType,WINBOOL *pbResult) {
    return This->lpVtbl->Compare(This,pTheirs,MatchType,pbResult);
}
static FORCEINLINE HRESULT IMFAttributes_GetUINT32(IMFAttributes* This,REFGUID guidKey,UINT32 *punValue) {
    return This->lpVtbl->GetUINT32(This,guidKey,punValue);
}
static FORCEINLINE HRESULT IMFAttributes_GetUINT64(IMFAttributes* This,REFGUID guidKey,UINT64 *punValue) {
    return This->lpVtbl->GetUINT64(This,guidKey,punValue);
}
static FORCEINLINE HRESULT IMFAttributes_GetDouble(IMFAttributes* This,REFGUID guidKey,double *pfValue) {
    return This->lpVtbl->GetDouble(This,guidKey,pfValue);
}
static FORCEINLINE HRESULT IMFAttributes_GetGUID(IMFAttributes* This,REFGUID guidKey,GUID *pguidValue) {
    return This->lpVtbl->GetGUID(This,guidKey,pguidValue);
}
static FORCEINLINE HRESULT IMFAttributes_GetStringLength(IMFAttributes* This,REFGUID guidKey,UINT32 *pcchLength) {
    return This->lpVtbl->GetStringLength(This,guidKey,pcchLength);
}
static FORCEINLINE HRESULT IMFAttributes_GetString(IMFAttributes* This,REFGUID guidKey,LPWSTR pwszValue,UINT32 cchBufSize,UINT32 *pcchLength) {
    return This->lpVtbl->GetString(This,guidKey,pwszValue,cchBufSize,pcchLength);
}
static FORCEINLINE HRESULT IMFAttributes_GetAllocatedString(IMFAttributes* This,REFGUID guidKey,LPWSTR *ppwszValue,UINT32 *pcchLength) {
    return This->lpVtbl->GetAllocatedString(This,guidKey,ppwszValue,pcchLength);
}
static FORCEINLINE HRESULT IMFAttributes_GetBlobSize(IMFAttributes* This,REFGUID guidKey,UINT32 *pcbBlobSize) {
    return This->lpVtbl->GetBlobSize(This,guidKey,pcbBlobSize);
}
static FORCEINLINE HRESULT IMFAttributes_GetBlob(IMFAttributes* This,REFGUID guidKey,UINT8 *pBuf,UINT32 cbBufSize,UINT32 *pcbBlobSize) {
    return This->lpVtbl->GetBlob(This,guidKey,pBuf,cbBufSize,pcbBlobSize);
}
static FORCEINLINE HRESULT IMFAttributes_GetAllocatedBlob(IMFAttributes* This,REFGUID guidKey,UINT8 **ppBuf,UINT32 *pcbSize) {
    return This->lpVtbl->GetAllocatedBlob(This,guidKey,ppBuf,pcbSize);
}
static FORCEINLINE HRESULT IMFAttributes_GetUnknown(IMFAttributes* This,REFGUID guidKey,REFIID riid,LPVOID *ppv) {
    return This->lpVtbl->GetUnknown(This,guidKey,riid,ppv);
}
static FORCEINLINE HRESULT IMFAttributes_SetItem(IMFAttributes* This,REFGUID guidKey,REFPROPVARIANT Value) {
    return This->lpVtbl->SetItem(This,guidKey,Value);
}
static FORCEINLINE HRESULT IMFAttributes_DeleteItem(IMFAttributes* This,REFGUID guidKey) {
    return This->lpVtbl->DeleteItem(This,guidKey);
}
static FORCEINLINE HRESULT IMFAttributes_DeleteAllItems(IMFAttributes* This) {
    return This->lpVtbl->DeleteAllItems(This);
}
static FORCEINLINE HRESULT IMFAttributes_SetUINT32(IMFAttributes* This,REFGUID guidKey,UINT32 unValue) {
    return This->lpVtbl->SetUINT32(This,guidKey,unValue);
}
static FORCEINLINE HRESULT IMFAttributes_SetUINT64(IMFAttributes* This,REFGUID guidKey,UINT64 unValue) {
    return This->lpVtbl->SetUINT64(This,guidKey,unValue);
}
static FORCEINLINE HRESULT IMFAttributes_SetDouble(IMFAttributes* This,REFGUID guidKey,double fValue) {
    return This->lpVtbl->SetDouble(This,guidKey,fValue);
}
static FORCEINLINE HRESULT IMFAttributes_SetGUID(IMFAttributes* This,REFGUID guidKey,REFGUID guidValue) {
    return This->lpVtbl->SetGUID(This,guidKey,guidValue);
}
static FORCEINLINE HRESULT IMFAttributes_SetString(IMFAttributes* This,REFGUID guidKey,LPCWSTR wszValue) {
    return This->lpVtbl->SetString(This,guidKey,wszValue);
}
static FORCEINLINE HRESULT IMFAttributes_SetBlob(IMFAttributes* This,REFGUID guidKey,const UINT8 *pBuf,UINT32 cbBufSize) {
    return This->lpVtbl->SetBlob(This,guidKey,pBuf,cbBufSize);
}
static FORCEINLINE HRESULT IMFAttributes_SetUnknown(IMFAttributes* This,REFGUID guidKey,IUnknown *pUnknown) {
    return This->lpVtbl->SetUnknown(This,guidKey,pUnknown);
}
static FORCEINLINE HRESULT IMFAttributes_LockStore(IMFAttributes* This) {
    return This->lpVtbl->LockStore(This);
}
static FORCEINLINE HRESULT IMFAttributes_UnlockStore(IMFAttributes* This) {
    return This->lpVtbl->UnlockStore(This);
}
static FORCEINLINE HRESULT IMFAttributes_GetCount(IMFAttributes* This,UINT32 *pcItems) {
    return This->lpVtbl->GetCount(This,pcItems);
}
static FORCEINLINE HRESULT IMFAttributes_GetItemByIndex(IMFAttributes* This,UINT32 unIndex,GUID *pguidKey,PROPVARIANT *pValue) {
    return This->lpVtbl->GetItemByIndex(This,unIndex,pguidKey,pValue);
}
static FORCEINLINE HRESULT IMFAttributes_CopyAllItems(IMFAttributes* This,IMFAttributes *pDest) {
    return This->lpVtbl->CopyAllItems(This,pDest);
}
#endif
#endif

#endif

HRESULT STDMETHODCALLTYPE IMFAttributes_GetItem_Proxy(
    IMFAttributes* This,
    REFGUID guidKey,
    PROPVARIANT *pValue);
void __RPC_STUB IMFAttributes_GetItem_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFAttributes_GetItemType_Proxy(
    IMFAttributes* This,
    REFGUID guidKey,
    MF_ATTRIBUTE_TYPE *pType);
void __RPC_STUB IMFAttributes_GetItemType_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFAttributes_CompareItem_Proxy(
    IMFAttributes* This,
    REFGUID guidKey,
    REFPROPVARIANT Value,
    WINBOOL *pbResult);
void __RPC_STUB IMFAttributes_CompareItem_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFAttributes_Compare_Proxy(
    IMFAttributes* This,
    IMFAttributes *pTheirs,
    MF_ATTRIBUTES_MATCH_TYPE MatchType,
    WINBOOL *pbResult);
void __RPC_STUB IMFAttributes_Compare_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFAttributes_GetUINT32_Proxy(
    IMFAttributes* This,
    REFGUID guidKey,
    UINT32 *punValue);
void __RPC_STUB IMFAttributes_GetUINT32_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFAttributes_GetUINT64_Proxy(
    IMFAttributes* This,
    REFGUID guidKey,
    UINT64 *punValue);
void __RPC_STUB IMFAttributes_GetUINT64_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFAttributes_GetDouble_Proxy(
    IMFAttributes* This,
    REFGUID guidKey,
    double *pfValue);
void __RPC_STUB IMFAttributes_GetDouble_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFAttributes_GetGUID_Proxy(
    IMFAttributes* This,
    REFGUID guidKey,
    GUID *pguidValue);
void __RPC_STUB IMFAttributes_GetGUID_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFAttributes_GetStringLength_Proxy(
    IMFAttributes* This,
    REFGUID guidKey,
    UINT32 *pcchLength);
void __RPC_STUB IMFAttributes_GetStringLength_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFAttributes_GetString_Proxy(
    IMFAttributes* This,
    REFGUID guidKey,
    LPWSTR pwszValue,
    UINT32 cchBufSize,
    UINT32 *pcchLength);
void __RPC_STUB IMFAttributes_GetString_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFAttributes_GetAllocatedString_Proxy(
    IMFAttributes* This,
    REFGUID guidKey,
    LPWSTR *ppwszValue,
    UINT32 *pcchLength);
void __RPC_STUB IMFAttributes_GetAllocatedString_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFAttributes_GetBlobSize_Proxy(
    IMFAttributes* This,
    REFGUID guidKey,
    UINT32 *pcbBlobSize);
void __RPC_STUB IMFAttributes_GetBlobSize_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFAttributes_GetBlob_Proxy(
    IMFAttributes* This,
    REFGUID guidKey,
    UINT8 *pBuf,
    UINT32 cbBufSize,
    UINT32 *pcbBlobSize);
void __RPC_STUB IMFAttributes_GetBlob_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFAttributes_GetAllocatedBlob_Proxy(
    IMFAttributes* This,
    REFGUID guidKey,
    UINT8 **ppBuf,
    UINT32 *pcbSize);
void __RPC_STUB IMFAttributes_GetAllocatedBlob_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFAttributes_GetUnknown_Proxy(
    IMFAttributes* This,
    REFGUID guidKey,
    REFIID riid,
    LPVOID *ppv);
void __RPC_STUB IMFAttributes_GetUnknown_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFAttributes_SetItem_Proxy(
    IMFAttributes* This,
    REFGUID guidKey,
    REFPROPVARIANT Value);
void __RPC_STUB IMFAttributes_SetItem_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFAttributes_DeleteItem_Proxy(
    IMFAttributes* This,
    REFGUID guidKey);
void __RPC_STUB IMFAttributes_DeleteItem_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFAttributes_DeleteAllItems_Proxy(
    IMFAttributes* This);
void __RPC_STUB IMFAttributes_DeleteAllItems_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFAttributes_SetUINT32_Proxy(
    IMFAttributes* This,
    REFGUID guidKey,
    UINT32 unValue);
void __RPC_STUB IMFAttributes_SetUINT32_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFAttributes_SetUINT64_Proxy(
    IMFAttributes* This,
    REFGUID guidKey,
    UINT64 unValue);
void __RPC_STUB IMFAttributes_SetUINT64_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFAttributes_SetDouble_Proxy(
    IMFAttributes* This,
    REFGUID guidKey,
    double fValue);
void __RPC_STUB IMFAttributes_SetDouble_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFAttributes_SetGUID_Proxy(
    IMFAttributes* This,
    REFGUID guidKey,
    REFGUID guidValue);
void __RPC_STUB IMFAttributes_SetGUID_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFAttributes_SetString_Proxy(
    IMFAttributes* This,
    REFGUID guidKey,
    LPCWSTR wszValue);
void __RPC_STUB IMFAttributes_SetString_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFAttributes_SetBlob_Proxy(
    IMFAttributes* This,
    REFGUID guidKey,
    const UINT8 *pBuf,
    UINT32 cbBufSize);
void __RPC_STUB IMFAttributes_SetBlob_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFAttributes_SetUnknown_Proxy(
    IMFAttributes* This,
    REFGUID guidKey,
    IUnknown *pUnknown);
void __RPC_STUB IMFAttributes_SetUnknown_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFAttributes_LockStore_Proxy(
    IMFAttributes* This);
void __RPC_STUB IMFAttributes_LockStore_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFAttributes_UnlockStore_Proxy(
    IMFAttributes* This);
void __RPC_STUB IMFAttributes_UnlockStore_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFAttributes_GetCount_Proxy(
    IMFAttributes* This,
    UINT32 *pcItems);
void __RPC_STUB IMFAttributes_GetCount_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFAttributes_GetItemByIndex_Proxy(
    IMFAttributes* This,
    UINT32 unIndex,
    GUID *pguidKey,
    PROPVARIANT *pValue);
void __RPC_STUB IMFAttributes_GetItemByIndex_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFAttributes_CopyAllItems_Proxy(
    IMFAttributes* This,
    IMFAttributes *pDest);
void __RPC_STUB IMFAttributes_CopyAllItems_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IMFAttributes_INTERFACE_DEFINED__ */


enum MF_ATTRIBUTE_SERIALIZE_OPTIONS {
    MF_ATTRIBUTE_SERIALIZE_UNKNOWN_BYREF = 0x1
};


STDAPI MFSerializeAttributesToStream(IMFAttributes *pAttr, DWORD dwOptions, IStream *pStm);
STDAPI MFDeserializeAttributesFromStream(IMFAttributes *pAttr, DWORD dwOptions, IStream *pStm);

/*****************************************************************************
 * IMFMediaBuffer interface
 */
#ifndef __IMFMediaBuffer_INTERFACE_DEFINED__
#define __IMFMediaBuffer_INTERFACE_DEFINED__

DEFINE_GUID(IID_IMFMediaBuffer, 0x045fa593, 0x8799, 0x42b8, 0xbc,0x8d, 0x89,0x68,0xc6,0x45,0x35,0x07);
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("045fa593-8799-42b8-bc8d-8968c6453507")
IMFMediaBuffer : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE Lock(
        BYTE **ppbBuffer,
        DWORD *pcbMaxLength,
        DWORD *pcbCurrentLength) = 0;

    virtual HRESULT STDMETHODCALLTYPE Unlock(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetCurrentLength(
        DWORD *pcbCurrentLength) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetCurrentLength(
        DWORD cbCurrentLength) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetMaxLength(
        DWORD *pcbMaxLength) = 0;

};
#ifdef __CRT_UUID_DECL
__CRT_UUID_DECL(IMFMediaBuffer, 0x045fa593, 0x8799, 0x42b8, 0xbc,0x8d, 0x89,0x68,0xc6,0x45,0x35,0x07)
#endif
#else
typedef struct IMFMediaBufferVtbl {
    BEGIN_INTERFACE

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

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

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

    /*** IMFMediaBuffer methods ***/
    HRESULT (STDMETHODCALLTYPE *Lock)(
        IMFMediaBuffer* This,
        BYTE **ppbBuffer,
        DWORD *pcbMaxLength,
        DWORD *pcbCurrentLength);

    HRESULT (STDMETHODCALLTYPE *Unlock)(
        IMFMediaBuffer* This);

    HRESULT (STDMETHODCALLTYPE *GetCurrentLength)(
        IMFMediaBuffer* This,
        DWORD *pcbCurrentLength);

    HRESULT (STDMETHODCALLTYPE *SetCurrentLength)(
        IMFMediaBuffer* This,
        DWORD cbCurrentLength);

    HRESULT (STDMETHODCALLTYPE *GetMaxLength)(
        IMFMediaBuffer* This,
        DWORD *pcbMaxLength);

    END_INTERFACE
} IMFMediaBufferVtbl;
interface IMFMediaBuffer {
    CONST_VTBL IMFMediaBufferVtbl* lpVtbl;
};

#ifdef COBJMACROS
#ifndef WIDL_C_INLINE_WRAPPERS
/*** IUnknown methods ***/
#define IMFMediaBuffer_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
#define IMFMediaBuffer_AddRef(This) (This)->lpVtbl->AddRef(This)
#define IMFMediaBuffer_Release(This) (This)->lpVtbl->Release(This)
/*** IMFMediaBuffer methods ***/
#define IMFMediaBuffer_Lock(This,ppbBuffer,pcbMaxLength,pcbCurrentLength) (This)->lpVtbl->Lock(This,ppbBuffer,pcbMaxLength,pcbCurrentLength)
#define IMFMediaBuffer_Unlock(This) (This)->lpVtbl->Unlock(This)
#define IMFMediaBuffer_GetCurrentLength(This,pcbCurrentLength) (This)->lpVtbl->GetCurrentLength(This,pcbCurrentLength)
#define IMFMediaBuffer_SetCurrentLength(This,cbCurrentLength) (This)->lpVtbl->SetCurrentLength(This,cbCurrentLength)
#define IMFMediaBuffer_GetMaxLength(This,pcbMaxLength) (This)->lpVtbl->GetMaxLength(This,pcbMaxLength)
#else
/*** IUnknown methods ***/
static FORCEINLINE HRESULT IMFMediaBuffer_QueryInterface(IMFMediaBuffer* This,REFIID riid,void **ppvObject) {
    return This->lpVtbl->QueryInterface(This,riid,ppvObject);
}
static FORCEINLINE ULONG IMFMediaBuffer_AddRef(IMFMediaBuffer* This) {
    return This->lpVtbl->AddRef(This);
}
static FORCEINLINE ULONG IMFMediaBuffer_Release(IMFMediaBuffer* This) {
    return This->lpVtbl->Release(This);
}
/*** IMFMediaBuffer methods ***/
static FORCEINLINE HRESULT IMFMediaBuffer_Lock(IMFMediaBuffer* This,BYTE **ppbBuffer,DWORD *pcbMaxLength,DWORD *pcbCurrentLength) {
    return This->lpVtbl->Lock(This,ppbBuffer,pcbMaxLength,pcbCurrentLength);
}
static FORCEINLINE HRESULT IMFMediaBuffer_Unlock(IMFMediaBuffer* This) {
    return This->lpVtbl->Unlock(This);
}
static FORCEINLINE HRESULT IMFMediaBuffer_GetCurrentLength(IMFMediaBuffer* This,DWORD *pcbCurrentLength) {
    return This->lpVtbl->GetCurrentLength(This,pcbCurrentLength);
}
static FORCEINLINE HRESULT IMFMediaBuffer_SetCurrentLength(IMFMediaBuffer* This,DWORD cbCurrentLength) {
    return This->lpVtbl->SetCurrentLength(This,cbCurrentLength);
}
static FORCEINLINE HRESULT IMFMediaBuffer_GetMaxLength(IMFMediaBuffer* This,DWORD *pcbMaxLength) {
    return This->lpVtbl->GetMaxLength(This,pcbMaxLength);
}
#endif
#endif

#endif

HRESULT STDMETHODCALLTYPE IMFMediaBuffer_Lock_Proxy(
    IMFMediaBuffer* This,
    BYTE **ppbBuffer,
    DWORD *pcbMaxLength,
    DWORD *pcbCurrentLength);
void __RPC_STUB IMFMediaBuffer_Lock_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFMediaBuffer_Unlock_Proxy(
    IMFMediaBuffer* This);
void __RPC_STUB IMFMediaBuffer_Unlock_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFMediaBuffer_GetCurrentLength_Proxy(
    IMFMediaBuffer* This,
    DWORD *pcbCurrentLength);
void __RPC_STUB IMFMediaBuffer_GetCurrentLength_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFMediaBuffer_SetCurrentLength_Proxy(
    IMFMediaBuffer* This,
    DWORD cbCurrentLength);
void __RPC_STUB IMFMediaBuffer_SetCurrentLength_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFMediaBuffer_GetMaxLength_Proxy(
    IMFMediaBuffer* This,
    DWORD *pcbMaxLength);
void __RPC_STUB IMFMediaBuffer_GetMaxLength_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IMFMediaBuffer_INTERFACE_DEFINED__ */


/*****************************************************************************
 * IMFSample interface
 */
#ifndef __IMFSample_INTERFACE_DEFINED__
#define __IMFSample_INTERFACE_DEFINED__

DEFINE_GUID(IID_IMFSample, 0xc40a00f2, 0xb93a, 0x4d80, 0xae,0x8c, 0x5a,0x1c,0x63,0x4f,0x58,0xe4);
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("c40a00f2-b93a-4d80-ae8c-5a1c634f58e4")
IMFSample : public IMFAttributes
{
    virtual HRESULT STDMETHODCALLTYPE GetSampleFlags(
        DWORD *pdwSampleFlags) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetSampleFlags(
        DWORD dwSampleFlags) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetSampleTime(
        LONGLONG *phnsSampleTime) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetSampleTime(
        LONGLONG hnsSampleTime) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetSampleDuration(
        LONGLONG *phnsSampleDuration) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetSampleDuration(
        LONGLONG hnsSampleDuration) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetBufferCount(
        DWORD *pdwBufferCount) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetBufferByIndex(
        DWORD dwIndex,
        IMFMediaBuffer **ppBuffer) = 0;

    virtual HRESULT STDMETHODCALLTYPE ConvertToContiguousBuffer(
        IMFMediaBuffer **ppBuffer) = 0;

    virtual HRESULT STDMETHODCALLTYPE AddBuffer(
        IMFMediaBuffer *pBuffer) = 0;

    virtual HRESULT STDMETHODCALLTYPE RemoveBufferByIndex(
        DWORD dwIndex) = 0;

    virtual HRESULT STDMETHODCALLTYPE RemoveAllBuffers(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetTotalLength(
        DWORD *pcbTotalLength) = 0;

    virtual HRESULT STDMETHODCALLTYPE CopyToBuffer(
        IMFMediaBuffer *pBuffer) = 0;

};
#ifdef __CRT_UUID_DECL
__CRT_UUID_DECL(IMFSample, 0xc40a00f2, 0xb93a, 0x4d80, 0xae,0x8c, 0x5a,0x1c,0x63,0x4f,0x58,0xe4)
#endif
#else
typedef struct IMFSampleVtbl {
    BEGIN_INTERFACE

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

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

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

    /*** IMFAttributes methods ***/
    HRESULT (STDMETHODCALLTYPE *GetItem)(
        IMFSample* This,
        REFGUID guidKey,
        PROPVARIANT *pValue);

    HRESULT (STDMETHODCALLTYPE *GetItemType)(
        IMFSample* This,
        REFGUID guidKey,
        MF_ATTRIBUTE_TYPE *pType);

    HRESULT (STDMETHODCALLTYPE *CompareItem)(
        IMFSample* This,
        REFGUID guidKey,
        REFPROPVARIANT Value,
        WINBOOL *pbResult);

    HRESULT (STDMETHODCALLTYPE *Compare)(
        IMFSample* This,
        IMFAttributes *pTheirs,
        MF_ATTRIBUTES_MATCH_TYPE MatchType,
        WINBOOL *pbResult);

    HRESULT (STDMETHODCALLTYPE *GetUINT32)(
        IMFSample* This,
        REFGUID guidKey,
        UINT32 *punValue);

    HRESULT (STDMETHODCALLTYPE *GetUINT64)(
        IMFSample* This,
        REFGUID guidKey,
        UINT64 *punValue);

    HRESULT (STDMETHODCALLTYPE *GetDouble)(
        IMFSample* This,
        REFGUID guidKey,
        double *pfValue);

    HRESULT (STDMETHODCALLTYPE *GetGUID)(
        IMFSample* This,
        REFGUID guidKey,
        GUID *pguidValue);

    HRESULT (STDMETHODCALLTYPE *GetStringLength)(
        IMFSample* This,
        REFGUID guidKey,
        UINT32 *pcchLength);

    HRESULT (STDMETHODCALLTYPE *GetString)(
        IMFSample* This,
        REFGUID guidKey,
        LPWSTR pwszValue,
        UINT32 cchBufSize,
        UINT32 *pcchLength);

    HRESULT (STDMETHODCALLTYPE *GetAllocatedString)(
        IMFSample* This,
        REFGUID guidKey,
        LPWSTR *ppwszValue,
        UINT32 *pcchLength);

    HRESULT (STDMETHODCALLTYPE *GetBlobSize)(
        IMFSample* This,
        REFGUID guidKey,
        UINT32 *pcbBlobSize);

    HRESULT (STDMETHODCALLTYPE *GetBlob)(
        IMFSample* This,
        REFGUID guidKey,
        UINT8 *pBuf,
        UINT32 cbBufSize,
        UINT32 *pcbBlobSize);

    HRESULT (STDMETHODCALLTYPE *GetAllocatedBlob)(
        IMFSample* This,
        REFGUID guidKey,
        UINT8 **ppBuf,
        UINT32 *pcbSize);

    HRESULT (STDMETHODCALLTYPE *GetUnknown)(
        IMFSample* This,
        REFGUID guidKey,
        REFIID riid,
        LPVOID *ppv);

    HRESULT (STDMETHODCALLTYPE *SetItem)(
        IMFSample* This,
        REFGUID guidKey,
        REFPROPVARIANT Value);

    HRESULT (STDMETHODCALLTYPE *DeleteItem)(
        IMFSample* This,
        REFGUID guidKey);

    HRESULT (STDMETHODCALLTYPE *DeleteAllItems)(
        IMFSample* This);

    HRESULT (STDMETHODCALLTYPE *SetUINT32)(
        IMFSample* This,
        REFGUID guidKey,
        UINT32 unValue);

    HRESULT (STDMETHODCALLTYPE *SetUINT64)(
        IMFSample* This,
        REFGUID guidKey,
        UINT64 unValue);

    HRESULT (STDMETHODCALLTYPE *SetDouble)(
        IMFSample* This,
        REFGUID guidKey,
        double fValue);

    HRESULT (STDMETHODCALLTYPE *SetGUID)(
        IMFSample* This,
        REFGUID guidKey,
        REFGUID guidValue);

    HRESULT (STDMETHODCALLTYPE *SetString)(
        IMFSample* This,
        REFGUID guidKey,
        LPCWSTR wszValue);

    HRESULT (STDMETHODCALLTYPE *SetBlob)(
        IMFSample* This,
        REFGUID guidKey,
        const UINT8 *pBuf,
        UINT32 cbBufSize);

    HRESULT (STDMETHODCALLTYPE *SetUnknown)(
        IMFSample* This,
        REFGUID guidKey,
        IUnknown *pUnknown);

    HRESULT (STDMETHODCALLTYPE *LockStore)(
        IMFSample* This);

    HRESULT (STDMETHODCALLTYPE *UnlockStore)(
        IMFSample* This);

    HRESULT (STDMETHODCALLTYPE *GetCount)(
        IMFSample* This,
        UINT32 *pcItems);

    HRESULT (STDMETHODCALLTYPE *GetItemByIndex)(
        IMFSample* This,
        UINT32 unIndex,
        GUID *pguidKey,
        PROPVARIANT *pValue);

    HRESULT (STDMETHODCALLTYPE *CopyAllItems)(
        IMFSample* This,
        IMFAttributes *pDest);

    /*** IMFSample methods ***/
    HRESULT (STDMETHODCALLTYPE *GetSampleFlags)(
        IMFSample* This,
        DWORD *pdwSampleFlags);

    HRESULT (STDMETHODCALLTYPE *SetSampleFlags)(
        IMFSample* This,
        DWORD dwSampleFlags);

    HRESULT (STDMETHODCALLTYPE *GetSampleTime)(
        IMFSample* This,
        LONGLONG *phnsSampleTime);

    HRESULT (STDMETHODCALLTYPE *SetSampleTime)(
        IMFSample* This,
        LONGLONG hnsSampleTime);

    HRESULT (STDMETHODCALLTYPE *GetSampleDuration)(
        IMFSample* This,
        LONGLONG *phnsSampleDuration);

    HRESULT (STDMETHODCALLTYPE *SetSampleDuration)(
        IMFSample* This,
        LONGLONG hnsSampleDuration);

    HRESULT (STDMETHODCALLTYPE *GetBufferCount)(
        IMFSample* This,
        DWORD *pdwBufferCount);

    HRESULT (STDMETHODCALLTYPE *GetBufferByIndex)(
        IMFSample* This,
        DWORD dwIndex,
        IMFMediaBuffer **ppBuffer);

    HRESULT (STDMETHODCALLTYPE *ConvertToContiguousBuffer)(
        IMFSample* This,
        IMFMediaBuffer **ppBuffer);

    HRESULT (STDMETHODCALLTYPE *AddBuffer)(
        IMFSample* This,
        IMFMediaBuffer *pBuffer);

    HRESULT (STDMETHODCALLTYPE *RemoveBufferByIndex)(
        IMFSample* This,
        DWORD dwIndex);

    HRESULT (STDMETHODCALLTYPE *RemoveAllBuffers)(
        IMFSample* This);

    HRESULT (STDMETHODCALLTYPE *GetTotalLength)(
        IMFSample* This,
        DWORD *pcbTotalLength);

    HRESULT (STDMETHODCALLTYPE *CopyToBuffer)(
        IMFSample* This,
        IMFMediaBuffer *pBuffer);

    END_INTERFACE
} IMFSampleVtbl;
interface IMFSample {
    CONST_VTBL IMFSampleVtbl* lpVtbl;
};

#ifdef COBJMACROS
#ifndef WIDL_C_INLINE_WRAPPERS
/*** IUnknown methods ***/
#define IMFSample_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
#define IMFSample_AddRef(This) (This)->lpVtbl->AddRef(This)
#define IMFSample_Release(This) (This)->lpVtbl->Release(This)
/*** IMFAttributes methods ***/
#define IMFSample_GetItem(This,guidKey,pValue) (This)->lpVtbl->GetItem(This,guidKey,pValue)
#define IMFSample_GetItemType(This,guidKey,pType) (This)->lpVtbl->GetItemType(This,guidKey,pType)
#define IMFSample_CompareItem(This,guidKey,Value,pbResult) (This)->lpVtbl->CompareItem(This,guidKey,Value,pbResult)
#define IMFSample_Compare(This,pTheirs,MatchType,pbResult) (This)->lpVtbl->Compare(This,pTheirs,MatchType,pbResult)
#define IMFSample_GetUINT32(This,guidKey,punValue) (This)->lpVtbl->GetUINT32(This,guidKey,punValue)
#define IMFSample_GetUINT64(This,guidKey,punValue) (This)->lpVtbl->GetUINT64(This,guidKey,punValue)
#define IMFSample_GetDouble(This,guidKey,pfValue) (This)->lpVtbl->GetDouble(This,guidKey,pfValue)
#define IMFSample_GetGUID(This,guidKey,pguidValue) (This)->lpVtbl->GetGUID(This,guidKey,pguidValue)
#define IMFSample_GetStringLength(This,guidKey,pcchLength) (This)->lpVtbl->GetStringLength(This,guidKey,pcchLength)
#define IMFSample_GetString(This,guidKey,pwszValue,cchBufSize,pcchLength) (This)->lpVtbl->GetString(This,guidKey,pwszValue,cchBufSize,pcchLength)
#define IMFSample_GetAllocatedString(This,guidKey,ppwszValue,pcchLength) (This)->lpVtbl->GetAllocatedString(This,guidKey,ppwszValue,pcchLength)
#define IMFSample_GetBlobSize(This,guidKey,pcbBlobSize) (This)->lpVtbl->GetBlobSize(This,guidKey,pcbBlobSize)
#define IMFSample_GetBlob(This,guidKey,pBuf,cbBufSize,pcbBlobSize) (This)->lpVtbl->GetBlob(This,guidKey,pBuf,cbBufSize,pcbBlobSize)
#define IMFSample_GetAllocatedBlob(This,guidKey,ppBuf,pcbSize) (This)->lpVtbl->GetAllocatedBlob(This,guidKey,ppBuf,pcbSize)
#define IMFSample_GetUnknown(This,guidKey,riid,ppv) (This)->lpVtbl->GetUnknown(This,guidKey,riid,ppv)
#define IMFSample_SetItem(This,guidKey,Value) (This)->lpVtbl->SetItem(This,guidKey,Value)
#define IMFSample_DeleteItem(This,guidKey) (This)->lpVtbl->DeleteItem(This,guidKey)
#define IMFSample_DeleteAllItems(This) (This)->lpVtbl->DeleteAllItems(This)
#define IMFSample_SetUINT32(This,guidKey,unValue) (This)->lpVtbl->SetUINT32(This,guidKey,unValue)
#define IMFSample_SetUINT64(This,guidKey,unValue) (This)->lpVtbl->SetUINT64(This,guidKey,unValue)
#define IMFSample_SetDouble(This,guidKey,fValue) (This)->lpVtbl->SetDouble(This,guidKey,fValue)
#define IMFSample_SetGUID(This,guidKey,guidValue) (This)->lpVtbl->SetGUID(This,guidKey,guidValue)
#define IMFSample_SetString(This,guidKey,wszValue) (This)->lpVtbl->SetString(This,guidKey,wszValue)
#define IMFSample_SetBlob(This,guidKey,pBuf,cbBufSize) (This)->lpVtbl->SetBlob(This,guidKey,pBuf,cbBufSize)
#define IMFSample_SetUnknown(This,guidKey,pUnknown) (This)->lpVtbl->SetUnknown(This,guidKey,pUnknown)
#define IMFSample_LockStore(This) (This)->lpVtbl->LockStore(This)
#define IMFSample_UnlockStore(This) (This)->lpVtbl->UnlockStore(This)
#define IMFSample_GetCount(This,pcItems) (This)->lpVtbl->GetCount(This,pcItems)
#define IMFSample_GetItemByIndex(This,unIndex,pguidKey,pValue) (This)->lpVtbl->GetItemByIndex(This,unIndex,pguidKey,pValue)
#define IMFSample_CopyAllItems(This,pDest) (This)->lpVtbl->CopyAllItems(This,pDest)
/*** IMFSample methods ***/
#define IMFSample_GetSampleFlags(This,pdwSampleFlags) (This)->lpVtbl->GetSampleFlags(This,pdwSampleFlags)
#define IMFSample_SetSampleFlags(This,dwSampleFlags) (This)->lpVtbl->SetSampleFlags(This,dwSampleFlags)
#define IMFSample_GetSampleTime(This,phnsSampleTime) (This)->lpVtbl->GetSampleTime(This,phnsSampleTime)
#define IMFSample_SetSampleTime(This,hnsSampleTime) (This)->lpVtbl->SetSampleTime(This,hnsSampleTime)
#define IMFSample_GetSampleDuration(This,phnsSampleDuration) (This)->lpVtbl->GetSampleDuration(This,phnsSampleDuration)
#define IMFSample_SetSampleDuration(This,hnsSampleDuration) (This)->lpVtbl->SetSampleDuration(This,hnsSampleDuration)
#define IMFSample_GetBufferCount(This,pdwBufferCount) (This)->lpVtbl->GetBufferCount(This,pdwBufferCount)
#define IMFSample_GetBufferByIndex(This,dwIndex,ppBuffer) (This)->lpVtbl->GetBufferByIndex(This,dwIndex,ppBuffer)
#define IMFSample_ConvertToContiguousBuffer(This,ppBuffer) (This)->lpVtbl->ConvertToContiguousBuffer(This,ppBuffer)
#define IMFSample_AddBuffer(This,pBuffer) (This)->lpVtbl->AddBuffer(This,pBuffer)
#define IMFSample_RemoveBufferByIndex(This,dwIndex) (This)->lpVtbl->RemoveBufferByIndex(This,dwIndex)
#define IMFSample_RemoveAllBuffers(This) (This)->lpVtbl->RemoveAllBuffers(This)
#define IMFSample_GetTotalLength(This,pcbTotalLength) (This)->lpVtbl->GetTotalLength(This,pcbTotalLength)
#define IMFSample_CopyToBuffer(This,pBuffer) (This)->lpVtbl->CopyToBuffer(This,pBuffer)
#else
/*** IUnknown methods ***/
static FORCEINLINE HRESULT IMFSample_QueryInterface(IMFSample* This,REFIID riid,void **ppvObject) {
    return This->lpVtbl->QueryInterface(This,riid,ppvObject);
}
static FORCEINLINE ULONG IMFSample_AddRef(IMFSample* This) {
    return This->lpVtbl->AddRef(This);
}
static FORCEINLINE ULONG IMFSample_Release(IMFSample* This) {
    return This->lpVtbl->Release(This);
}
/*** IMFAttributes methods ***/
static FORCEINLINE HRESULT IMFSample_GetItem(IMFSample* This,REFGUID guidKey,PROPVARIANT *pValue) {
    return This->lpVtbl->GetItem(This,guidKey,pValue);
}
static FORCEINLINE HRESULT IMFSample_GetItemType(IMFSample* This,REFGUID guidKey,MF_ATTRIBUTE_TYPE *pType) {
    return This->lpVtbl->GetItemType(This,guidKey,pType);
}
static FORCEINLINE HRESULT IMFSample_CompareItem(IMFSample* This,REFGUID guidKey,REFPROPVARIANT Value,WINBOOL *pbResult) {
    return This->lpVtbl->CompareItem(This,guidKey,Value,pbResult);
}
static FORCEINLINE HRESULT IMFSample_Compare(IMFSample* This,IMFAttributes *pTheirs,MF_ATTRIBUTES_MATCH_TYPE MatchType,WINBOOL *pbResult) {
    return This->lpVtbl->Compare(This,pTheirs,MatchType,pbResult);
}
static FORCEINLINE HRESULT IMFSample_GetUINT32(IMFSample* This,REFGUID guidKey,UINT32 *punValue) {
    return This->lpVtbl->GetUINT32(This,guidKey,punValue);
}
static FORCEINLINE HRESULT IMFSample_GetUINT64(IMFSample* This,REFGUID guidKey,UINT64 *punValue) {
    return This->lpVtbl->GetUINT64(This,guidKey,punValue);
}
static FORCEINLINE HRESULT IMFSample_GetDouble(IMFSample* This,REFGUID guidKey,double *pfValue) {
    return This->lpVtbl->GetDouble(This,guidKey,pfValue);
}
static FORCEINLINE HRESULT IMFSample_GetGUID(IMFSample* This,REFGUID guidKey,GUID *pguidValue) {
    return This->lpVtbl->GetGUID(This,guidKey,pguidValue);
}
static FORCEINLINE HRESULT IMFSample_GetStringLength(IMFSample* This,REFGUID guidKey,UINT32 *pcchLength) {
    return This->lpVtbl->GetStringLength(This,guidKey,pcchLength);
}
static FORCEINLINE HRESULT IMFSample_GetString(IMFSample* This,REFGUID guidKey,LPWSTR pwszValue,UINT32 cchBufSize,UINT32 *pcchLength) {
    return This->lpVtbl->GetString(This,guidKey,pwszValue,cchBufSize,pcchLength);
}
static FORCEINLINE HRESULT IMFSample_GetAllocatedString(IMFSample* This,REFGUID guidKey,LPWSTR *ppwszValue,UINT32 *pcchLength) {
    return This->lpVtbl->GetAllocatedString(This,guidKey,ppwszValue,pcchLength);
}
static FORCEINLINE HRESULT IMFSample_GetBlobSize(IMFSample* This,REFGUID guidKey,UINT32 *pcbBlobSize) {
    return This->lpVtbl->GetBlobSize(This,guidKey,pcbBlobSize);
}
static FORCEINLINE HRESULT IMFSample_GetBlob(IMFSample* This,REFGUID guidKey,UINT8 *pBuf,UINT32 cbBufSize,UINT32 *pcbBlobSize) {
    return This->lpVtbl->GetBlob(This,guidKey,pBuf,cbBufSize,pcbBlobSize);
}
static FORCEINLINE HRESULT IMFSample_GetAllocatedBlob(IMFSample* This,REFGUID guidKey,UINT8 **ppBuf,UINT32 *pcbSize) {
    return This->lpVtbl->GetAllocatedBlob(This,guidKey,ppBuf,pcbSize);
}
static FORCEINLINE HRESULT IMFSample_GetUnknown(IMFSample* This,REFGUID guidKey,REFIID riid,LPVOID *ppv) {
    return This->lpVtbl->GetUnknown(This,guidKey,riid,ppv);
}
static FORCEINLINE HRESULT IMFSample_SetItem(IMFSample* This,REFGUID guidKey,REFPROPVARIANT Value) {
    return This->lpVtbl->SetItem(This,guidKey,Value);
}
static FORCEINLINE HRESULT IMFSample_DeleteItem(IMFSample* This,REFGUID guidKey) {
    return This->lpVtbl->DeleteItem(This,guidKey);
}
static FORCEINLINE HRESULT IMFSample_DeleteAllItems(IMFSample* This) {
    return This->lpVtbl->DeleteAllItems(This);
}
static FORCEINLINE HRESULT IMFSample_SetUINT32(IMFSample* This,REFGUID guidKey,UINT32 unValue) {
    return This->lpVtbl->SetUINT32(This,guidKey,unValue);
}
static FORCEINLINE HRESULT IMFSample_SetUINT64(IMFSample* This,REFGUID guidKey,UINT64 unValue) {
    return This->lpVtbl->SetUINT64(This,guidKey,unValue);
}
static FORCEINLINE HRESULT IMFSample_SetDouble(IMFSample* This,REFGUID guidKey,double fValue) {
    return This->lpVtbl->SetDouble(This,guidKey,fValue);
}
static FORCEINLINE HRESULT IMFSample_SetGUID(IMFSample* This,REFGUID guidKey,REFGUID guidValue) {
    return This->lpVtbl->SetGUID(This,guidKey,guidValue);
}
static FORCEINLINE HRESULT IMFSample_SetString(IMFSample* This,REFGUID guidKey,LPCWSTR wszValue) {
    return This->lpVtbl->SetString(This,guidKey,wszValue);
}
static FORCEINLINE HRESULT IMFSample_SetBlob(IMFSample* This,REFGUID guidKey,const UINT8 *pBuf,UINT32 cbBufSize) {
    return This->lpVtbl->SetBlob(This,guidKey,pBuf,cbBufSize);
}
static FORCEINLINE HRESULT IMFSample_SetUnknown(IMFSample* This,REFGUID guidKey,IUnknown *pUnknown) {
    return This->lpVtbl->SetUnknown(This,guidKey,pUnknown);
}
static FORCEINLINE HRESULT IMFSample_LockStore(IMFSample* This) {
    return This->lpVtbl->LockStore(This);
}
static FORCEINLINE HRESULT IMFSample_UnlockStore(IMFSample* This) {
    return This->lpVtbl->UnlockStore(This);
}
static FORCEINLINE HRESULT IMFSample_GetCount(IMFSample* This,UINT32 *pcItems) {
    return This->lpVtbl->GetCount(This,pcItems);
}
static FORCEINLINE HRESULT IMFSample_GetItemByIndex(IMFSample* This,UINT32 unIndex,GUID *pguidKey,PROPVARIANT *pValue) {
    return This->lpVtbl->GetItemByIndex(This,unIndex,pguidKey,pValue);
}
static FORCEINLINE HRESULT IMFSample_CopyAllItems(IMFSample* This,IMFAttributes *pDest) {
    return This->lpVtbl->CopyAllItems(This,pDest);
}
/*** IMFSample methods ***/
static FORCEINLINE HRESULT IMFSample_GetSampleFlags(IMFSample* This,DWORD *pdwSampleFlags) {
    return This->lpVtbl->GetSampleFlags(This,pdwSampleFlags);
}
static FORCEINLINE HRESULT IMFSample_SetSampleFlags(IMFSample* This,DWORD dwSampleFlags) {
    return This->lpVtbl->SetSampleFlags(This,dwSampleFlags);
}
static FORCEINLINE HRESULT IMFSample_GetSampleTime(IMFSample* This,LONGLONG *phnsSampleTime) {
    return This->lpVtbl->GetSampleTime(This,phnsSampleTime);
}
static FORCEINLINE HRESULT IMFSample_SetSampleTime(IMFSample* This,LONGLONG hnsSampleTime) {
    return This->lpVtbl->SetSampleTime(This,hnsSampleTime);
}
static FORCEINLINE HRESULT IMFSample_GetSampleDuration(IMFSample* This,LONGLONG *phnsSampleDuration) {
    return This->lpVtbl->GetSampleDuration(This,phnsSampleDuration);
}
static FORCEINLINE HRESULT IMFSample_SetSampleDuration(IMFSample* This,LONGLONG hnsSampleDuration) {
    return This->lpVtbl->SetSampleDuration(This,hnsSampleDuration);
}
static FORCEINLINE HRESULT IMFSample_GetBufferCount(IMFSample* This,DWORD *pdwBufferCount) {
    return This->lpVtbl->GetBufferCount(This,pdwBufferCount);
}
static FORCEINLINE HRESULT IMFSample_GetBufferByIndex(IMFSample* This,DWORD dwIndex,IMFMediaBuffer **ppBuffer) {
    return This->lpVtbl->GetBufferByIndex(This,dwIndex,ppBuffer);
}
static FORCEINLINE HRESULT IMFSample_ConvertToContiguousBuffer(IMFSample* This,IMFMediaBuffer **ppBuffer) {
    return This->lpVtbl->ConvertToContiguousBuffer(This,ppBuffer);
}
static FORCEINLINE HRESULT IMFSample_AddBuffer(IMFSample* This,IMFMediaBuffer *pBuffer) {
    return This->lpVtbl->AddBuffer(This,pBuffer);
}
static FORCEINLINE HRESULT IMFSample_RemoveBufferByIndex(IMFSample* This,DWORD dwIndex) {
    return This->lpVtbl->RemoveBufferByIndex(This,dwIndex);
}
static FORCEINLINE HRESULT IMFSample_RemoveAllBuffers(IMFSample* This) {
    return This->lpVtbl->RemoveAllBuffers(This);
}
static FORCEINLINE HRESULT IMFSample_GetTotalLength(IMFSample* This,DWORD *pcbTotalLength) {
    return This->lpVtbl->GetTotalLength(This,pcbTotalLength);
}
static FORCEINLINE HRESULT IMFSample_CopyToBuffer(IMFSample* This,IMFMediaBuffer *pBuffer) {
    return This->lpVtbl->CopyToBuffer(This,pBuffer);
}
#endif
#endif

#endif

HRESULT STDMETHODCALLTYPE IMFSample_GetSampleFlags_Proxy(
    IMFSample* This,
    DWORD *pdwSampleFlags);
void __RPC_STUB IMFSample_GetSampleFlags_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFSample_SetSampleFlags_Proxy(
    IMFSample* This,
    DWORD dwSampleFlags);
void __RPC_STUB IMFSample_SetSampleFlags_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFSample_GetSampleTime_Proxy(
    IMFSample* This,
    LONGLONG *phnsSampleTime);
void __RPC_STUB IMFSample_GetSampleTime_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFSample_SetSampleTime_Proxy(
    IMFSample* This,
    LONGLONG hnsSampleTime);
void __RPC_STUB IMFSample_SetSampleTime_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFSample_GetSampleDuration_Proxy(
    IMFSample* This,
    LONGLONG *phnsSampleDuration);
void __RPC_STUB IMFSample_GetSampleDuration_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFSample_SetSampleDuration_Proxy(
    IMFSample* This,
    LONGLONG hnsSampleDuration);
void __RPC_STUB IMFSample_SetSampleDuration_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFSample_GetBufferCount_Proxy(
    IMFSample* This,
    DWORD *pdwBufferCount);
void __RPC_STUB IMFSample_GetBufferCount_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFSample_GetBufferByIndex_Proxy(
    IMFSample* This,
    DWORD dwIndex,
    IMFMediaBuffer **ppBuffer);
void __RPC_STUB IMFSample_GetBufferByIndex_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFSample_ConvertToContiguousBuffer_Proxy(
    IMFSample* This,
    IMFMediaBuffer **ppBuffer);
void __RPC_STUB IMFSample_ConvertToContiguousBuffer_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFSample_AddBuffer_Proxy(
    IMFSample* This,
    IMFMediaBuffer *pBuffer);
void __RPC_STUB IMFSample_AddBuffer_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFSample_RemoveBufferByIndex_Proxy(
    IMFSample* This,
    DWORD dwIndex);
void __RPC_STUB IMFSample_RemoveBufferByIndex_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFSample_RemoveAllBuffers_Proxy(
    IMFSample* This);
void __RPC_STUB IMFSample_RemoveAllBuffers_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFSample_GetTotalLength_Proxy(
    IMFSample* This,
    DWORD *pcbTotalLength);
void __RPC_STUB IMFSample_GetTotalLength_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFSample_CopyToBuffer_Proxy(
    IMFSample* This,
    IMFMediaBuffer *pBuffer);
void __RPC_STUB IMFSample_CopyToBuffer_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IMFSample_INTERFACE_DEFINED__ */


/*****************************************************************************
 * IMF2DBuffer interface
 */
#ifndef __IMF2DBuffer_INTERFACE_DEFINED__
#define __IMF2DBuffer_INTERFACE_DEFINED__

DEFINE_GUID(IID_IMF2DBuffer, 0x7dc9d5f9, 0x9ed9, 0x44ec, 0x9b,0xbf, 0x06,0x00,0xbb,0x58,0x9f,0xbb);
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("7dc9d5f9-9ed9-44ec-9bbf-0600bb589fbb")
IMF2DBuffer : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE Lock2D(
        BYTE **ppbScanline0,
        LONG *plPitch) = 0;

    virtual HRESULT STDMETHODCALLTYPE Unlock2D(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetScanline0AndPitch(
        BYTE **pbScanline0,
        LONG *plPitch) = 0;

    virtual HRESULT STDMETHODCALLTYPE IsContiguousFormat(
        WINBOOL *pfIsContiguous) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetContiguousLength(
        DWORD *pcbLength) = 0;

    virtual HRESULT STDMETHODCALLTYPE ContiguousCopyTo(
        BYTE *pbDestBuffer,
        DWORD cbDestBuffer) = 0;

    virtual HRESULT STDMETHODCALLTYPE ContiguousCopyFrom(
        const BYTE *pbSrcBuffer,
        DWORD cbSrcBuffer) = 0;

};
#ifdef __CRT_UUID_DECL
__CRT_UUID_DECL(IMF2DBuffer, 0x7dc9d5f9, 0x9ed9, 0x44ec, 0x9b,0xbf, 0x06,0x00,0xbb,0x58,0x9f,0xbb)
#endif
#else
typedef struct IMF2DBufferVtbl {
    BEGIN_INTERFACE

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

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

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

    /*** IMF2DBuffer methods ***/
    HRESULT (STDMETHODCALLTYPE *Lock2D)(
        IMF2DBuffer* This,
        BYTE **ppbScanline0,
        LONG *plPitch);

    HRESULT (STDMETHODCALLTYPE *Unlock2D)(
        IMF2DBuffer* This);

    HRESULT (STDMETHODCALLTYPE *GetScanline0AndPitch)(
        IMF2DBuffer* This,
        BYTE **pbScanline0,
        LONG *plPitch);

    HRESULT (STDMETHODCALLTYPE *IsContiguousFormat)(
        IMF2DBuffer* This,
        WINBOOL *pfIsContiguous);

    HRESULT (STDMETHODCALLTYPE *GetContiguousLength)(
        IMF2DBuffer* This,
        DWORD *pcbLength);

    HRESULT (STDMETHODCALLTYPE *ContiguousCopyTo)(
        IMF2DBuffer* This,
        BYTE *pbDestBuffer,
        DWORD cbDestBuffer);

    HRESULT (STDMETHODCALLTYPE *ContiguousCopyFrom)(
        IMF2DBuffer* This,
        const BYTE *pbSrcBuffer,
        DWORD cbSrcBuffer);

    END_INTERFACE
} IMF2DBufferVtbl;
interface IMF2DBuffer {
    CONST_VTBL IMF2DBufferVtbl* lpVtbl;
};

#ifdef COBJMACROS
#ifndef WIDL_C_INLINE_WRAPPERS
/*** IUnknown methods ***/
#define IMF2DBuffer_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
#define IMF2DBuffer_AddRef(This) (This)->lpVtbl->AddRef(This)
#define IMF2DBuffer_Release(This) (This)->lpVtbl->Release(This)
/*** IMF2DBuffer methods ***/
#define IMF2DBuffer_Lock2D(This,ppbScanline0,plPitch) (This)->lpVtbl->Lock2D(This,ppbScanline0,plPitch)
#define IMF2DBuffer_Unlock2D(This) (This)->lpVtbl->Unlock2D(This)
#define IMF2DBuffer_GetScanline0AndPitch(This,pbScanline0,plPitch) (This)->lpVtbl->GetScanline0AndPitch(This,pbScanline0,plPitch)
#define IMF2DBuffer_IsContiguousFormat(This,pfIsContiguous) (This)->lpVtbl->IsContiguousFormat(This,pfIsContiguous)
#define IMF2DBuffer_GetContiguousLength(This,pcbLength) (This)->lpVtbl->GetContiguousLength(This,pcbLength)
#define IMF2DBuffer_ContiguousCopyTo(This,pbDestBuffer,cbDestBuffer) (This)->lpVtbl->ContiguousCopyTo(This,pbDestBuffer,cbDestBuffer)
#define IMF2DBuffer_ContiguousCopyFrom(This,pbSrcBuffer,cbSrcBuffer) (This)->lpVtbl->ContiguousCopyFrom(This,pbSrcBuffer,cbSrcBuffer)
#else
/*** IUnknown methods ***/
static FORCEINLINE HRESULT IMF2DBuffer_QueryInterface(IMF2DBuffer* This,REFIID riid,void **ppvObject) {
    return This->lpVtbl->QueryInterface(This,riid,ppvObject);
}
static FORCEINLINE ULONG IMF2DBuffer_AddRef(IMF2DBuffer* This) {
    return This->lpVtbl->AddRef(This);
}
static FORCEINLINE ULONG IMF2DBuffer_Release(IMF2DBuffer* This) {
    return This->lpVtbl->Release(This);
}
/*** IMF2DBuffer methods ***/
static FORCEINLINE HRESULT IMF2DBuffer_Lock2D(IMF2DBuffer* This,BYTE **ppbScanline0,LONG *plPitch) {
    return This->lpVtbl->Lock2D(This,ppbScanline0,plPitch);
}
static FORCEINLINE HRESULT IMF2DBuffer_Unlock2D(IMF2DBuffer* This) {
    return This->lpVtbl->Unlock2D(This);
}
static FORCEINLINE HRESULT IMF2DBuffer_GetScanline0AndPitch(IMF2DBuffer* This,BYTE **pbScanline0,LONG *plPitch) {
    return This->lpVtbl->GetScanline0AndPitch(This,pbScanline0,plPitch);
}
static FORCEINLINE HRESULT IMF2DBuffer_IsContiguousFormat(IMF2DBuffer* This,WINBOOL *pfIsContiguous) {
    return This->lpVtbl->IsContiguousFormat(This,pfIsContiguous);
}
static FORCEINLINE HRESULT IMF2DBuffer_GetContiguousLength(IMF2DBuffer* This,DWORD *pcbLength) {
    return This->lpVtbl->GetContiguousLength(This,pcbLength);
}
static FORCEINLINE HRESULT IMF2DBuffer_ContiguousCopyTo(IMF2DBuffer* This,BYTE *pbDestBuffer,DWORD cbDestBuffer) {
    return This->lpVtbl->ContiguousCopyTo(This,pbDestBuffer,cbDestBuffer);
}
static FORCEINLINE HRESULT IMF2DBuffer_ContiguousCopyFrom(IMF2DBuffer* This,const BYTE *pbSrcBuffer,DWORD cbSrcBuffer) {
    return This->lpVtbl->ContiguousCopyFrom(This,pbSrcBuffer,cbSrcBuffer);
}
#endif
#endif

#endif

HRESULT STDMETHODCALLTYPE IMF2DBuffer_Lock2D_Proxy(
    IMF2DBuffer* This,
    BYTE **ppbScanline0,
    LONG *plPitch);
void __RPC_STUB IMF2DBuffer_Lock2D_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMF2DBuffer_Unlock2D_Proxy(
    IMF2DBuffer* This);
void __RPC_STUB IMF2DBuffer_Unlock2D_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMF2DBuffer_GetScanline0AndPitch_Proxy(
    IMF2DBuffer* This,
    BYTE **pbScanline0,
    LONG *plPitch);
void __RPC_STUB IMF2DBuffer_GetScanline0AndPitch_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMF2DBuffer_IsContiguousFormat_Proxy(
    IMF2DBuffer* This,
    WINBOOL *pfIsContiguous);
void __RPC_STUB IMF2DBuffer_IsContiguousFormat_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMF2DBuffer_GetContiguousLength_Proxy(
    IMF2DBuffer* This,
    DWORD *pcbLength);
void __RPC_STUB IMF2DBuffer_GetContiguousLength_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMF2DBuffer_ContiguousCopyTo_Proxy(
    IMF2DBuffer* This,
    BYTE *pbDestBuffer,
    DWORD cbDestBuffer);
void __RPC_STUB IMF2DBuffer_ContiguousCopyTo_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMF2DBuffer_ContiguousCopyFrom_Proxy(
    IMF2DBuffer* This,
    const BYTE *pbSrcBuffer,
    DWORD cbSrcBuffer);
void __RPC_STUB IMF2DBuffer_ContiguousCopyFrom_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IMF2DBuffer_INTERFACE_DEFINED__ */


typedef enum _MF2DBuffer_LockFlags {
    MF2DBuffer_LockFlags_LockTypeMask = (0x1 | 0x2) | 0x3,
    MF2DBuffer_LockFlags_Read = 0x1,
    MF2DBuffer_LockFlags_Write = 0x2,
    MF2DBuffer_LockFlags_ReadWrite = 0x3,
    MF2DBuffer_LockFlags_ForceDWORD = 0x7fffffff
} MF2DBuffer_LockFlags;

/*****************************************************************************
 * IMF2DBuffer2 interface
 */
#ifndef __IMF2DBuffer2_INTERFACE_DEFINED__
#define __IMF2DBuffer2_INTERFACE_DEFINED__

DEFINE_GUID(IID_IMF2DBuffer2, 0x33ae5ea6, 0x4316, 0x436f, 0x8d,0xdd, 0xd7,0x3d,0x22,0xf8,0x29,0xec);
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("33ae5ea6-4316-436f-8ddd-d73d22f829ec")
IMF2DBuffer2 : public IMF2DBuffer
{
    virtual HRESULT STDMETHODCALLTYPE Lock2DSize(
        MF2DBuffer_LockFlags lockFlags,
        BYTE **ppbScanline0,
        LONG *plPitch,
        BYTE **ppbBufferStart,
        DWORD *pcbBufferLength) = 0;

    virtual HRESULT STDMETHODCALLTYPE Copy2DTo(
        IMF2DBuffer2 *pDestBuffer) = 0;

};
#ifdef __CRT_UUID_DECL
__CRT_UUID_DECL(IMF2DBuffer2, 0x33ae5ea6, 0x4316, 0x436f, 0x8d,0xdd, 0xd7,0x3d,0x22,0xf8,0x29,0xec)
#endif
#else
typedef struct IMF2DBuffer2Vtbl {
    BEGIN_INTERFACE

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

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

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

    /*** IMF2DBuffer methods ***/
    HRESULT (STDMETHODCALLTYPE *Lock2D)(
        IMF2DBuffer2* This,
        BYTE **ppbScanline0,
        LONG *plPitch);

    HRESULT (STDMETHODCALLTYPE *Unlock2D)(
        IMF2DBuffer2* This);

    HRESULT (STDMETHODCALLTYPE *GetScanline0AndPitch)(
        IMF2DBuffer2* This,
        BYTE **pbScanline0,
        LONG *plPitch);

    HRESULT (STDMETHODCALLTYPE *IsContiguousFormat)(
        IMF2DBuffer2* This,
        WINBOOL *pfIsContiguous);

    HRESULT (STDMETHODCALLTYPE *GetContiguousLength)(
        IMF2DBuffer2* This,
        DWORD *pcbLength);

    HRESULT (STDMETHODCALLTYPE *ContiguousCopyTo)(
        IMF2DBuffer2* This,
        BYTE *pbDestBuffer,
        DWORD cbDestBuffer);

    HRESULT (STDMETHODCALLTYPE *ContiguousCopyFrom)(
        IMF2DBuffer2* This,
        const BYTE *pbSrcBuffer,
        DWORD cbSrcBuffer);

    /*** IMF2DBuffer2 methods ***/
    HRESULT (STDMETHODCALLTYPE *Lock2DSize)(
        IMF2DBuffer2* This,
        MF2DBuffer_LockFlags lockFlags,
        BYTE **ppbScanline0,
        LONG *plPitch,
        BYTE **ppbBufferStart,
        DWORD *pcbBufferLength);

    HRESULT (STDMETHODCALLTYPE *Copy2DTo)(
        IMF2DBuffer2* This,
        IMF2DBuffer2 *pDestBuffer);

    END_INTERFACE
} IMF2DBuffer2Vtbl;
interface IMF2DBuffer2 {
    CONST_VTBL IMF2DBuffer2Vtbl* lpVtbl;
};

#ifdef COBJMACROS
#ifndef WIDL_C_INLINE_WRAPPERS
/*** IUnknown methods ***/
#define IMF2DBuffer2_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
#define IMF2DBuffer2_AddRef(This) (This)->lpVtbl->AddRef(This)
#define IMF2DBuffer2_Release(This) (This)->lpVtbl->Release(This)
/*** IMF2DBuffer methods ***/
#define IMF2DBuffer2_Lock2D(This,ppbScanline0,plPitch) (This)->lpVtbl->Lock2D(This,ppbScanline0,plPitch)
#define IMF2DBuffer2_Unlock2D(This) (This)->lpVtbl->Unlock2D(This)
#define IMF2DBuffer2_GetScanline0AndPitch(This,pbScanline0,plPitch) (This)->lpVtbl->GetScanline0AndPitch(This,pbScanline0,plPitch)
#define IMF2DBuffer2_IsContiguousFormat(This,pfIsContiguous) (This)->lpVtbl->IsContiguousFormat(This,pfIsContiguous)
#define IMF2DBuffer2_GetContiguousLength(This,pcbLength) (This)->lpVtbl->GetContiguousLength(This,pcbLength)
#define IMF2DBuffer2_ContiguousCopyTo(This,pbDestBuffer,cbDestBuffer) (This)->lpVtbl->ContiguousCopyTo(This,pbDestBuffer,cbDestBuffer)
#define IMF2DBuffer2_ContiguousCopyFrom(This,pbSrcBuffer,cbSrcBuffer) (This)->lpVtbl->ContiguousCopyFrom(This,pbSrcBuffer,cbSrcBuffer)
/*** IMF2DBuffer2 methods ***/
#define IMF2DBuffer2_Lock2DSize(This,lockFlags,ppbScanline0,plPitch,ppbBufferStart,pcbBufferLength) (This)->lpVtbl->Lock2DSize(This,lockFlags,ppbScanline0,plPitch,ppbBufferStart,pcbBufferLength)
#define IMF2DBuffer2_Copy2DTo(This,pDestBuffer) (This)->lpVtbl->Copy2DTo(This,pDestBuffer)
#else
/*** IUnknown methods ***/
static FORCEINLINE HRESULT IMF2DBuffer2_QueryInterface(IMF2DBuffer2* This,REFIID riid,void **ppvObject) {
    return This->lpVtbl->QueryInterface(This,riid,ppvObject);
}
static FORCEINLINE ULONG IMF2DBuffer2_AddRef(IMF2DBuffer2* This) {
    return This->lpVtbl->AddRef(This);
}
static FORCEINLINE ULONG IMF2DBuffer2_Release(IMF2DBuffer2* This) {
    return This->lpVtbl->Release(This);
}
/*** IMF2DBuffer methods ***/
static FORCEINLINE HRESULT IMF2DBuffer2_Lock2D(IMF2DBuffer2* This,BYTE **ppbScanline0,LONG *plPitch) {
    return This->lpVtbl->Lock2D(This,ppbScanline0,plPitch);
}
static FORCEINLINE HRESULT IMF2DBuffer2_Unlock2D(IMF2DBuffer2* This) {
    return This->lpVtbl->Unlock2D(This);
}
static FORCEINLINE HRESULT IMF2DBuffer2_GetScanline0AndPitch(IMF2DBuffer2* This,BYTE **pbScanline0,LONG *plPitch) {
    return This->lpVtbl->GetScanline0AndPitch(This,pbScanline0,plPitch);
}
static FORCEINLINE HRESULT IMF2DBuffer2_IsContiguousFormat(IMF2DBuffer2* This,WINBOOL *pfIsContiguous) {
    return This->lpVtbl->IsContiguousFormat(This,pfIsContiguous);
}
static FORCEINLINE HRESULT IMF2DBuffer2_GetContiguousLength(IMF2DBuffer2* This,DWORD *pcbLength) {
    return This->lpVtbl->GetContiguousLength(This,pcbLength);
}
static FORCEINLINE HRESULT IMF2DBuffer2_ContiguousCopyTo(IMF2DBuffer2* This,BYTE *pbDestBuffer,DWORD cbDestBuffer) {
    return This->lpVtbl->ContiguousCopyTo(This,pbDestBuffer,cbDestBuffer);
}
static FORCEINLINE HRESULT IMF2DBuffer2_ContiguousCopyFrom(IMF2DBuffer2* This,const BYTE *pbSrcBuffer,DWORD cbSrcBuffer) {
    return This->lpVtbl->ContiguousCopyFrom(This,pbSrcBuffer,cbSrcBuffer);
}
/*** IMF2DBuffer2 methods ***/
static FORCEINLINE HRESULT IMF2DBuffer2_Lock2DSize(IMF2DBuffer2* This,MF2DBuffer_LockFlags lockFlags,BYTE **ppbScanline0,LONG *plPitch,BYTE **ppbBufferStart,DWORD *pcbBufferLength) {
    return This->lpVtbl->Lock2DSize(This,lockFlags,ppbScanline0,plPitch,ppbBufferStart,pcbBufferLength);
}
static FORCEINLINE HRESULT IMF2DBuffer2_Copy2DTo(IMF2DBuffer2* This,IMF2DBuffer2 *pDestBuffer) {
    return This->lpVtbl->Copy2DTo(This,pDestBuffer);
}
#endif
#endif

#endif

HRESULT STDMETHODCALLTYPE IMF2DBuffer2_Lock2DSize_Proxy(
    IMF2DBuffer2* This,
    MF2DBuffer_LockFlags lockFlags,
    BYTE **ppbScanline0,
    LONG *plPitch,
    BYTE **ppbBufferStart,
    DWORD *pcbBufferLength);
void __RPC_STUB IMF2DBuffer2_Lock2DSize_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMF2DBuffer2_Copy2DTo_Proxy(
    IMF2DBuffer2* This,
    IMF2DBuffer2 *pDestBuffer);
void __RPC_STUB IMF2DBuffer2_Copy2DTo_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IMF2DBuffer2_INTERFACE_DEFINED__ */


/*****************************************************************************
 * IMFDXGIBuffer interface
 */
#ifndef __IMFDXGIBuffer_INTERFACE_DEFINED__
#define __IMFDXGIBuffer_INTERFACE_DEFINED__

DEFINE_GUID(IID_IMFDXGIBuffer, 0xe7174cfa, 0x1c9e, 0x48b1, 0x88,0x66, 0x62,0x62,0x26,0xbf,0xc2,0x58);
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("e7174cfa-1c9e-48b1-8866-626226bfc258")
IMFDXGIBuffer : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE GetResource(
        REFIID riid,
        LPVOID *ppvObject) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetSubresourceIndex(
        UINT *puSubresource) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetUnknown(
        REFIID guid,
        REFIID riid,
        LPVOID *ppvObject) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetUnknown(
        REFIID guid,
        IUnknown *pUnkData) = 0;

};
#ifdef __CRT_UUID_DECL
__CRT_UUID_DECL(IMFDXGIBuffer, 0xe7174cfa, 0x1c9e, 0x48b1, 0x88,0x66, 0x62,0x62,0x26,0xbf,0xc2,0x58)
#endif
#else
typedef struct IMFDXGIBufferVtbl {
    BEGIN_INTERFACE

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

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

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

    /*** IMFDXGIBuffer methods ***/
    HRESULT (STDMETHODCALLTYPE *GetResource)(
        IMFDXGIBuffer* This,
        REFIID riid,
        LPVOID *ppvObject);

    HRESULT (STDMETHODCALLTYPE *GetSubresourceIndex)(
        IMFDXGIBuffer* This,
        UINT *puSubresource);

    HRESULT (STDMETHODCALLTYPE *GetUnknown)(
        IMFDXGIBuffer* This,
        REFIID guid,
        REFIID riid,
        LPVOID *ppvObject);

    HRESULT (STDMETHODCALLTYPE *SetUnknown)(
        IMFDXGIBuffer* This,
        REFIID guid,
        IUnknown *pUnkData);

    END_INTERFACE
} IMFDXGIBufferVtbl;
interface IMFDXGIBuffer {
    CONST_VTBL IMFDXGIBufferVtbl* lpVtbl;
};

#ifdef COBJMACROS
#ifndef WIDL_C_INLINE_WRAPPERS
/*** IUnknown methods ***/
#define IMFDXGIBuffer_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
#define IMFDXGIBuffer_AddRef(This) (This)->lpVtbl->AddRef(This)
#define IMFDXGIBuffer_Release(This) (This)->lpVtbl->Release(This)
/*** IMFDXGIBuffer methods ***/
#define IMFDXGIBuffer_GetResource(This,riid,ppvObject) (This)->lpVtbl->GetResource(This,riid,ppvObject)
#define IMFDXGIBuffer_GetSubresourceIndex(This,puSubresource) (This)->lpVtbl->GetSubresourceIndex(This,puSubresource)
#define IMFDXGIBuffer_GetUnknown(This,guid,riid,ppvObject) (This)->lpVtbl->GetUnknown(This,guid,riid,ppvObject)
#define IMFDXGIBuffer_SetUnknown(This,guid,pUnkData) (This)->lpVtbl->SetUnknown(This,guid,pUnkData)
#else
/*** IUnknown methods ***/
static FORCEINLINE HRESULT IMFDXGIBuffer_QueryInterface(IMFDXGIBuffer* This,REFIID riid,void **ppvObject) {
    return This->lpVtbl->QueryInterface(This,riid,ppvObject);
}
static FORCEINLINE ULONG IMFDXGIBuffer_AddRef(IMFDXGIBuffer* This) {
    return This->lpVtbl->AddRef(This);
}
static FORCEINLINE ULONG IMFDXGIBuffer_Release(IMFDXGIBuffer* This) {
    return This->lpVtbl->Release(This);
}
/*** IMFDXGIBuffer methods ***/
static FORCEINLINE HRESULT IMFDXGIBuffer_GetResource(IMFDXGIBuffer* This,REFIID riid,LPVOID *ppvObject) {
    return This->lpVtbl->GetResource(This,riid,ppvObject);
}
static FORCEINLINE HRESULT IMFDXGIBuffer_GetSubresourceIndex(IMFDXGIBuffer* This,UINT *puSubresource) {
    return This->lpVtbl->GetSubresourceIndex(This,puSubresource);
}
static FORCEINLINE HRESULT IMFDXGIBuffer_GetUnknown(IMFDXGIBuffer* This,REFIID guid,REFIID riid,LPVOID *ppvObject) {
    return This->lpVtbl->GetUnknown(This,guid,riid,ppvObject);
}
static FORCEINLINE HRESULT IMFDXGIBuffer_SetUnknown(IMFDXGIBuffer* This,REFIID guid,IUnknown *pUnkData) {
    return This->lpVtbl->SetUnknown(This,guid,pUnkData);
}
#endif
#endif

#endif

HRESULT STDMETHODCALLTYPE IMFDXGIBuffer_GetResource_Proxy(
    IMFDXGIBuffer* This,
    REFIID riid,
    LPVOID *ppvObject);
void __RPC_STUB IMFDXGIBuffer_GetResource_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFDXGIBuffer_GetSubresourceIndex_Proxy(
    IMFDXGIBuffer* This,
    UINT *puSubresource);
void __RPC_STUB IMFDXGIBuffer_GetSubresourceIndex_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFDXGIBuffer_GetUnknown_Proxy(
    IMFDXGIBuffer* This,
    REFIID guid,
    REFIID riid,
    LPVOID *ppvObject);
void __RPC_STUB IMFDXGIBuffer_GetUnknown_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFDXGIBuffer_SetUnknown_Proxy(
    IMFDXGIBuffer* This,
    REFIID guid,
    IUnknown *pUnkData);
void __RPC_STUB IMFDXGIBuffer_SetUnknown_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IMFDXGIBuffer_INTERFACE_DEFINED__ */


/*****************************************************************************
 * IMFMediaType interface
 */
#ifndef __IMFMediaType_INTERFACE_DEFINED__
#define __IMFMediaType_INTERFACE_DEFINED__

DEFINE_GUID(IID_IMFMediaType, 0x44ae0fa8, 0xea31, 0x4109, 0x8d,0x2e, 0x4c,0xae,0x49,0x97,0xc5,0x55);
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("44ae0fa8-ea31-4109-8d2e-4cae4997c555")
IMFMediaType : public IMFAttributes
{
    virtual HRESULT STDMETHODCALLTYPE GetMajorType(
        GUID *pguidMajorType) = 0;

    virtual HRESULT STDMETHODCALLTYPE IsCompressedFormat(
        WINBOOL *pfCompressed) = 0;

    virtual HRESULT STDMETHODCALLTYPE IsEqual(
        IMFMediaType *pIMediaType,
        DWORD *pdwFlags) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetRepresentation(
        GUID guidRepresentation,
        LPVOID *ppvRepresentation) = 0;

    virtual HRESULT STDMETHODCALLTYPE FreeRepresentation(
        GUID guidRepresentation,
        LPVOID pvRepresentation) = 0;

};
#ifdef __CRT_UUID_DECL
__CRT_UUID_DECL(IMFMediaType, 0x44ae0fa8, 0xea31, 0x4109, 0x8d,0x2e, 0x4c,0xae,0x49,0x97,0xc5,0x55)
#endif
#else
typedef struct IMFMediaTypeVtbl {
    BEGIN_INTERFACE

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

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

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

    /*** IMFAttributes methods ***/
    HRESULT (STDMETHODCALLTYPE *GetItem)(
        IMFMediaType* This,
        REFGUID guidKey,
        PROPVARIANT *pValue);

    HRESULT (STDMETHODCALLTYPE *GetItemType)(
        IMFMediaType* This,
        REFGUID guidKey,
        MF_ATTRIBUTE_TYPE *pType);

    HRESULT (STDMETHODCALLTYPE *CompareItem)(
        IMFMediaType* This,
        REFGUID guidKey,
        REFPROPVARIANT Value,
        WINBOOL *pbResult);

    HRESULT (STDMETHODCALLTYPE *Compare)(
        IMFMediaType* This,
        IMFAttributes *pTheirs,
        MF_ATTRIBUTES_MATCH_TYPE MatchType,
        WINBOOL *pbResult);

    HRESULT (STDMETHODCALLTYPE *GetUINT32)(
        IMFMediaType* This,
        REFGUID guidKey,
        UINT32 *punValue);

    HRESULT (STDMETHODCALLTYPE *GetUINT64)(
        IMFMediaType* This,
        REFGUID guidKey,
        UINT64 *punValue);

    HRESULT (STDMETHODCALLTYPE *GetDouble)(
        IMFMediaType* This,
        REFGUID guidKey,
        double *pfValue);

    HRESULT (STDMETHODCALLTYPE *GetGUID)(
        IMFMediaType* This,
        REFGUID guidKey,
        GUID *pguidValue);

    HRESULT (STDMETHODCALLTYPE *GetStringLength)(
        IMFMediaType* This,
        REFGUID guidKey,
        UINT32 *pcchLength);

    HRESULT (STDMETHODCALLTYPE *GetString)(
        IMFMediaType* This,
        REFGUID guidKey,
        LPWSTR pwszValue,
        UINT32 cchBufSize,
        UINT32 *pcchLength);

    HRESULT (STDMETHODCALLTYPE *GetAllocatedString)(
        IMFMediaType* This,
        REFGUID guidKey,
        LPWSTR *ppwszValue,
        UINT32 *pcchLength);

    HRESULT (STDMETHODCALLTYPE *GetBlobSize)(
        IMFMediaType* This,
        REFGUID guidKey,
        UINT32 *pcbBlobSize);

    HRESULT (STDMETHODCALLTYPE *GetBlob)(
        IMFMediaType* This,
        REFGUID guidKey,
        UINT8 *pBuf,
        UINT32 cbBufSize,
        UINT32 *pcbBlobSize);

    HRESULT (STDMETHODCALLTYPE *GetAllocatedBlob)(
        IMFMediaType* This,
        REFGUID guidKey,
        UINT8 **ppBuf,
        UINT32 *pcbSize);

    HRESULT (STDMETHODCALLTYPE *GetUnknown)(
        IMFMediaType* This,
        REFGUID guidKey,
        REFIID riid,
        LPVOID *ppv);

    HRESULT (STDMETHODCALLTYPE *SetItem)(
        IMFMediaType* This,
        REFGUID guidKey,
        REFPROPVARIANT Value);

    HRESULT (STDMETHODCALLTYPE *DeleteItem)(
        IMFMediaType* This,
        REFGUID guidKey);

    HRESULT (STDMETHODCALLTYPE *DeleteAllItems)(
        IMFMediaType* This);

    HRESULT (STDMETHODCALLTYPE *SetUINT32)(
        IMFMediaType* This,
        REFGUID guidKey,
        UINT32 unValue);

    HRESULT (STDMETHODCALLTYPE *SetUINT64)(
        IMFMediaType* This,
        REFGUID guidKey,
        UINT64 unValue);

    HRESULT (STDMETHODCALLTYPE *SetDouble)(
        IMFMediaType* This,
        REFGUID guidKey,
        double fValue);

    HRESULT (STDMETHODCALLTYPE *SetGUID)(
        IMFMediaType* This,
        REFGUID guidKey,
        REFGUID guidValue);

    HRESULT (STDMETHODCALLTYPE *SetString)(
        IMFMediaType* This,
        REFGUID guidKey,
        LPCWSTR wszValue);

    HRESULT (STDMETHODCALLTYPE *SetBlob)(
        IMFMediaType* This,
        REFGUID guidKey,
        const UINT8 *pBuf,
        UINT32 cbBufSize);

    HRESULT (STDMETHODCALLTYPE *SetUnknown)(
        IMFMediaType* This,
        REFGUID guidKey,
        IUnknown *pUnknown);

    HRESULT (STDMETHODCALLTYPE *LockStore)(
        IMFMediaType* This);

    HRESULT (STDMETHODCALLTYPE *UnlockStore)(
        IMFMediaType* This);

    HRESULT (STDMETHODCALLTYPE *GetCount)(
        IMFMediaType* This,
        UINT32 *pcItems);

    HRESULT (STDMETHODCALLTYPE *GetItemByIndex)(
        IMFMediaType* This,
        UINT32 unIndex,
        GUID *pguidKey,
        PROPVARIANT *pValue);

    HRESULT (STDMETHODCALLTYPE *CopyAllItems)(
        IMFMediaType* This,
        IMFAttributes *pDest);

    /*** IMFMediaType methods ***/
    HRESULT (STDMETHODCALLTYPE *GetMajorType)(
        IMFMediaType* This,
        GUID *pguidMajorType);

    HRESULT (STDMETHODCALLTYPE *IsCompressedFormat)(
        IMFMediaType* This,
        WINBOOL *pfCompressed);

    HRESULT (STDMETHODCALLTYPE *IsEqual)(
        IMFMediaType* This,
        IMFMediaType *pIMediaType,
        DWORD *pdwFlags);

    HRESULT (STDMETHODCALLTYPE *GetRepresentation)(
        IMFMediaType* This,
        GUID guidRepresentation,
        LPVOID *ppvRepresentation);

    HRESULT (STDMETHODCALLTYPE *FreeRepresentation)(
        IMFMediaType* This,
        GUID guidRepresentation,
        LPVOID pvRepresentation);

    END_INTERFACE
} IMFMediaTypeVtbl;
interface IMFMediaType {
    CONST_VTBL IMFMediaTypeVtbl* lpVtbl;
};

#ifdef COBJMACROS
#ifndef WIDL_C_INLINE_WRAPPERS
/*** IUnknown methods ***/
#define IMFMediaType_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
#define IMFMediaType_AddRef(This) (This)->lpVtbl->AddRef(This)
#define IMFMediaType_Release(This) (This)->lpVtbl->Release(This)
/*** IMFAttributes methods ***/
#define IMFMediaType_GetItem(This,guidKey,pValue) (This)->lpVtbl->GetItem(This,guidKey,pValue)
#define IMFMediaType_GetItemType(This,guidKey,pType) (This)->lpVtbl->GetItemType(This,guidKey,pType)
#define IMFMediaType_CompareItem(This,guidKey,Value,pbResult) (This)->lpVtbl->CompareItem(This,guidKey,Value,pbResult)
#define IMFMediaType_Compare(This,pTheirs,MatchType,pbResult) (This)->lpVtbl->Compare(This,pTheirs,MatchType,pbResult)
#define IMFMediaType_GetUINT32(This,guidKey,punValue) (This)->lpVtbl->GetUINT32(This,guidKey,punValue)
#define IMFMediaType_GetUINT64(This,guidKey,punValue) (This)->lpVtbl->GetUINT64(This,guidKey,punValue)
#define IMFMediaType_GetDouble(This,guidKey,pfValue) (This)->lpVtbl->GetDouble(This,guidKey,pfValue)
#define IMFMediaType_GetGUID(This,guidKey,pguidValue) (This)->lpVtbl->GetGUID(This,guidKey,pguidValue)
#define IMFMediaType_GetStringLength(This,guidKey,pcchLength) (This)->lpVtbl->GetStringLength(This,guidKey,pcchLength)
#define IMFMediaType_GetString(This,guidKey,pwszValue,cchBufSize,pcchLength) (This)->lpVtbl->GetString(This,guidKey,pwszValue,cchBufSize,pcchLength)
#define IMFMediaType_GetAllocatedString(This,guidKey,ppwszValue,pcchLength) (This)->lpVtbl->GetAllocatedString(This,guidKey,ppwszValue,pcchLength)
#define IMFMediaType_GetBlobSize(This,guidKey,pcbBlobSize) (This)->lpVtbl->GetBlobSize(This,guidKey,pcbBlobSize)
#define IMFMediaType_GetBlob(This,guidKey,pBuf,cbBufSize,pcbBlobSize) (This)->lpVtbl->GetBlob(This,guidKey,pBuf,cbBufSize,pcbBlobSize)
#define IMFMediaType_GetAllocatedBlob(This,guidKey,ppBuf,pcbSize) (This)->lpVtbl->GetAllocatedBlob(This,guidKey,ppBuf,pcbSize)
#define IMFMediaType_GetUnknown(This,guidKey,riid,ppv) (This)->lpVtbl->GetUnknown(This,guidKey,riid,ppv)
#define IMFMediaType_SetItem(This,guidKey,Value) (This)->lpVtbl->SetItem(This,guidKey,Value)
#define IMFMediaType_DeleteItem(This,guidKey) (This)->lpVtbl->DeleteItem(This,guidKey)
#define IMFMediaType_DeleteAllItems(This) (This)->lpVtbl->DeleteAllItems(This)
#define IMFMediaType_SetUINT32(This,guidKey,unValue) (This)->lpVtbl->SetUINT32(This,guidKey,unValue)
#define IMFMediaType_SetUINT64(This,guidKey,unValue) (This)->lpVtbl->SetUINT64(This,guidKey,unValue)
#define IMFMediaType_SetDouble(This,guidKey,fValue) (This)->lpVtbl->SetDouble(This,guidKey,fValue)
#define IMFMediaType_SetGUID(This,guidKey,guidValue) (This)->lpVtbl->SetGUID(This,guidKey,guidValue)
#define IMFMediaType_SetString(This,guidKey,wszValue) (This)->lpVtbl->SetString(This,guidKey,wszValue)
#define IMFMediaType_SetBlob(This,guidKey,pBuf,cbBufSize) (This)->lpVtbl->SetBlob(This,guidKey,pBuf,cbBufSize)
#define IMFMediaType_SetUnknown(This,guidKey,pUnknown) (This)->lpVtbl->SetUnknown(This,guidKey,pUnknown)
#define IMFMediaType_LockStore(This) (This)->lpVtbl->LockStore(This)
#define IMFMediaType_UnlockStore(This) (This)->lpVtbl->UnlockStore(This)
#define IMFMediaType_GetCount(This,pcItems) (This)->lpVtbl->GetCount(This,pcItems)
#define IMFMediaType_GetItemByIndex(This,unIndex,pguidKey,pValue) (This)->lpVtbl->GetItemByIndex(This,unIndex,pguidKey,pValue)
#define IMFMediaType_CopyAllItems(This,pDest) (This)->lpVtbl->CopyAllItems(This,pDest)
/*** IMFMediaType methods ***/
#define IMFMediaType_GetMajorType(This,pguidMajorType) (This)->lpVtbl->GetMajorType(This,pguidMajorType)
#define IMFMediaType_IsCompressedFormat(This,pfCompressed) (This)->lpVtbl->IsCompressedFormat(This,pfCompressed)
#define IMFMediaType_IsEqual(This,pIMediaType,pdwFlags) (This)->lpVtbl->IsEqual(This,pIMediaType,pdwFlags)
#define IMFMediaType_GetRepresentation(This,guidRepresentation,ppvRepresentation) (This)->lpVtbl->GetRepresentation(This,guidRepresentation,ppvRepresentation)
#define IMFMediaType_FreeRepresentation(This,guidRepresentation,pvRepresentation) (This)->lpVtbl->FreeRepresentation(This,guidRepresentation,pvRepresentation)
#else
/*** IUnknown methods ***/
static FORCEINLINE HRESULT IMFMediaType_QueryInterface(IMFMediaType* This,REFIID riid,void **ppvObject) {
    return This->lpVtbl->QueryInterface(This,riid,ppvObject);
}
static FORCEINLINE ULONG IMFMediaType_AddRef(IMFMediaType* This) {
    return This->lpVtbl->AddRef(This);
}
static FORCEINLINE ULONG IMFMediaType_Release(IMFMediaType* This) {
    return This->lpVtbl->Release(This);
}
/*** IMFAttributes methods ***/
static FORCEINLINE HRESULT IMFMediaType_GetItem(IMFMediaType* This,REFGUID guidKey,PROPVARIANT *pValue) {
    return This->lpVtbl->GetItem(This,guidKey,pValue);
}
static FORCEINLINE HRESULT IMFMediaType_GetItemType(IMFMediaType* This,REFGUID guidKey,MF_ATTRIBUTE_TYPE *pType) {
    return This->lpVtbl->GetItemType(This,guidKey,pType);
}
static FORCEINLINE HRESULT IMFMediaType_CompareItem(IMFMediaType* This,REFGUID guidKey,REFPROPVARIANT Value,WINBOOL *pbResult) {
    return This->lpVtbl->CompareItem(This,guidKey,Value,pbResult);
}
static FORCEINLINE HRESULT IMFMediaType_Compare(IMFMediaType* This,IMFAttributes *pTheirs,MF_ATTRIBUTES_MATCH_TYPE MatchType,WINBOOL *pbResult) {
    return This->lpVtbl->Compare(This,pTheirs,MatchType,pbResult);
}
static FORCEINLINE HRESULT IMFMediaType_GetUINT32(IMFMediaType* This,REFGUID guidKey,UINT32 *punValue) {
    return This->lpVtbl->GetUINT32(This,guidKey,punValue);
}
static FORCEINLINE HRESULT IMFMediaType_GetUINT64(IMFMediaType* This,REFGUID guidKey,UINT64 *punValue) {
    return This->lpVtbl->GetUINT64(This,guidKey,punValue);
}
static FORCEINLINE HRESULT IMFMediaType_GetDouble(IMFMediaType* This,REFGUID guidKey,double *pfValue) {
    return This->lpVtbl->GetDouble(This,guidKey,pfValue);
}
static FORCEINLINE HRESULT IMFMediaType_GetGUID(IMFMediaType* This,REFGUID guidKey,GUID *pguidValue) {
    return This->lpVtbl->GetGUID(This,guidKey,pguidValue);
}
static FORCEINLINE HRESULT IMFMediaType_GetStringLength(IMFMediaType* This,REFGUID guidKey,UINT32 *pcchLength) {
    return This->lpVtbl->GetStringLength(This,guidKey,pcchLength);
}
static FORCEINLINE HRESULT IMFMediaType_GetString(IMFMediaType* This,REFGUID guidKey,LPWSTR pwszValue,UINT32 cchBufSize,UINT32 *pcchLength) {
    return This->lpVtbl->GetString(This,guidKey,pwszValue,cchBufSize,pcchLength);
}
static FORCEINLINE HRESULT IMFMediaType_GetAllocatedString(IMFMediaType* This,REFGUID guidKey,LPWSTR *ppwszValue,UINT32 *pcchLength) {
    return This->lpVtbl->GetAllocatedString(This,guidKey,ppwszValue,pcchLength);
}
static FORCEINLINE HRESULT IMFMediaType_GetBlobSize(IMFMediaType* This,REFGUID guidKey,UINT32 *pcbBlobSize) {
    return This->lpVtbl->GetBlobSize(This,guidKey,pcbBlobSize);
}
static FORCEINLINE HRESULT IMFMediaType_GetBlob(IMFMediaType* This,REFGUID guidKey,UINT8 *pBuf,UINT32 cbBufSize,UINT32 *pcbBlobSize) {
    return This->lpVtbl->GetBlob(This,guidKey,pBuf,cbBufSize,pcbBlobSize);
}
static FORCEINLINE HRESULT IMFMediaType_GetAllocatedBlob(IMFMediaType* This,REFGUID guidKey,UINT8 **ppBuf,UINT32 *pcbSize) {
    return This->lpVtbl->GetAllocatedBlob(This,guidKey,ppBuf,pcbSize);
}
static FORCEINLINE HRESULT IMFMediaType_GetUnknown(IMFMediaType* This,REFGUID guidKey,REFIID riid,LPVOID *ppv) {
    return This->lpVtbl->GetUnknown(This,guidKey,riid,ppv);
}
static FORCEINLINE HRESULT IMFMediaType_SetItem(IMFMediaType* This,REFGUID guidKey,REFPROPVARIANT Value) {
    return This->lpVtbl->SetItem(This,guidKey,Value);
}
static FORCEINLINE HRESULT IMFMediaType_DeleteItem(IMFMediaType* This,REFGUID guidKey) {
    return This->lpVtbl->DeleteItem(This,guidKey);
}
static FORCEINLINE HRESULT IMFMediaType_DeleteAllItems(IMFMediaType* This) {
    return This->lpVtbl->DeleteAllItems(This);
}
static FORCEINLINE HRESULT IMFMediaType_SetUINT32(IMFMediaType* This,REFGUID guidKey,UINT32 unValue) {
    return This->lpVtbl->SetUINT32(This,guidKey,unValue);
}
static FORCEINLINE HRESULT IMFMediaType_SetUINT64(IMFMediaType* This,REFGUID guidKey,UINT64 unValue) {
    return This->lpVtbl->SetUINT64(This,guidKey,unValue);
}
static FORCEINLINE HRESULT IMFMediaType_SetDouble(IMFMediaType* This,REFGUID guidKey,double fValue) {
    return This->lpVtbl->SetDouble(This,guidKey,fValue);
}
static FORCEINLINE HRESULT IMFMediaType_SetGUID(IMFMediaType* This,REFGUID guidKey,REFGUID guidValue) {
    return This->lpVtbl->SetGUID(This,guidKey,guidValue);
}
static FORCEINLINE HRESULT IMFMediaType_SetString(IMFMediaType* This,REFGUID guidKey,LPCWSTR wszValue) {
    return This->lpVtbl->SetString(This,guidKey,wszValue);
}
static FORCEINLINE HRESULT IMFMediaType_SetBlob(IMFMediaType* This,REFGUID guidKey,const UINT8 *pBuf,UINT32 cbBufSize) {
    return This->lpVtbl->SetBlob(This,guidKey,pBuf,cbBufSize);
}
static FORCEINLINE HRESULT IMFMediaType_SetUnknown(IMFMediaType* This,REFGUID guidKey,IUnknown *pUnknown) {
    return This->lpVtbl->SetUnknown(This,guidKey,pUnknown);
}
static FORCEINLINE HRESULT IMFMediaType_LockStore(IMFMediaType* This) {
    return This->lpVtbl->LockStore(This);
}
static FORCEINLINE HRESULT IMFMediaType_UnlockStore(IMFMediaType* This) {
    return This->lpVtbl->UnlockStore(This);
}
static FORCEINLINE HRESULT IMFMediaType_GetCount(IMFMediaType* This,UINT32 *pcItems) {
    return This->lpVtbl->GetCount(This,pcItems);
}
static FORCEINLINE HRESULT IMFMediaType_GetItemByIndex(IMFMediaType* This,UINT32 unIndex,GUID *pguidKey,PROPVARIANT *pValue) {
    return This->lpVtbl->GetItemByIndex(This,unIndex,pguidKey,pValue);
}
static FORCEINLINE HRESULT IMFMediaType_CopyAllItems(IMFMediaType* This,IMFAttributes *pDest) {
    return This->lpVtbl->CopyAllItems(This,pDest);
}
/*** IMFMediaType methods ***/
static FORCEINLINE HRESULT IMFMediaType_GetMajorType(IMFMediaType* This,GUID *pguidMajorType) {
    return This->lpVtbl->GetMajorType(This,pguidMajorType);
}
static FORCEINLINE HRESULT IMFMediaType_IsCompressedFormat(IMFMediaType* This,WINBOOL *pfCompressed) {
    return This->lpVtbl->IsCompressedFormat(This,pfCompressed);
}
static FORCEINLINE HRESULT IMFMediaType_IsEqual(IMFMediaType* This,IMFMediaType *pIMediaType,DWORD *pdwFlags) {
    return This->lpVtbl->IsEqual(This,pIMediaType,pdwFlags);
}
static FORCEINLINE HRESULT IMFMediaType_GetRepresentation(IMFMediaType* This,GUID guidRepresentation,LPVOID *ppvRepresentation) {
    return This->lpVtbl->GetRepresentation(This,guidRepresentation,ppvRepresentation);
}
static FORCEINLINE HRESULT IMFMediaType_FreeRepresentation(IMFMediaType* This,GUID guidRepresentation,LPVOID pvRepresentation) {
    return This->lpVtbl->FreeRepresentation(This,guidRepresentation,pvRepresentation);
}
#endif
#endif

#endif

HRESULT STDMETHODCALLTYPE IMFMediaType_GetMajorType_Proxy(
    IMFMediaType* This,
    GUID *pguidMajorType);
void __RPC_STUB IMFMediaType_GetMajorType_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFMediaType_IsCompressedFormat_Proxy(
    IMFMediaType* This,
    WINBOOL *pfCompressed);
void __RPC_STUB IMFMediaType_IsCompressedFormat_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFMediaType_IsEqual_Proxy(
    IMFMediaType* This,
    IMFMediaType *pIMediaType,
    DWORD *pdwFlags);
void __RPC_STUB IMFMediaType_IsEqual_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFMediaType_GetRepresentation_Proxy(
    IMFMediaType* This,
    GUID guidRepresentation,
    LPVOID *ppvRepresentation);
void __RPC_STUB IMFMediaType_GetRepresentation_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFMediaType_FreeRepresentation_Proxy(
    IMFMediaType* This,
    GUID guidRepresentation,
    LPVOID pvRepresentation);
void __RPC_STUB IMFMediaType_FreeRepresentation_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IMFMediaType_INTERFACE_DEFINED__ */


#define MF_MEDIATYPE_EQUAL_MAJOR_TYPES 0x00000001
#define MF_MEDIATYPE_EQUAL_FORMAT_TYPES 0x00000002
#define MF_MEDIATYPE_EQUAL_FORMAT_DATA 0x00000004
#define MF_MEDIATYPE_EQUAL_FORMAT_USER_DATA 0x00000008
#endif

#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
/*****************************************************************************
 * IMFAudioMediaType interface
 */
#ifndef __IMFAudioMediaType_INTERFACE_DEFINED__
#define __IMFAudioMediaType_INTERFACE_DEFINED__

DEFINE_GUID(IID_IMFAudioMediaType, 0x26a0adc3, 0xce26, 0x4672, 0x93,0x04, 0x69,0x55,0x2e,0xdd,0x3f,0xaf);
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("26a0adc3-ce26-4672-9304-69552edd3faf")
IMFAudioMediaType : public IMFMediaType
{
    virtual const WAVEFORMATEX * STDMETHODCALLTYPE GetAudioFormat(
        ) = 0;

};
#ifdef __CRT_UUID_DECL
__CRT_UUID_DECL(IMFAudioMediaType, 0x26a0adc3, 0xce26, 0x4672, 0x93,0x04, 0x69,0x55,0x2e,0xdd,0x3f,0xaf)
#endif
#else
typedef struct IMFAudioMediaTypeVtbl {
    BEGIN_INTERFACE

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

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

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

    /*** IMFAttributes methods ***/
    HRESULT (STDMETHODCALLTYPE *GetItem)(
        IMFAudioMediaType* This,
        REFGUID guidKey,
        PROPVARIANT *pValue);

    HRESULT (STDMETHODCALLTYPE *GetItemType)(
        IMFAudioMediaType* This,
        REFGUID guidKey,
        MF_ATTRIBUTE_TYPE *pType);

    HRESULT (STDMETHODCALLTYPE *CompareItem)(
        IMFAudioMediaType* This,
        REFGUID guidKey,
        REFPROPVARIANT Value,
        WINBOOL *pbResult);

    HRESULT (STDMETHODCALLTYPE *Compare)(
        IMFAudioMediaType* This,
        IMFAttributes *pTheirs,
        MF_ATTRIBUTES_MATCH_TYPE MatchType,
        WINBOOL *pbResult);

    HRESULT (STDMETHODCALLTYPE *GetUINT32)(
        IMFAudioMediaType* This,
        REFGUID guidKey,
        UINT32 *punValue);

    HRESULT (STDMETHODCALLTYPE *GetUINT64)(
        IMFAudioMediaType* This,
        REFGUID guidKey,
        UINT64 *punValue);

    HRESULT (STDMETHODCALLTYPE *GetDouble)(
        IMFAudioMediaType* This,
        REFGUID guidKey,
        double *pfValue);

    HRESULT (STDMETHODCALLTYPE *GetGUID)(
        IMFAudioMediaType* This,
        REFGUID guidKey,
        GUID *pguidValue);

    HRESULT (STDMETHODCALLTYPE *GetStringLength)(
        IMFAudioMediaType* This,
        REFGUID guidKey,
        UINT32 *pcchLength);

    HRESULT (STDMETHODCALLTYPE *GetString)(
        IMFAudioMediaType* This,
        REFGUID guidKey,
        LPWSTR pwszValue,
        UINT32 cchBufSize,
        UINT32 *pcchLength);

    HRESULT (STDMETHODCALLTYPE *GetAllocatedString)(
        IMFAudioMediaType* This,
        REFGUID guidKey,
        LPWSTR *ppwszValue,
        UINT32 *pcchLength);

    HRESULT (STDMETHODCALLTYPE *GetBlobSize)(
        IMFAudioMediaType* This,
        REFGUID guidKey,
        UINT32 *pcbBlobSize);

    HRESULT (STDMETHODCALLTYPE *GetBlob)(
        IMFAudioMediaType* This,
        REFGUID guidKey,
        UINT8 *pBuf,
        UINT32 cbBufSize,
        UINT32 *pcbBlobSize);

    HRESULT (STDMETHODCALLTYPE *GetAllocatedBlob)(
        IMFAudioMediaType* This,
        REFGUID guidKey,
        UINT8 **ppBuf,
        UINT32 *pcbSize);

    HRESULT (STDMETHODCALLTYPE *GetUnknown)(
        IMFAudioMediaType* This,
        REFGUID guidKey,
        REFIID riid,
        LPVOID *ppv);

    HRESULT (STDMETHODCALLTYPE *SetItem)(
        IMFAudioMediaType* This,
        REFGUID guidKey,
        REFPROPVARIANT Value);

    HRESULT (STDMETHODCALLTYPE *DeleteItem)(
        IMFAudioMediaType* This,
        REFGUID guidKey);

    HRESULT (STDMETHODCALLTYPE *DeleteAllItems)(
        IMFAudioMediaType* This);

    HRESULT (STDMETHODCALLTYPE *SetUINT32)(
        IMFAudioMediaType* This,
        REFGUID guidKey,
        UINT32 unValue);

    HRESULT (STDMETHODCALLTYPE *SetUINT64)(
        IMFAudioMediaType* This,
        REFGUID guidKey,
        UINT64 unValue);

    HRESULT (STDMETHODCALLTYPE *SetDouble)(
        IMFAudioMediaType* This,
        REFGUID guidKey,
        double fValue);

    HRESULT (STDMETHODCALLTYPE *SetGUID)(
        IMFAudioMediaType* This,
        REFGUID guidKey,
        REFGUID guidValue);

    HRESULT (STDMETHODCALLTYPE *SetString)(
        IMFAudioMediaType* This,
        REFGUID guidKey,
        LPCWSTR wszValue);

    HRESULT (STDMETHODCALLTYPE *SetBlob)(
        IMFAudioMediaType* This,
        REFGUID guidKey,
        const UINT8 *pBuf,
        UINT32 cbBufSize);

    HRESULT (STDMETHODCALLTYPE *SetUnknown)(
        IMFAudioMediaType* This,
        REFGUID guidKey,
        IUnknown *pUnknown);

    HRESULT (STDMETHODCALLTYPE *LockStore)(
        IMFAudioMediaType* This);

    HRESULT (STDMETHODCALLTYPE *UnlockStore)(
        IMFAudioMediaType* This);

    HRESULT (STDMETHODCALLTYPE *GetCount)(
        IMFAudioMediaType* This,
        UINT32 *pcItems);

    HRESULT (STDMETHODCALLTYPE *GetItemByIndex)(
        IMFAudioMediaType* This,
        UINT32 unIndex,
        GUID *pguidKey,
        PROPVARIANT *pValue);

    HRESULT (STDMETHODCALLTYPE *CopyAllItems)(
        IMFAudioMediaType* This,
        IMFAttributes *pDest);

    /*** IMFMediaType methods ***/
    HRESULT (STDMETHODCALLTYPE *GetMajorType)(
        IMFAudioMediaType* This,
        GUID *pguidMajorType);

    HRESULT (STDMETHODCALLTYPE *IsCompressedFormat)(
        IMFAudioMediaType* This,
        WINBOOL *pfCompressed);

    HRESULT (STDMETHODCALLTYPE *IsEqual)(
        IMFAudioMediaType* This,
        IMFMediaType *pIMediaType,
        DWORD *pdwFlags);

    HRESULT (STDMETHODCALLTYPE *GetRepresentation)(
        IMFAudioMediaType* This,
        GUID guidRepresentation,
        LPVOID *ppvRepresentation);

    HRESULT (STDMETHODCALLTYPE *FreeRepresentation)(
        IMFAudioMediaType* This,
        GUID guidRepresentation,
        LPVOID pvRepresentation);

    /*** IMFAudioMediaType methods ***/
    const WAVEFORMATEX * (STDMETHODCALLTYPE *GetAudioFormat)(
        IMFAudioMediaType* This);

    END_INTERFACE
} IMFAudioMediaTypeVtbl;
interface IMFAudioMediaType {
    CONST_VTBL IMFAudioMediaTypeVtbl* lpVtbl;
};

#ifdef COBJMACROS
#ifndef WIDL_C_INLINE_WRAPPERS
/*** IUnknown methods ***/
#define IMFAudioMediaType_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
#define IMFAudioMediaType_AddRef(This) (This)->lpVtbl->AddRef(This)
#define IMFAudioMediaType_Release(This) (This)->lpVtbl->Release(This)
/*** IMFAttributes methods ***/
#define IMFAudioMediaType_GetItem(This,guidKey,pValue) (This)->lpVtbl->GetItem(This,guidKey,pValue)
#define IMFAudioMediaType_GetItemType(This,guidKey,pType) (This)->lpVtbl->GetItemType(This,guidKey,pType)
#define IMFAudioMediaType_CompareItem(This,guidKey,Value,pbResult) (This)->lpVtbl->CompareItem(This,guidKey,Value,pbResult)
#define IMFAudioMediaType_Compare(This,pTheirs,MatchType,pbResult) (This)->lpVtbl->Compare(This,pTheirs,MatchType,pbResult)
#define IMFAudioMediaType_GetUINT32(This,guidKey,punValue) (This)->lpVtbl->GetUINT32(This,guidKey,punValue)
#define IMFAudioMediaType_GetUINT64(This,guidKey,punValue) (This)->lpVtbl->GetUINT64(This,guidKey,punValue)
#define IMFAudioMediaType_GetDouble(This,guidKey,pfValue) (This)->lpVtbl->GetDouble(This,guidKey,pfValue)
#define IMFAudioMediaType_GetGUID(This,guidKey,pguidValue) (This)->lpVtbl->GetGUID(This,guidKey,pguidValue)
#define IMFAudioMediaType_GetStringLength(This,guidKey,pcchLength) (This)->lpVtbl->GetStringLength(This,guidKey,pcchLength)
#define IMFAudioMediaType_GetString(This,guidKey,pwszValue,cchBufSize,pcchLength) (This)->lpVtbl->GetString(This,guidKey,pwszValue,cchBufSize,pcchLength)
#define IMFAudioMediaType_GetAllocatedString(This,guidKey,ppwszValue,pcchLength) (This)->lpVtbl->GetAllocatedString(This,guidKey,ppwszValue,pcchLength)
#define IMFAudioMediaType_GetBlobSize(This,guidKey,pcbBlobSize) (This)->lpVtbl->GetBlobSize(This,guidKey,pcbBlobSize)
#define IMFAudioMediaType_GetBlob(This,guidKey,pBuf,cbBufSize,pcbBlobSize) (This)->lpVtbl->GetBlob(This,guidKey,pBuf,cbBufSize,pcbBlobSize)
#define IMFAudioMediaType_GetAllocatedBlob(This,guidKey,ppBuf,pcbSize) (This)->lpVtbl->GetAllocatedBlob(This,guidKey,ppBuf,pcbSize)
#define IMFAudioMediaType_GetUnknown(This,guidKey,riid,ppv) (This)->lpVtbl->GetUnknown(This,guidKey,riid,ppv)
#define IMFAudioMediaType_SetItem(This,guidKey,Value) (This)->lpVtbl->SetItem(This,guidKey,Value)
#define IMFAudioMediaType_DeleteItem(This,guidKey) (This)->lpVtbl->DeleteItem(This,guidKey)
#define IMFAudioMediaType_DeleteAllItems(This) (This)->lpVtbl->DeleteAllItems(This)
#define IMFAudioMediaType_SetUINT32(This,guidKey,unValue) (This)->lpVtbl->SetUINT32(This,guidKey,unValue)
#define IMFAudioMediaType_SetUINT64(This,guidKey,unValue) (This)->lpVtbl->SetUINT64(This,guidKey,unValue)
#define IMFAudioMediaType_SetDouble(This,guidKey,fValue) (This)->lpVtbl->SetDouble(This,guidKey,fValue)
#define IMFAudioMediaType_SetGUID(This,guidKey,guidValue) (This)->lpVtbl->SetGUID(This,guidKey,guidValue)
#define IMFAudioMediaType_SetString(This,guidKey,wszValue) (This)->lpVtbl->SetString(This,guidKey,wszValue)
#define IMFAudioMediaType_SetBlob(This,guidKey,pBuf,cbBufSize) (This)->lpVtbl->SetBlob(This,guidKey,pBuf,cbBufSize)
#define IMFAudioMediaType_SetUnknown(This,guidKey,pUnknown) (This)->lpVtbl->SetUnknown(This,guidKey,pUnknown)
#define IMFAudioMediaType_LockStore(This) (This)->lpVtbl->LockStore(This)
#define IMFAudioMediaType_UnlockStore(This) (This)->lpVtbl->UnlockStore(This)
#define IMFAudioMediaType_GetCount(This,pcItems) (This)->lpVtbl->GetCount(This,pcItems)
#define IMFAudioMediaType_GetItemByIndex(This,unIndex,pguidKey,pValue) (This)->lpVtbl->GetItemByIndex(This,unIndex,pguidKey,pValue)
#define IMFAudioMediaType_CopyAllItems(This,pDest) (This)->lpVtbl->CopyAllItems(This,pDest)
/*** IMFMediaType methods ***/
#define IMFAudioMediaType_GetMajorType(This,pguidMajorType) (This)->lpVtbl->GetMajorType(This,pguidMajorType)
#define IMFAudioMediaType_IsCompressedFormat(This,pfCompressed) (This)->lpVtbl->IsCompressedFormat(This,pfCompressed)
#define IMFAudioMediaType_IsEqual(This,pIMediaType,pdwFlags) (This)->lpVtbl->IsEqual(This,pIMediaType,pdwFlags)
#define IMFAudioMediaType_GetRepresentation(This,guidRepresentation,ppvRepresentation) (This)->lpVtbl->GetRepresentation(This,guidRepresentation,ppvRepresentation)
#define IMFAudioMediaType_FreeRepresentation(This,guidRepresentation,pvRepresentation) (This)->lpVtbl->FreeRepresentation(This,guidRepresentation,pvRepresentation)
/*** IMFAudioMediaType methods ***/
#define IMFAudioMediaType_GetAudioFormat(This) (This)->lpVtbl->GetAudioFormat(This)
#else
/*** IUnknown methods ***/
static FORCEINLINE HRESULT IMFAudioMediaType_QueryInterface(IMFAudioMediaType* This,REFIID riid,void **ppvObject) {
    return This->lpVtbl->QueryInterface(This,riid,ppvObject);
}
static FORCEINLINE ULONG IMFAudioMediaType_AddRef(IMFAudioMediaType* This) {
    return This->lpVtbl->AddRef(This);
}
static FORCEINLINE ULONG IMFAudioMediaType_Release(IMFAudioMediaType* This) {
    return This->lpVtbl->Release(This);
}
/*** IMFAttributes methods ***/
static FORCEINLINE HRESULT IMFAudioMediaType_GetItem(IMFAudioMediaType* This,REFGUID guidKey,PROPVARIANT *pValue) {
    return This->lpVtbl->GetItem(This,guidKey,pValue);
}
static FORCEINLINE HRESULT IMFAudioMediaType_GetItemType(IMFAudioMediaType* This,REFGUID guidKey,MF_ATTRIBUTE_TYPE *pType) {
    return This->lpVtbl->GetItemType(This,guidKey,pType);
}
static FORCEINLINE HRESULT IMFAudioMediaType_CompareItem(IMFAudioMediaType* This,REFGUID guidKey,REFPROPVARIANT Value,WINBOOL *pbResult) {
    return This->lpVtbl->CompareItem(This,guidKey,Value,pbResult);
}
static FORCEINLINE HRESULT IMFAudioMediaType_Compare(IMFAudioMediaType* This,IMFAttributes *pTheirs,MF_ATTRIBUTES_MATCH_TYPE MatchType,WINBOOL *pbResult) {
    return This->lpVtbl->Compare(This,pTheirs,MatchType,pbResult);
}
static FORCEINLINE HRESULT IMFAudioMediaType_GetUINT32(IMFAudioMediaType* This,REFGUID guidKey,UINT32 *punValue) {
    return This->lpVtbl->GetUINT32(This,guidKey,punValue);
}
static FORCEINLINE HRESULT IMFAudioMediaType_GetUINT64(IMFAudioMediaType* This,REFGUID guidKey,UINT64 *punValue) {
    return This->lpVtbl->GetUINT64(This,guidKey,punValue);
}
static FORCEINLINE HRESULT IMFAudioMediaType_GetDouble(IMFAudioMediaType* This,REFGUID guidKey,double *pfValue) {
    return This->lpVtbl->GetDouble(This,guidKey,pfValue);
}
static FORCEINLINE HRESULT IMFAudioMediaType_GetGUID(IMFAudioMediaType* This,REFGUID guidKey,GUID *pguidValue) {
    return This->lpVtbl->GetGUID(This,guidKey,pguidValue);
}
static FORCEINLINE HRESULT IMFAudioMediaType_GetStringLength(IMFAudioMediaType* This,REFGUID guidKey,UINT32 *pcchLength) {
    return This->lpVtbl->GetStringLength(This,guidKey,pcchLength);
}
static FORCEINLINE HRESULT IMFAudioMediaType_GetString(IMFAudioMediaType* This,REFGUID guidKey,LPWSTR pwszValue,UINT32 cchBufSize,UINT32 *pcchLength) {
    return This->lpVtbl->GetString(This,guidKey,pwszValue,cchBufSize,pcchLength);
}
static FORCEINLINE HRESULT IMFAudioMediaType_GetAllocatedString(IMFAudioMediaType* This,REFGUID guidKey,LPWSTR *ppwszValue,UINT32 *pcchLength) {
    return This->lpVtbl->GetAllocatedString(This,guidKey,ppwszValue,pcchLength);
}
static FORCEINLINE HRESULT IMFAudioMediaType_GetBlobSize(IMFAudioMediaType* This,REFGUID guidKey,UINT32 *pcbBlobSize) {
    return This->lpVtbl->GetBlobSize(This,guidKey,pcbBlobSize);
}
static FORCEINLINE HRESULT IMFAudioMediaType_GetBlob(IMFAudioMediaType* This,REFGUID guidKey,UINT8 *pBuf,UINT32 cbBufSize,UINT32 *pcbBlobSize) {
    return This->lpVtbl->GetBlob(This,guidKey,pBuf,cbBufSize,pcbBlobSize);
}
static FORCEINLINE HRESULT IMFAudioMediaType_GetAllocatedBlob(IMFAudioMediaType* This,REFGUID guidKey,UINT8 **ppBuf,UINT32 *pcbSize) {
    return This->lpVtbl->GetAllocatedBlob(This,guidKey,ppBuf,pcbSize);
}
static FORCEINLINE HRESULT IMFAudioMediaType_GetUnknown(IMFAudioMediaType* This,REFGUID guidKey,REFIID riid,LPVOID *ppv) {
    return This->lpVtbl->GetUnknown(This,guidKey,riid,ppv);
}
static FORCEINLINE HRESULT IMFAudioMediaType_SetItem(IMFAudioMediaType* This,REFGUID guidKey,REFPROPVARIANT Value) {
    return This->lpVtbl->SetItem(This,guidKey,Value);
}
static FORCEINLINE HRESULT IMFAudioMediaType_DeleteItem(IMFAudioMediaType* This,REFGUID guidKey) {
    return This->lpVtbl->DeleteItem(This,guidKey);
}
static FORCEINLINE HRESULT IMFAudioMediaType_DeleteAllItems(IMFAudioMediaType* This) {
    return This->lpVtbl->DeleteAllItems(This);
}
static FORCEINLINE HRESULT IMFAudioMediaType_SetUINT32(IMFAudioMediaType* This,REFGUID guidKey,UINT32 unValue) {
    return This->lpVtbl->SetUINT32(This,guidKey,unValue);
}
static FORCEINLINE HRESULT IMFAudioMediaType_SetUINT64(IMFAudioMediaType* This,REFGUID guidKey,UINT64 unValue) {
    return This->lpVtbl->SetUINT64(This,guidKey,unValue);
}
static FORCEINLINE HRESULT IMFAudioMediaType_SetDouble(IMFAudioMediaType* This,REFGUID guidKey,double fValue) {
    return This->lpVtbl->SetDouble(This,guidKey,fValue);
}
static FORCEINLINE HRESULT IMFAudioMediaType_SetGUID(IMFAudioMediaType* This,REFGUID guidKey,REFGUID guidValue) {
    return This->lpVtbl->SetGUID(This,guidKey,guidValue);
}
static FORCEINLINE HRESULT IMFAudioMediaType_SetString(IMFAudioMediaType* This,REFGUID guidKey,LPCWSTR wszValue) {
    return This->lpVtbl->SetString(This,guidKey,wszValue);
}
static FORCEINLINE HRESULT IMFAudioMediaType_SetBlob(IMFAudioMediaType* This,REFGUID guidKey,const UINT8 *pBuf,UINT32 cbBufSize) {
    return This->lpVtbl->SetBlob(This,guidKey,pBuf,cbBufSize);
}
static FORCEINLINE HRESULT IMFAudioMediaType_SetUnknown(IMFAudioMediaType* This,REFGUID guidKey,IUnknown *pUnknown) {
    return This->lpVtbl->SetUnknown(This,guidKey,pUnknown);
}
static FORCEINLINE HRESULT IMFAudioMediaType_LockStore(IMFAudioMediaType* This) {
    return This->lpVtbl->LockStore(This);
}
static FORCEINLINE HRESULT IMFAudioMediaType_UnlockStore(IMFAudioMediaType* This) {
    return This->lpVtbl->UnlockStore(This);
}
static FORCEINLINE HRESULT IMFAudioMediaType_GetCount(IMFAudioMediaType* This,UINT32 *pcItems) {
    return This->lpVtbl->GetCount(This,pcItems);
}
static FORCEINLINE HRESULT IMFAudioMediaType_GetItemByIndex(IMFAudioMediaType* This,UINT32 unIndex,GUID *pguidKey,PROPVARIANT *pValue) {
    return This->lpVtbl->GetItemByIndex(This,unIndex,pguidKey,pValue);
}
static FORCEINLINE HRESULT IMFAudioMediaType_CopyAllItems(IMFAudioMediaType* This,IMFAttributes *pDest) {
    return This->lpVtbl->CopyAllItems(This,pDest);
}
/*** IMFMediaType methods ***/
static FORCEINLINE HRESULT IMFAudioMediaType_GetMajorType(IMFAudioMediaType* This,GUID *pguidMajorType) {
    return This->lpVtbl->GetMajorType(This,pguidMajorType);
}
static FORCEINLINE HRESULT IMFAudioMediaType_IsCompressedFormat(IMFAudioMediaType* This,WINBOOL *pfCompressed) {
    return This->lpVtbl->IsCompressedFormat(This,pfCompressed);
}
static FORCEINLINE HRESULT IMFAudioMediaType_IsEqual(IMFAudioMediaType* This,IMFMediaType *pIMediaType,DWORD *pdwFlags) {
    return This->lpVtbl->IsEqual(This,pIMediaType,pdwFlags);
}
static FORCEINLINE HRESULT IMFAudioMediaType_GetRepresentation(IMFAudioMediaType* This,GUID guidRepresentation,LPVOID *ppvRepresentation) {
    return This->lpVtbl->GetRepresentation(This,guidRepresentation,ppvRepresentation);
}
static FORCEINLINE HRESULT IMFAudioMediaType_FreeRepresentation(IMFAudioMediaType* This,GUID guidRepresentation,LPVOID pvRepresentation) {
    return This->lpVtbl->FreeRepresentation(This,guidRepresentation,pvRepresentation);
}
/*** IMFAudioMediaType methods ***/
static FORCEINLINE const WAVEFORMATEX * IMFAudioMediaType_GetAudioFormat(IMFAudioMediaType* This) {
    return This->lpVtbl->GetAudioFormat(This);
}
#endif
#endif

#endif

const WAVEFORMATEX * STDMETHODCALLTYPE IMFAudioMediaType_GetAudioFormat_Proxy(
    IMFAudioMediaType* This);
void __RPC_STUB IMFAudioMediaType_GetAudioFormat_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IMFAudioMediaType_INTERFACE_DEFINED__ */


#ifndef _WINGDI_
typedef DWORD RGBQUAD;

typedef struct __WIDL_mfobjects_generated_name_00000014 {
    DWORD biSize;
    LONG biWidth;
    LONG biHeight;
    WORD biPlanes;
    WORD biBitCount;
    DWORD biCompression;
    DWORD biSizeImage;
    LONG biXPelsPerMeter;
    LONG biYPelsPerMeter;
    DWORD biClrUsed;
    DWORD biClrImportant;
} BITMAPINFOHEADER;

typedef struct __WIDL_mfobjects_generated_name_00000015 {
    BITMAPINFOHEADER bmiHeader;
    RGBQUAD bmiColors[1];
} BITMAPINFO;
#endif

typedef struct __WIDL_mfobjects_generated_name_00000016 {
    GUID guidMajorType;
    GUID guidSubtype;
} MFT_REGISTER_TYPE_INFO;
#endif
#ifndef _MFVIDEOFORMAT_
#define _MFVIDEOFORMAT_

#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
typedef enum _MFVideoInterlaceMode {
    MFVideoInterlace_Unknown = 0,
    MFVideoInterlace_Progressive = 2,
    MFVideoInterlace_FieldInterleavedUpperFirst = 3,
    MFVideoInterlace_FieldInterleavedLowerFirst = 4,
    MFVideoInterlace_FieldSingleUpper = 5,
    MFVideoInterlace_FieldSingleLower = 6,
    MFVideoInterlace_MixedInterlaceOrProgressive = 7,
    MFVideoInterlace_Last = 8,
    MFVideoInterlace_ForceDWORD = 0x7fffffff
} MFVideoInterlaceMode;

#define MFVideoInterlace_FieldSingleUpperFirst MFVideoInterlace_FieldSingleUpper
#define MFVideoInterlace_FieldSingleLowerFirst MFVideoInterlace_FieldSingleLower

typedef enum _MFVideoTransferFunction {
    MFVideoTransFunc_Unknown = 0,
    MFVideoTransFunc_10 = 1,
    MFVideoTransFunc_18 = 2,
    MFVideoTransFunc_20 = 3,
    MFVideoTransFunc_22 = 4,
    MFVideoTransFunc_709 = 5,
    MFVideoTransFunc_240M = 6,
    MFVideoTransFunc_sRGB = 7,
    MFVideoTransFunc_28 = 8,
    MFVideoTransFunc_Last = 9,
    MFVideoTransFunc_ForceDWORD = 0x7fffffff
} MFVideoTransferFunction;

typedef enum _MFVideoPrimaries {
    MFVideoPrimaries_Unknown = 0,
    MFVideoPrimaries_reserved = 1,
    MFVideoPrimaries_BT709 = 2,
    MFVideoPrimaries_BT470_2_SysM = 3,
    MFVideoPrimaries_BT470_2_SysBG = 4,
    MFVideoPrimaries_SMPTE170M = 5,
    MFVideoPrimaries_SMPTE240M = 6,
    MFVideoPrimaries_EBU3213 = 7,
    MFVideoPrimaries_SMPTE_C = 8,
    MFVideoPrimaries_Last = 9,
    MFVideoPrimaries_ForceDWORD = 0x7fffffff
} MFVideoPrimaries;

typedef enum _MFVideoLighting {
    MFVideoLighting_Unknown = 0,
    MFVideoLighting_bright = 1,
    MFVideoLighting_office = 2,
    MFVideoLighting_dim = 3,
    MFVideoLighting_dark = 4,
    MFVideoLighting_Last = 5,
    MFVideoLighting_ForceDWORD = 0x7fffffff
} MFVideoLighting;

typedef enum _MFVideoTransferMatrix {
    MFVideoTransferMatrix_Unknown = 0,
    MFVideoTransferMatrix_BT709 = 1,
    MFVideoTransferMatrix_BT601 = 2,
    MFVideoTransferMatrix_SMPTE240M = 3,
    MFVideoTransferMatrix_Last = 4,
    MFVideoTransferMatrix_ForceDWORD = 0x7fffffff
} MFVideoTransferMatrix;

typedef enum _MFVideoChromaSubsampling {
    MFVideoChromaSubsampling_Unknown = 0,
    MFVideoChromaSubsampling_ProgressiveChroma = 0x8,
    MFVideoChromaSubsampling_Horizontally_Cosited = 0x4,
    MFVideoChromaSubsampling_Vertically_Cosited = 0x2,
    MFVideoChromaSubsampling_Vertically_AlignedChromaPlanes = 0x1,
    MFVideoChromaSubsampling_MPEG2 = MFVideoChromaSubsampling_Horizontally_Cosited | MFVideoChromaSubsampling_Vertically_AlignedChromaPlanes,
    MFVideoChromaSubsampling_MPEG1 = MFVideoChromaSubsampling_Vertically_AlignedChromaPlanes,
    MFVideoChromaSubsampling_DV_PAL = MFVideoChromaSubsampling_Horizontally_Cosited | MFVideoChromaSubsampling_Vertically_Cosited,
    MFVideoChromaSubsampling_Cosited = (MFVideoChromaSubsampling_Horizontally_Cosited | MFVideoChromaSubsampling_Vertically_Cosited) | MFVideoChromaSubsampling_Vertically_AlignedChromaPlanes,
    MFVideoChromaSubsampling_Last = MFVideoChromaSubsampling_Cosited + 1,
    MFVideoChromaSubsampling_ForceDWORD = 0x7fffffff
} MFVideoChromaSubsampling;

typedef enum _MFNominalRange {
    MFNominalRange_Unknown = 0,
    MFNominalRange_Normal = 1,
    MFNominalRange_Wide = 2,
    MFNominalRange_0_255 = 1,
    MFNominalRange_16_235 = 2,
    MFNominalRange_48_208 = 3,
    MFNominalRange_Last = 4,
    MFNominalRange_ForceDWORD = 0x7fffffff
} MFNominalRange;
#endif

#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
typedef enum _MFVideoFlags {
    MFVideoFlag_PAD_TO_Mask = 0x1 | 0x2,
    MFVideoFlag_PAD_TO_None = 0 * 0x1,
    MFVideoFlag_PAD_TO_4x3 = 1 * 0x1,
    MFVideoFlag_PAD_TO_16x9 = 2 * 0x1,
    MFVideoFlag_SrcContentHintMask = (0x4 | 0x8) | 0x10,
    MFVideoFlag_SrcContentHintNone = 0 * 0x4,
    MFVideoFlag_SrcContentHint16x9 = 1 * 0x4,
    MFVideoFlag_SrcContentHint235_1 = 2 * 0x4,
    MFVideoFlag_AnalogProtected = 0x20,
    MFVideoFlag_DigitallyProtected = 0x40,
    MFVideoFlag_ProgressiveContent = 0x80,
    MFVideoFlag_FieldRepeatCountMask = (0x100 | 0x200) | 0x400,
    MFVideoFlag_FieldRepeatCountShift = 8,
    MFVideoFlag_ProgressiveSeqReset = 0x800,
    MFVideoFlag_PanScanEnabled = 0x20000,
    MFVideoFlag_LowerFieldFirst = 0x40000,
    MFVideoFlag_BottomUpLinearRep = 0x80000,
    MFVideoFlags_DXVASurface = 0x100000,
    MFVideoFlags_RenderTargetSurface = 0x400000,
    MFVideoFlags_ForceQWORD = 0x7fffffff
} MFVideoFlags;
#endif

#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
typedef struct _MFRatio {
    DWORD Numerator;
    DWORD Denominator;
} MFRatio;

typedef struct _MFOffset {
    WORD fract;
    short value;
} MFOffset;
typedef struct _MFVideoArea {
    MFOffset OffsetX;
    MFOffset OffsetY;
    SIZE Area;
} MFVideoArea;
#endif

#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
typedef struct _MFVideoInfo {
    DWORD dwWidth;
    DWORD dwHeight;
    MFRatio PixelAspectRatio;
    MFVideoChromaSubsampling SourceChromaSubsampling;
    MFVideoInterlaceMode InterlaceMode;
    MFVideoTransferFunction TransferFunction;
    MFVideoPrimaries ColorPrimaries;
    MFVideoTransferMatrix TransferMatrix;
    MFVideoLighting SourceLighting;
    MFRatio FramesPerSecond;
    MFNominalRange NominalRange;
    MFVideoArea GeometricAperture;
    MFVideoArea MinimumDisplayAperture;
    MFVideoArea PanScanAperture;
    UINT64 VideoFlags;
} MFVideoInfo;
#endif

#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
typedef struct __MFAYUVSample {
    BYTE bCrValue;
    BYTE bCbValue;
    BYTE bYValue;
    BYTE bSampleAlpha8;
} MFAYUVSample;

typedef struct _MFARGB {
    BYTE rgbBlue;
    BYTE rgbGreen;
    BYTE rgbRed;
    BYTE rgbAlpha;
} MFARGB;

typedef union _MFPaletteEntry {
    MFARGB ARGB;
    MFAYUVSample AYCbCr;
} MFPaletteEntry;
#endif

#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
typedef struct _MFVideoSurfaceInfo {
    DWORD Format;
    DWORD PaletteEntries;
    MFPaletteEntry Palette[1];
} MFVideoSurfaceInfo;

typedef struct _MFVideoCompressedInfo {
    LONGLONG AvgBitrate;
    LONGLONG AvgBitErrorRate;
    DWORD MaxKeyFrameSpacing;
} MFVideoCompressedInfo;

typedef struct _MFVIDEOFORMAT {
    DWORD dwSize;
    MFVideoInfo videoInfo;
    GUID guidFormat;
    MFVideoCompressedInfo compressedInfo;
    MFVideoSurfaceInfo surfaceInfo;
} MFVIDEOFORMAT;

typedef enum _MFStandardVideoFormat {
    MFStdVideoFormat_reserved = 0,
    MFStdVideoFormat_NTSC = 1,
    MFStdVideoFormat_PAL = 2,
    MFStdVideoFormat_DVD_NTSC = 3,
    MFStdVideoFormat_DVD_PAL = 4,
    MFStdVideoFormat_DV_PAL = 5,
    MFStdVideoFormat_DV_NTSC = 6,
    MFStdVideoFormat_ATSC_SD480i = 7,
    MFStdVideoFormat_ATSC_HD1080i = 8,
    MFStdVideoFormat_ATSC_HD720p = 9
} MFStandardVideoFormat;
#endif
#endif

#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
/*****************************************************************************
 * IMFVideoMediaType interface
 */
#ifndef __IMFVideoMediaType_INTERFACE_DEFINED__
#define __IMFVideoMediaType_INTERFACE_DEFINED__

DEFINE_GUID(IID_IMFVideoMediaType, 0xb99f381f, 0xa8f9, 0x47a2, 0xa5,0xaf, 0xca,0x3a,0x22,0x5a,0x38,0x90);
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("b99f381f-a8f9-47a2-a5af-ca3a225a3890")
IMFVideoMediaType : public IMFMediaType
{
    virtual const MFVIDEOFORMAT * STDMETHODCALLTYPE GetVideoFormat(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetVideoRepresentation(
        GUID guidRepresentation,
        LPVOID *ppvRepresentation,
        LONG lStride) = 0;

};
#ifdef __CRT_UUID_DECL
__CRT_UUID_DECL(IMFVideoMediaType, 0xb99f381f, 0xa8f9, 0x47a2, 0xa5,0xaf, 0xca,0x3a,0x22,0x5a,0x38,0x90)
#endif
#else
typedef struct IMFVideoMediaTypeVtbl {
    BEGIN_INTERFACE

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

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

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

    /*** IMFAttributes methods ***/
    HRESULT (STDMETHODCALLTYPE *GetItem)(
        IMFVideoMediaType* This,
        REFGUID guidKey,
        PROPVARIANT *pValue);

    HRESULT (STDMETHODCALLTYPE *GetItemType)(
        IMFVideoMediaType* This,
        REFGUID guidKey,
        MF_ATTRIBUTE_TYPE *pType);

    HRESULT (STDMETHODCALLTYPE *CompareItem)(
        IMFVideoMediaType* This,
        REFGUID guidKey,
        REFPROPVARIANT Value,
        WINBOOL *pbResult);

    HRESULT (STDMETHODCALLTYPE *Compare)(
        IMFVideoMediaType* This,
        IMFAttributes *pTheirs,
        MF_ATTRIBUTES_MATCH_TYPE MatchType,
        WINBOOL *pbResult);

    HRESULT (STDMETHODCALLTYPE *GetUINT32)(
        IMFVideoMediaType* This,
        REFGUID guidKey,
        UINT32 *punValue);

    HRESULT (STDMETHODCALLTYPE *GetUINT64)(
        IMFVideoMediaType* This,
        REFGUID guidKey,
        UINT64 *punValue);

    HRESULT (STDMETHODCALLTYPE *GetDouble)(
        IMFVideoMediaType* This,
        REFGUID guidKey,
        double *pfValue);

    HRESULT (STDMETHODCALLTYPE *GetGUID)(
        IMFVideoMediaType* This,
        REFGUID guidKey,
        GUID *pguidValue);

    HRESULT (STDMETHODCALLTYPE *GetStringLength)(
        IMFVideoMediaType* This,
        REFGUID guidKey,
        UINT32 *pcchLength);

    HRESULT (STDMETHODCALLTYPE *GetString)(
        IMFVideoMediaType* This,
        REFGUID guidKey,
        LPWSTR pwszValue,
        UINT32 cchBufSize,
        UINT32 *pcchLength);

    HRESULT (STDMETHODCALLTYPE *GetAllocatedString)(
        IMFVideoMediaType* This,
        REFGUID guidKey,
        LPWSTR *ppwszValue,
        UINT32 *pcchLength);

    HRESULT (STDMETHODCALLTYPE *GetBlobSize)(
        IMFVideoMediaType* This,
        REFGUID guidKey,
        UINT32 *pcbBlobSize);

    HRESULT (STDMETHODCALLTYPE *GetBlob)(
        IMFVideoMediaType* This,
        REFGUID guidKey,
        UINT8 *pBuf,
        UINT32 cbBufSize,
        UINT32 *pcbBlobSize);

    HRESULT (STDMETHODCALLTYPE *GetAllocatedBlob)(
        IMFVideoMediaType* This,
        REFGUID guidKey,
        UINT8 **ppBuf,
        UINT32 *pcbSize);

    HRESULT (STDMETHODCALLTYPE *GetUnknown)(
        IMFVideoMediaType* This,
        REFGUID guidKey,
        REFIID riid,
        LPVOID *ppv);

    HRESULT (STDMETHODCALLTYPE *SetItem)(
        IMFVideoMediaType* This,
        REFGUID guidKey,
        REFPROPVARIANT Value);

    HRESULT (STDMETHODCALLTYPE *DeleteItem)(
        IMFVideoMediaType* This,
        REFGUID guidKey);

    HRESULT (STDMETHODCALLTYPE *DeleteAllItems)(
        IMFVideoMediaType* This);

    HRESULT (STDMETHODCALLTYPE *SetUINT32)(
        IMFVideoMediaType* This,
        REFGUID guidKey,
        UINT32 unValue);

    HRESULT (STDMETHODCALLTYPE *SetUINT64)(
        IMFVideoMediaType* This,
        REFGUID guidKey,
        UINT64 unValue);

    HRESULT (STDMETHODCALLTYPE *SetDouble)(
        IMFVideoMediaType* This,
        REFGUID guidKey,
        double fValue);

    HRESULT (STDMETHODCALLTYPE *SetGUID)(
        IMFVideoMediaType* This,
        REFGUID guidKey,
        REFGUID guidValue);

    HRESULT (STDMETHODCALLTYPE *SetString)(
        IMFVideoMediaType* This,
        REFGUID guidKey,
        LPCWSTR wszValue);

    HRESULT (STDMETHODCALLTYPE *SetBlob)(
        IMFVideoMediaType* This,
        REFGUID guidKey,
        const UINT8 *pBuf,
        UINT32 cbBufSize);

    HRESULT (STDMETHODCALLTYPE *SetUnknown)(
        IMFVideoMediaType* This,
        REFGUID guidKey,
        IUnknown *pUnknown);

    HRESULT (STDMETHODCALLTYPE *LockStore)(
        IMFVideoMediaType* This);

    HRESULT (STDMETHODCALLTYPE *UnlockStore)(
        IMFVideoMediaType* This);

    HRESULT (STDMETHODCALLTYPE *GetCount)(
        IMFVideoMediaType* This,
        UINT32 *pcItems);

    HRESULT (STDMETHODCALLTYPE *GetItemByIndex)(
        IMFVideoMediaType* This,
        UINT32 unIndex,
        GUID *pguidKey,
        PROPVARIANT *pValue);

    HRESULT (STDMETHODCALLTYPE *CopyAllItems)(
        IMFVideoMediaType* This,
        IMFAttributes *pDest);

    /*** IMFMediaType methods ***/
    HRESULT (STDMETHODCALLTYPE *GetMajorType)(
        IMFVideoMediaType* This,
        GUID *pguidMajorType);

    HRESULT (STDMETHODCALLTYPE *IsCompressedFormat)(
        IMFVideoMediaType* This,
        WINBOOL *pfCompressed);

    HRESULT (STDMETHODCALLTYPE *IsEqual)(
        IMFVideoMediaType* This,
        IMFMediaType *pIMediaType,
        DWORD *pdwFlags);

    HRESULT (STDMETHODCALLTYPE *GetRepresentation)(
        IMFVideoMediaType* This,
        GUID guidRepresentation,
        LPVOID *ppvRepresentation);

    HRESULT (STDMETHODCALLTYPE *FreeRepresentation)(
        IMFVideoMediaType* This,
        GUID guidRepresentation,
        LPVOID pvRepresentation);

    /*** IMFVideoMediaType methods ***/
    const MFVIDEOFORMAT * (STDMETHODCALLTYPE *GetVideoFormat)(
        IMFVideoMediaType* This);

    HRESULT (STDMETHODCALLTYPE *GetVideoRepresentation)(
        IMFVideoMediaType* This,
        GUID guidRepresentation,
        LPVOID *ppvRepresentation,
        LONG lStride);

    END_INTERFACE
} IMFVideoMediaTypeVtbl;
interface IMFVideoMediaType {
    CONST_VTBL IMFVideoMediaTypeVtbl* lpVtbl;
};

#ifdef COBJMACROS
#ifndef WIDL_C_INLINE_WRAPPERS
/*** IUnknown methods ***/
#define IMFVideoMediaType_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
#define IMFVideoMediaType_AddRef(This) (This)->lpVtbl->AddRef(This)
#define IMFVideoMediaType_Release(This) (This)->lpVtbl->Release(This)
/*** IMFAttributes methods ***/
#define IMFVideoMediaType_GetItem(This,guidKey,pValue) (This)->lpVtbl->GetItem(This,guidKey,pValue)
#define IMFVideoMediaType_GetItemType(This,guidKey,pType) (This)->lpVtbl->GetItemType(This,guidKey,pType)
#define IMFVideoMediaType_CompareItem(This,guidKey,Value,pbResult) (This)->lpVtbl->CompareItem(This,guidKey,Value,pbResult)
#define IMFVideoMediaType_Compare(This,pTheirs,MatchType,pbResult) (This)->lpVtbl->Compare(This,pTheirs,MatchType,pbResult)
#define IMFVideoMediaType_GetUINT32(This,guidKey,punValue) (This)->lpVtbl->GetUINT32(This,guidKey,punValue)
#define IMFVideoMediaType_GetUINT64(This,guidKey,punValue) (This)->lpVtbl->GetUINT64(This,guidKey,punValue)
#define IMFVideoMediaType_GetDouble(This,guidKey,pfValue) (This)->lpVtbl->GetDouble(This,guidKey,pfValue)
#define IMFVideoMediaType_GetGUID(This,guidKey,pguidValue) (This)->lpVtbl->GetGUID(This,guidKey,pguidValue)
#define IMFVideoMediaType_GetStringLength(This,guidKey,pcchLength) (This)->lpVtbl->GetStringLength(This,guidKey,pcchLength)
#define IMFVideoMediaType_GetString(This,guidKey,pwszValue,cchBufSize,pcchLength) (This)->lpVtbl->GetString(This,guidKey,pwszValue,cchBufSize,pcchLength)
#define IMFVideoMediaType_GetAllocatedString(This,guidKey,ppwszValue,pcchLength) (This)->lpVtbl->GetAllocatedString(This,guidKey,ppwszValue,pcchLength)
#define IMFVideoMediaType_GetBlobSize(This,guidKey,pcbBlobSize) (This)->lpVtbl->GetBlobSize(This,guidKey,pcbBlobSize)
#define IMFVideoMediaType_GetBlob(This,guidKey,pBuf,cbBufSize,pcbBlobSize) (This)->lpVtbl->GetBlob(This,guidKey,pBuf,cbBufSize,pcbBlobSize)
#define IMFVideoMediaType_GetAllocatedBlob(This,guidKey,ppBuf,pcbSize) (This)->lpVtbl->GetAllocatedBlob(This,guidKey,ppBuf,pcbSize)
#define IMFVideoMediaType_GetUnknown(This,guidKey,riid,ppv) (This)->lpVtbl->GetUnknown(This,guidKey,riid,ppv)
#define IMFVideoMediaType_SetItem(This,guidKey,Value) (This)->lpVtbl->SetItem(This,guidKey,Value)
#define IMFVideoMediaType_DeleteItem(This,guidKey) (This)->lpVtbl->DeleteItem(This,guidKey)
#define IMFVideoMediaType_DeleteAllItems(This) (This)->lpVtbl->DeleteAllItems(This)
#define IMFVideoMediaType_SetUINT32(This,guidKey,unValue) (This)->lpVtbl->SetUINT32(This,guidKey,unValue)
#define IMFVideoMediaType_SetUINT64(This,guidKey,unValue) (This)->lpVtbl->SetUINT64(This,guidKey,unValue)
#define IMFVideoMediaType_SetDouble(This,guidKey,fValue) (This)->lpVtbl->SetDouble(This,guidKey,fValue)
#define IMFVideoMediaType_SetGUID(This,guidKey,guidValue) (This)->lpVtbl->SetGUID(This,guidKey,guidValue)
#define IMFVideoMediaType_SetString(This,guidKey,wszValue) (This)->lpVtbl->SetString(This,guidKey,wszValue)
#define IMFVideoMediaType_SetBlob(This,guidKey,pBuf,cbBufSize) (This)->lpVtbl->SetBlob(This,guidKey,pBuf,cbBufSize)
#define IMFVideoMediaType_SetUnknown(This,guidKey,pUnknown) (This)->lpVtbl->SetUnknown(This,guidKey,pUnknown)
#define IMFVideoMediaType_LockStore(This) (This)->lpVtbl->LockStore(This)
#define IMFVideoMediaType_UnlockStore(This) (This)->lpVtbl->UnlockStore(This)
#define IMFVideoMediaType_GetCount(This,pcItems) (This)->lpVtbl->GetCount(This,pcItems)
#define IMFVideoMediaType_GetItemByIndex(This,unIndex,pguidKey,pValue) (This)->lpVtbl->GetItemByIndex(This,unIndex,pguidKey,pValue)
#define IMFVideoMediaType_CopyAllItems(This,pDest) (This)->lpVtbl->CopyAllItems(This,pDest)
/*** IMFMediaType methods ***/
#define IMFVideoMediaType_GetMajorType(This,pguidMajorType) (This)->lpVtbl->GetMajorType(This,pguidMajorType)
#define IMFVideoMediaType_IsCompressedFormat(This,pfCompressed) (This)->lpVtbl->IsCompressedFormat(This,pfCompressed)
#define IMFVideoMediaType_IsEqual(This,pIMediaType,pdwFlags) (This)->lpVtbl->IsEqual(This,pIMediaType,pdwFlags)
#define IMFVideoMediaType_GetRepresentation(This,guidRepresentation,ppvRepresentation) (This)->lpVtbl->GetRepresentation(This,guidRepresentation,ppvRepresentation)
#define IMFVideoMediaType_FreeRepresentation(This,guidRepresentation,pvRepresentation) (This)->lpVtbl->FreeRepresentation(This,guidRepresentation,pvRepresentation)
/*** IMFVideoMediaType methods ***/
#define IMFVideoMediaType_GetVideoFormat(This) (This)->lpVtbl->GetVideoFormat(This)
#define IMFVideoMediaType_GetVideoRepresentation(This,guidRepresentation,ppvRepresentation,lStride) (This)->lpVtbl->GetVideoRepresentation(This,guidRepresentation,ppvRepresentation,lStride)
#else
/*** IUnknown methods ***/
static FORCEINLINE HRESULT IMFVideoMediaType_QueryInterface(IMFVideoMediaType* This,REFIID riid,void **ppvObject) {
    return This->lpVtbl->QueryInterface(This,riid,ppvObject);
}
static FORCEINLINE ULONG IMFVideoMediaType_AddRef(IMFVideoMediaType* This) {
    return This->lpVtbl->AddRef(This);
}
static FORCEINLINE ULONG IMFVideoMediaType_Release(IMFVideoMediaType* This) {
    return This->lpVtbl->Release(This);
}
/*** IMFAttributes methods ***/
static FORCEINLINE HRESULT IMFVideoMediaType_GetItem(IMFVideoMediaType* This,REFGUID guidKey,PROPVARIANT *pValue) {
    return This->lpVtbl->GetItem(This,guidKey,pValue);
}
static FORCEINLINE HRESULT IMFVideoMediaType_GetItemType(IMFVideoMediaType* This,REFGUID guidKey,MF_ATTRIBUTE_TYPE *pType) {
    return This->lpVtbl->GetItemType(This,guidKey,pType);
}
static FORCEINLINE HRESULT IMFVideoMediaType_CompareItem(IMFVideoMediaType* This,REFGUID guidKey,REFPROPVARIANT Value,WINBOOL *pbResult) {
    return This->lpVtbl->CompareItem(This,guidKey,Value,pbResult);
}
static FORCEINLINE HRESULT IMFVideoMediaType_Compare(IMFVideoMediaType* This,IMFAttributes *pTheirs,MF_ATTRIBUTES_MATCH_TYPE MatchType,WINBOOL *pbResult) {
    return This->lpVtbl->Compare(This,pTheirs,MatchType,pbResult);
}
static FORCEINLINE HRESULT IMFVideoMediaType_GetUINT32(IMFVideoMediaType* This,REFGUID guidKey,UINT32 *punValue) {
    return This->lpVtbl->GetUINT32(This,guidKey,punValue);
}
static FORCEINLINE HRESULT IMFVideoMediaType_GetUINT64(IMFVideoMediaType* This,REFGUID guidKey,UINT64 *punValue) {
    return This->lpVtbl->GetUINT64(This,guidKey,punValue);
}
static FORCEINLINE HRESULT IMFVideoMediaType_GetDouble(IMFVideoMediaType* This,REFGUID guidKey,double *pfValue) {
    return This->lpVtbl->GetDouble(This,guidKey,pfValue);
}
static FORCEINLINE HRESULT IMFVideoMediaType_GetGUID(IMFVideoMediaType* This,REFGUID guidKey,GUID *pguidValue) {
    return This->lpVtbl->GetGUID(This,guidKey,pguidValue);
}
static FORCEINLINE HRESULT IMFVideoMediaType_GetStringLength(IMFVideoMediaType* This,REFGUID guidKey,UINT32 *pcchLength) {
    return This->lpVtbl->GetStringLength(This,guidKey,pcchLength);
}
static FORCEINLINE HRESULT IMFVideoMediaType_GetString(IMFVideoMediaType* This,REFGUID guidKey,LPWSTR pwszValue,UINT32 cchBufSize,UINT32 *pcchLength) {
    return This->lpVtbl->GetString(This,guidKey,pwszValue,cchBufSize,pcchLength);
}
static FORCEINLINE HRESULT IMFVideoMediaType_GetAllocatedString(IMFVideoMediaType* This,REFGUID guidKey,LPWSTR *ppwszValue,UINT32 *pcchLength) {
    return This->lpVtbl->GetAllocatedString(This,guidKey,ppwszValue,pcchLength);
}
static FORCEINLINE HRESULT IMFVideoMediaType_GetBlobSize(IMFVideoMediaType* This,REFGUID guidKey,UINT32 *pcbBlobSize) {
    return This->lpVtbl->GetBlobSize(This,guidKey,pcbBlobSize);
}
static FORCEINLINE HRESULT IMFVideoMediaType_GetBlob(IMFVideoMediaType* This,REFGUID guidKey,UINT8 *pBuf,UINT32 cbBufSize,UINT32 *pcbBlobSize) {
    return This->lpVtbl->GetBlob(This,guidKey,pBuf,cbBufSize,pcbBlobSize);
}
static FORCEINLINE HRESULT IMFVideoMediaType_GetAllocatedBlob(IMFVideoMediaType* This,REFGUID guidKey,UINT8 **ppBuf,UINT32 *pcbSize) {
    return This->lpVtbl->GetAllocatedBlob(This,guidKey,ppBuf,pcbSize);
}
static FORCEINLINE HRESULT IMFVideoMediaType_GetUnknown(IMFVideoMediaType* This,REFGUID guidKey,REFIID riid,LPVOID *ppv) {
    return This->lpVtbl->GetUnknown(This,guidKey,riid,ppv);
}
static FORCEINLINE HRESULT IMFVideoMediaType_SetItem(IMFVideoMediaType* This,REFGUID guidKey,REFPROPVARIANT Value) {
    return This->lpVtbl->SetItem(This,guidKey,Value);
}
static FORCEINLINE HRESULT IMFVideoMediaType_DeleteItem(IMFVideoMediaType* This,REFGUID guidKey) {
    return This->lpVtbl->DeleteItem(This,guidKey);
}
static FORCEINLINE HRESULT IMFVideoMediaType_DeleteAllItems(IMFVideoMediaType* This) {
    return This->lpVtbl->DeleteAllItems(This);
}
static FORCEINLINE HRESULT IMFVideoMediaType_SetUINT32(IMFVideoMediaType* This,REFGUID guidKey,UINT32 unValue) {
    return This->lpVtbl->SetUINT32(This,guidKey,unValue);
}
static FORCEINLINE HRESULT IMFVideoMediaType_SetUINT64(IMFVideoMediaType* This,REFGUID guidKey,UINT64 unValue) {
    return This->lpVtbl->SetUINT64(This,guidKey,unValue);
}
static FORCEINLINE HRESULT IMFVideoMediaType_SetDouble(IMFVideoMediaType* This,REFGUID guidKey,double fValue) {
    return This->lpVtbl->SetDouble(This,guidKey,fValue);
}
static FORCEINLINE HRESULT IMFVideoMediaType_SetGUID(IMFVideoMediaType* This,REFGUID guidKey,REFGUID guidValue) {
    return This->lpVtbl->SetGUID(This,guidKey,guidValue);
}
static FORCEINLINE HRESULT IMFVideoMediaType_SetString(IMFVideoMediaType* This,REFGUID guidKey,LPCWSTR wszValue) {
    return This->lpVtbl->SetString(This,guidKey,wszValue);
}
static FORCEINLINE HRESULT IMFVideoMediaType_SetBlob(IMFVideoMediaType* This,REFGUID guidKey,const UINT8 *pBuf,UINT32 cbBufSize) {
    return This->lpVtbl->SetBlob(This,guidKey,pBuf,cbBufSize);
}
static FORCEINLINE HRESULT IMFVideoMediaType_SetUnknown(IMFVideoMediaType* This,REFGUID guidKey,IUnknown *pUnknown) {
    return This->lpVtbl->SetUnknown(This,guidKey,pUnknown);
}
static FORCEINLINE HRESULT IMFVideoMediaType_LockStore(IMFVideoMediaType* This) {
    return This->lpVtbl->LockStore(This);
}
static FORCEINLINE HRESULT IMFVideoMediaType_UnlockStore(IMFVideoMediaType* This) {
    return This->lpVtbl->UnlockStore(This);
}
static FORCEINLINE HRESULT IMFVideoMediaType_GetCount(IMFVideoMediaType* This,UINT32 *pcItems) {
    return This->lpVtbl->GetCount(This,pcItems);
}
static FORCEINLINE HRESULT IMFVideoMediaType_GetItemByIndex(IMFVideoMediaType* This,UINT32 unIndex,GUID *pguidKey,PROPVARIANT *pValue) {
    return This->lpVtbl->GetItemByIndex(This,unIndex,pguidKey,pValue);
}
static FORCEINLINE HRESULT IMFVideoMediaType_CopyAllItems(IMFVideoMediaType* This,IMFAttributes *pDest) {
    return This->lpVtbl->CopyAllItems(This,pDest);
}
/*** IMFMediaType methods ***/
static FORCEINLINE HRESULT IMFVideoMediaType_GetMajorType(IMFVideoMediaType* This,GUID *pguidMajorType) {
    return This->lpVtbl->GetMajorType(This,pguidMajorType);
}
static FORCEINLINE HRESULT IMFVideoMediaType_IsCompressedFormat(IMFVideoMediaType* This,WINBOOL *pfCompressed) {
    return This->lpVtbl->IsCompressedFormat(This,pfCompressed);
}
static FORCEINLINE HRESULT IMFVideoMediaType_IsEqual(IMFVideoMediaType* This,IMFMediaType *pIMediaType,DWORD *pdwFlags) {
    return This->lpVtbl->IsEqual(This,pIMediaType,pdwFlags);
}
static FORCEINLINE HRESULT IMFVideoMediaType_GetRepresentation(IMFVideoMediaType* This,GUID guidRepresentation,LPVOID *ppvRepresentation) {
    return This->lpVtbl->GetRepresentation(This,guidRepresentation,ppvRepresentation);
}
static FORCEINLINE HRESULT IMFVideoMediaType_FreeRepresentation(IMFVideoMediaType* This,GUID guidRepresentation,LPVOID pvRepresentation) {
    return This->lpVtbl->FreeRepresentation(This,guidRepresentation,pvRepresentation);
}
/*** IMFVideoMediaType methods ***/
static FORCEINLINE const MFVIDEOFORMAT * IMFVideoMediaType_GetVideoFormat(IMFVideoMediaType* This) {
    return This->lpVtbl->GetVideoFormat(This);
}
static FORCEINLINE HRESULT IMFVideoMediaType_GetVideoRepresentation(IMFVideoMediaType* This,GUID guidRepresentation,LPVOID *ppvRepresentation,LONG lStride) {
    return This->lpVtbl->GetVideoRepresentation(This,guidRepresentation,ppvRepresentation,lStride);
}
#endif
#endif

#endif

const MFVIDEOFORMAT * STDMETHODCALLTYPE IMFVideoMediaType_GetVideoFormat_Proxy(
    IMFVideoMediaType* This);
void __RPC_STUB IMFVideoMediaType_GetVideoFormat_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFVideoMediaType_GetVideoRepresentation_Proxy(
    IMFVideoMediaType* This,
    GUID guidRepresentation,
    LPVOID *ppvRepresentation,
    LONG lStride);
void __RPC_STUB IMFVideoMediaType_GetVideoRepresentation_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IMFVideoMediaType_INTERFACE_DEFINED__ */

#endif

#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
/*****************************************************************************
 * IMFAsyncResult interface
 */
#ifndef __IMFAsyncResult_INTERFACE_DEFINED__
#define __IMFAsyncResult_INTERFACE_DEFINED__

DEFINE_GUID(IID_IMFAsyncResult, 0xac6b7889, 0x0740, 0x4d51, 0x86,0x19, 0x90,0x59,0x94,0xa5,0x5c,0xc6);
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("ac6b7889-0740-4d51-8619-905994a55cc6")
IMFAsyncResult : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE GetState(
        IUnknown **ppunkState) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetStatus(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetStatus(
        HRESULT hrStatus) = 0;

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

    virtual IUnknown * STDMETHODCALLTYPE GetStateNoAddRef(
        ) = 0;

};
#ifdef __CRT_UUID_DECL
__CRT_UUID_DECL(IMFAsyncResult, 0xac6b7889, 0x0740, 0x4d51, 0x86,0x19, 0x90,0x59,0x94,0xa5,0x5c,0xc6)
#endif
#else
typedef struct IMFAsyncResultVtbl {
    BEGIN_INTERFACE

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

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

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

    /*** IMFAsyncResult methods ***/
    HRESULT (STDMETHODCALLTYPE *GetState)(
        IMFAsyncResult* This,
        IUnknown **ppunkState);

    HRESULT (STDMETHODCALLTYPE *GetStatus)(
        IMFAsyncResult* This);

    HRESULT (STDMETHODCALLTYPE *SetStatus)(
        IMFAsyncResult* This,
        HRESULT hrStatus);

    HRESULT (STDMETHODCALLTYPE *GetObject)(
        IMFAsyncResult* This,
        IUnknown **ppObject);

    IUnknown * (STDMETHODCALLTYPE *GetStateNoAddRef)(
        IMFAsyncResult* This);

    END_INTERFACE
} IMFAsyncResultVtbl;
interface IMFAsyncResult {
    CONST_VTBL IMFAsyncResultVtbl* lpVtbl;
};

#ifdef COBJMACROS
#ifndef WIDL_C_INLINE_WRAPPERS
/*** IUnknown methods ***/
#define IMFAsyncResult_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
#define IMFAsyncResult_AddRef(This) (This)->lpVtbl->AddRef(This)
#define IMFAsyncResult_Release(This) (This)->lpVtbl->Release(This)
/*** IMFAsyncResult methods ***/
#define IMFAsyncResult_GetState(This,ppunkState) (This)->lpVtbl->GetState(This,ppunkState)
#define IMFAsyncResult_GetStatus(This) (This)->lpVtbl->GetStatus(This)
#define IMFAsyncResult_SetStatus(This,hrStatus) (This)->lpVtbl->SetStatus(This,hrStatus)
#define IMFAsyncResult_GetObject(This,ppObject) (This)->lpVtbl->GetObject(This,ppObject)
#define IMFAsyncResult_GetStateNoAddRef(This) (This)->lpVtbl->GetStateNoAddRef(This)
#else
/*** IUnknown methods ***/
static FORCEINLINE HRESULT IMFAsyncResult_QueryInterface(IMFAsyncResult* This,REFIID riid,void **ppvObject) {
    return This->lpVtbl->QueryInterface(This,riid,ppvObject);
}
static FORCEINLINE ULONG IMFAsyncResult_AddRef(IMFAsyncResult* This) {
    return This->lpVtbl->AddRef(This);
}
static FORCEINLINE ULONG IMFAsyncResult_Release(IMFAsyncResult* This) {
    return This->lpVtbl->Release(This);
}
/*** IMFAsyncResult methods ***/
static FORCEINLINE HRESULT IMFAsyncResult_GetState(IMFAsyncResult* This,IUnknown **ppunkState) {
    return This->lpVtbl->GetState(This,ppunkState);
}
static FORCEINLINE HRESULT IMFAsyncResult_GetStatus(IMFAsyncResult* This) {
    return This->lpVtbl->GetStatus(This);
}
static FORCEINLINE HRESULT IMFAsyncResult_SetStatus(IMFAsyncResult* This,HRESULT hrStatus) {
    return This->lpVtbl->SetStatus(This,hrStatus);
}
static FORCEINLINE HRESULT IMFAsyncResult_GetObject(IMFAsyncResult* This,IUnknown **ppObject) {
    return This->lpVtbl->GetObject(This,ppObject);
}
static FORCEINLINE IUnknown * IMFAsyncResult_GetStateNoAddRef(IMFAsyncResult* This) {
    return This->lpVtbl->GetStateNoAddRef(This);
}
#endif
#endif

#endif

HRESULT STDMETHODCALLTYPE IMFAsyncResult_GetState_Proxy(
    IMFAsyncResult* This,
    IUnknown **ppunkState);
void __RPC_STUB IMFAsyncResult_GetState_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFAsyncResult_GetStatus_Proxy(
    IMFAsyncResult* This);
void __RPC_STUB IMFAsyncResult_GetStatus_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFAsyncResult_SetStatus_Proxy(
    IMFAsyncResult* This,
    HRESULT hrStatus);
void __RPC_STUB IMFAsyncResult_SetStatus_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFAsyncResult_GetObject_Proxy(
    IMFAsyncResult* This,
    IUnknown **ppObject);
void __RPC_STUB IMFAsyncResult_GetObject_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IMFAsyncResult_INTERFACE_DEFINED__ */


/*****************************************************************************
 * IMFAsyncCallback interface
 */
#ifndef __IMFAsyncCallback_INTERFACE_DEFINED__
#define __IMFAsyncCallback_INTERFACE_DEFINED__

DEFINE_GUID(IID_IMFAsyncCallback, 0xa27003cf, 0x2354, 0x4f2a, 0x8d,0x6a, 0xab,0x7c,0xff,0x15,0x43,0x7e);
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("a27003cf-2354-4f2a-8d6a-ab7cff15437e")
IMFAsyncCallback : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE GetParameters(
        DWORD *pdwFlags,
        DWORD *pdwQueue) = 0;

    virtual HRESULT STDMETHODCALLTYPE Invoke(
        IMFAsyncResult *pAsyncResult) = 0;

};
#ifdef __CRT_UUID_DECL
__CRT_UUID_DECL(IMFAsyncCallback, 0xa27003cf, 0x2354, 0x4f2a, 0x8d,0x6a, 0xab,0x7c,0xff,0x15,0x43,0x7e)
#endif
#else
typedef struct IMFAsyncCallbackVtbl {
    BEGIN_INTERFACE

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

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

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

    /*** IMFAsyncCallback methods ***/
    HRESULT (STDMETHODCALLTYPE *GetParameters)(
        IMFAsyncCallback* This,
        DWORD *pdwFlags,
        DWORD *pdwQueue);

    HRESULT (STDMETHODCALLTYPE *Invoke)(
        IMFAsyncCallback* This,
        IMFAsyncResult *pAsyncResult);

    END_INTERFACE
} IMFAsyncCallbackVtbl;
interface IMFAsyncCallback {
    CONST_VTBL IMFAsyncCallbackVtbl* lpVtbl;
};

#ifdef COBJMACROS
#ifndef WIDL_C_INLINE_WRAPPERS
/*** IUnknown methods ***/
#define IMFAsyncCallback_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
#define IMFAsyncCallback_AddRef(This) (This)->lpVtbl->AddRef(This)
#define IMFAsyncCallback_Release(This) (This)->lpVtbl->Release(This)
/*** IMFAsyncCallback methods ***/
#define IMFAsyncCallback_GetParameters(This,pdwFlags,pdwQueue) (This)->lpVtbl->GetParameters(This,pdwFlags,pdwQueue)
#define IMFAsyncCallback_Invoke(This,pAsyncResult) (This)->lpVtbl->Invoke(This,pAsyncResult)
#else
/*** IUnknown methods ***/
static FORCEINLINE HRESULT IMFAsyncCallback_QueryInterface(IMFAsyncCallback* This,REFIID riid,void **ppvObject) {
    return This->lpVtbl->QueryInterface(This,riid,ppvObject);
}
static FORCEINLINE ULONG IMFAsyncCallback_AddRef(IMFAsyncCallback* This) {
    return This->lpVtbl->AddRef(This);
}
static FORCEINLINE ULONG IMFAsyncCallback_Release(IMFAsyncCallback* This) {
    return This->lpVtbl->Release(This);
}
/*** IMFAsyncCallback methods ***/
static FORCEINLINE HRESULT IMFAsyncCallback_GetParameters(IMFAsyncCallback* This,DWORD *pdwFlags,DWORD *pdwQueue) {
    return This->lpVtbl->GetParameters(This,pdwFlags,pdwQueue);
}
static FORCEINLINE HRESULT IMFAsyncCallback_Invoke(IMFAsyncCallback* This,IMFAsyncResult *pAsyncResult) {
    return This->lpVtbl->Invoke(This,pAsyncResult);
}
#endif
#endif

#endif

HRESULT STDMETHODCALLTYPE IMFAsyncCallback_GetParameters_Proxy(
    IMFAsyncCallback* This,
    DWORD *pdwFlags,
    DWORD *pdwQueue);
void __RPC_STUB IMFAsyncCallback_GetParameters_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFAsyncCallback_Invoke_Proxy(
    IMFAsyncCallback* This,
    IMFAsyncResult *pAsyncResult);
void __RPC_STUB IMFAsyncCallback_Invoke_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IMFAsyncCallback_INTERFACE_DEFINED__ */

#endif

#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
/*****************************************************************************
 * IMFAsyncCallbackLogging interface
 */
#ifndef __IMFAsyncCallbackLogging_INTERFACE_DEFINED__
#define __IMFAsyncCallbackLogging_INTERFACE_DEFINED__

DEFINE_GUID(IID_IMFAsyncCallbackLogging, 0xc7a4dca1, 0xf5f0, 0x47b6, 0xb9,0x2b, 0xbf,0x01,0x06,0xd2,0x57,0x91);
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("c7a4dca1-f5f0-47b6-b92b-bf0106d25791")
IMFAsyncCallbackLogging : public IMFAsyncCallback
{
    virtual void * STDMETHODCALLTYPE GetObjectPointer(
        ) = 0;

    virtual DWORD STDMETHODCALLTYPE GetObjectTag(
        ) = 0;

};
#ifdef __CRT_UUID_DECL
__CRT_UUID_DECL(IMFAsyncCallbackLogging, 0xc7a4dca1, 0xf5f0, 0x47b6, 0xb9,0x2b, 0xbf,0x01,0x06,0xd2,0x57,0x91)
#endif
#else
typedef struct IMFAsyncCallbackLoggingVtbl {
    BEGIN_INTERFACE

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

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

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

    /*** IMFAsyncCallback methods ***/
    HRESULT (STDMETHODCALLTYPE *GetParameters)(
        IMFAsyncCallbackLogging* This,
        DWORD *pdwFlags,
        DWORD *pdwQueue);

    HRESULT (STDMETHODCALLTYPE *Invoke)(
        IMFAsyncCallbackLogging* This,
        IMFAsyncResult *pAsyncResult);

    /*** IMFAsyncCallbackLogging methods ***/
    void * (STDMETHODCALLTYPE *GetObjectPointer)(
        IMFAsyncCallbackLogging* This);

    DWORD (STDMETHODCALLTYPE *GetObjectTag)(
        IMFAsyncCallbackLogging* This);

    END_INTERFACE
} IMFAsyncCallbackLoggingVtbl;
interface IMFAsyncCallbackLogging {
    CONST_VTBL IMFAsyncCallbackLoggingVtbl* lpVtbl;
};

#ifdef COBJMACROS
#ifndef WIDL_C_INLINE_WRAPPERS
/*** IUnknown methods ***/
#define IMFAsyncCallbackLogging_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
#define IMFAsyncCallbackLogging_AddRef(This) (This)->lpVtbl->AddRef(This)
#define IMFAsyncCallbackLogging_Release(This) (This)->lpVtbl->Release(This)
/*** IMFAsyncCallback methods ***/
#define IMFAsyncCallbackLogging_GetParameters(This,pdwFlags,pdwQueue) (This)->lpVtbl->GetParameters(This,pdwFlags,pdwQueue)
#define IMFAsyncCallbackLogging_Invoke(This,pAsyncResult) (This)->lpVtbl->Invoke(This,pAsyncResult)
/*** IMFAsyncCallbackLogging methods ***/
#define IMFAsyncCallbackLogging_GetObjectPointer(This) (This)->lpVtbl->GetObjectPointer(This)
#define IMFAsyncCallbackLogging_GetObjectTag(This) (This)->lpVtbl->GetObjectTag(This)
#else
/*** IUnknown methods ***/
static FORCEINLINE HRESULT IMFAsyncCallbackLogging_QueryInterface(IMFAsyncCallbackLogging* This,REFIID riid,void **ppvObject) {
    return This->lpVtbl->QueryInterface(This,riid,ppvObject);
}
static FORCEINLINE ULONG IMFAsyncCallbackLogging_AddRef(IMFAsyncCallbackLogging* This) {
    return This->lpVtbl->AddRef(This);
}
static FORCEINLINE ULONG IMFAsyncCallbackLogging_Release(IMFAsyncCallbackLogging* This) {
    return This->lpVtbl->Release(This);
}
/*** IMFAsyncCallback methods ***/
static FORCEINLINE HRESULT IMFAsyncCallbackLogging_GetParameters(IMFAsyncCallbackLogging* This,DWORD *pdwFlags,DWORD *pdwQueue) {
    return This->lpVtbl->GetParameters(This,pdwFlags,pdwQueue);
}
static FORCEINLINE HRESULT IMFAsyncCallbackLogging_Invoke(IMFAsyncCallbackLogging* This,IMFAsyncResult *pAsyncResult) {
    return This->lpVtbl->Invoke(This,pAsyncResult);
}
/*** IMFAsyncCallbackLogging methods ***/
static FORCEINLINE void * IMFAsyncCallbackLogging_GetObjectPointer(IMFAsyncCallbackLogging* This) {
    return This->lpVtbl->GetObjectPointer(This);
}
static FORCEINLINE DWORD IMFAsyncCallbackLogging_GetObjectTag(IMFAsyncCallbackLogging* This) {
    return This->lpVtbl->GetObjectTag(This);
}
#endif
#endif

#endif

void * STDMETHODCALLTYPE IMFAsyncCallbackLogging_GetObjectPointer_Proxy(
    IMFAsyncCallbackLogging* This);
void __RPC_STUB IMFAsyncCallbackLogging_GetObjectPointer_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
DWORD STDMETHODCALLTYPE IMFAsyncCallbackLogging_GetObjectTag_Proxy(
    IMFAsyncCallbackLogging* This);
void __RPC_STUB IMFAsyncCallbackLogging_GetObjectTag_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IMFAsyncCallbackLogging_INTERFACE_DEFINED__ */

#endif

#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
#define MFASYNC_FAST_IO_PROCESSING_CALLBACK 0x00000001
#define MFASYNC_SIGNAL_CALLBACK 0x00000002
#define MFASYNC_BLOCKING_CALLBACK 0x00000004
#define MFASYNC_REPLY_CALLBACK 0x00000008
#define MFASYNC_LOCALIZE_REMOTE_CALLBACK 0x00000010

#define MFASYNC_CALLBACK_QUEUE_UNDEFINED 0x00000000
#define MFASYNC_CALLBACK_QUEUE_STANDARD 0x00000001
#define MFASYNC_CALLBACK_QUEUE_RT 0x00000002
#define MFASYNC_CALLBACK_QUEUE_IO 0x00000003
#define MFASYNC_CALLBACK_QUEUE_TIMER 0x00000004
#define MFASYNC_CALLBACK_QUEUE_MULTITHREADED 0x00000005
#define MFASYNC_CALLBACK_QUEUE_LONG_FUNCTION 0x00000007
#define MFASYNC_CALLBACK_QUEUE_PRIVATE_MASK 0xFFFF0000
#define MFASYNC_CALLBACK_QUEUE_ALL 0xFFFFFFFF

enum {
    MEUnknown = 0,
    MEError = 1,
    MEExtendedType = 2,
    MENonFatalError = 3,
    MEGenericV1Anchor = MENonFatalError,
    MESessionUnknown = 100,
    MESessionTopologySet = 101,
    MESessionTopologiesCleared = 102,
    MESessionStarted = 103,
    MESessionPaused = 104,
    MESessionStopped = 105,
    MESessionClosed = 106,
    MESessionEnded = 107,
    MESessionRateChanged = 108,
    MESessionScrubSampleComplete = 109,
    MESessionCapabilitiesChanged = 110,
    MESessionTopologyStatus = 111,
    MESessionNotifyPresentationTime = 112,
    MENewPresentation = 113,
    MELicenseAcquisitionStart = 114,
    MELicenseAcquisitionCompleted = 115,
    MEIndividualizationStart = 116,
    MEIndividualizationCompleted = 117,
    MEEnablerProgress = 118,
    MEEnablerCompleted = 119,
    MEPolicyError = 120,
    MEPolicyReport = 121,
    MEBufferingStarted = 122,
    MEBufferingStopped = 123,
    MEConnectStart = 124,
    MEConnectEnd = 125,
    MEReconnectStart = 126,
    MEReconnectEnd = 127,
    MERendererEvent = 128,
    MESessionStreamSinkFormatChanged = 129,
    MESessionV1Anchor = MESessionStreamSinkFormatChanged,
    MESourceUnknown = 200,
    MESourceStarted = 201,
    MEStreamStarted = 202,
    MESourceSeeked = 203,
    MEStreamSeeked = 204,
    MENewStream = 205,
    MEUpdatedStream = 206,
    MESourceStopped = 207,
    MEStreamStopped = 208,
    MESourcePaused = 209,
    MEStreamPaused = 210,
    MEEndOfPresentation = 211,
    MEEndOfStream = 212,
    MEMediaSample = 213,
    MEStreamTick = 214,
    MEStreamThinMode = 215,
    MEStreamFormatChanged = 216,
    MESourceRateChanged = 217,
    MEEndOfPresentationSegment = 218,
    MESourceCharacteristicsChanged = 219,
    MESourceRateChangeRequested = 220,
    MESourceMetadataChanged = 221,
    MESequencerSourceTopologyUpdated = 222,
    MESourceV1Anchor = MESequencerSourceTopologyUpdated,
    MESinkUnknown = 300,
    MEStreamSinkStarted = 301,
    MEStreamSinkStopped = 302,
    MEStreamSinkPaused = 303,
    MEStreamSinkRateChanged = 304,
    MEStreamSinkRequestSample = 305,
    MEStreamSinkMarker = 306,
    MEStreamSinkPrerolled = 307,
    MEStreamSinkScrubSampleComplete = 308,
    MEStreamSinkFormatChanged = 309,
    MEStreamSinkDeviceChanged = 310,
    MEQualityNotify = 311,
    MESinkInvalidated = 312,
    MEAudioSessionNameChanged = 313,
    MEAudioSessionVolumeChanged = 314,
    MEAudioSessionDeviceRemoved = 315,
    MEAudioSessionServerShutdown = 316,
    MEAudioSessionGroupingParamChanged = 317,
    MEAudioSessionIconChanged = 318,
    MEAudioSessionFormatChanged = 319,
    MEAudioSessionDisconnected = 320,
    MEAudioSessionExclusiveModeOverride = 321,
    MESinkV1Anchor = MEAudioSessionExclusiveModeOverride,
    METrustUnknown = 400,
    MEPolicyChanged = 401,
    MEContentProtectionMessage = 402,
    MEPolicySet = 403,
    METrustV1Anchor = MEPolicySet,
    MEWMDRMLicenseBackupCompleted = 500,
    MEWMDRMLicenseBackupProgress = 501,
    MEWMDRMLicenseRestoreCompleted = 502,
    MEWMDRMLicenseRestoreProgress = 503,
    MEWMDRMLicenseAcquisitionCompleted = 506,
    MEWMDRMIndividualizationCompleted = 508,
    MEWMDRMIndividualizationProgress = 513,
    MEWMDRMProximityCompleted = 514,
    MEWMDRMLicenseStoreCleaned = 515,
    MEWMDRMRevocationDownloadCompleted = 516,
    MEWMDRMV1Anchor = MEWMDRMRevocationDownloadCompleted,
    MEReservedMax = 10000
};


typedef DWORD MediaEventType;

/*****************************************************************************
 * IMFMediaEvent interface
 */
#ifndef __IMFMediaEvent_INTERFACE_DEFINED__
#define __IMFMediaEvent_INTERFACE_DEFINED__

DEFINE_GUID(IID_IMFMediaEvent, 0xdf598932, 0xf10c, 0x4e39, 0xbb,0xa2, 0xc3,0x08,0xf1,0x01,0xda,0xa3);
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("df598932-f10c-4e39-bba2-c308f101daa3")
IMFMediaEvent : public IMFAttributes
{
    virtual HRESULT STDMETHODCALLTYPE GetType(
        MediaEventType *pmet) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetExtendedType(
        GUID *pguidExtendedType) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetStatus(
        HRESULT *phrStatus) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetValue(
        PROPVARIANT *pvValue) = 0;

};
#ifdef __CRT_UUID_DECL
__CRT_UUID_DECL(IMFMediaEvent, 0xdf598932, 0xf10c, 0x4e39, 0xbb,0xa2, 0xc3,0x08,0xf1,0x01,0xda,0xa3)
#endif
#else
typedef struct IMFMediaEventVtbl {
    BEGIN_INTERFACE

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

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

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

    /*** IMFAttributes methods ***/
    HRESULT (STDMETHODCALLTYPE *GetItem)(
        IMFMediaEvent* This,
        REFGUID guidKey,
        PROPVARIANT *pValue);

    HRESULT (STDMETHODCALLTYPE *GetItemType)(
        IMFMediaEvent* This,
        REFGUID guidKey,
        MF_ATTRIBUTE_TYPE *pType);

    HRESULT (STDMETHODCALLTYPE *CompareItem)(
        IMFMediaEvent* This,
        REFGUID guidKey,
        REFPROPVARIANT Value,
        WINBOOL *pbResult);

    HRESULT (STDMETHODCALLTYPE *Compare)(
        IMFMediaEvent* This,
        IMFAttributes *pTheirs,
        MF_ATTRIBUTES_MATCH_TYPE MatchType,
        WINBOOL *pbResult);

    HRESULT (STDMETHODCALLTYPE *GetUINT32)(
        IMFMediaEvent* This,
        REFGUID guidKey,
        UINT32 *punValue);

    HRESULT (STDMETHODCALLTYPE *GetUINT64)(
        IMFMediaEvent* This,
        REFGUID guidKey,
        UINT64 *punValue);

    HRESULT (STDMETHODCALLTYPE *GetDouble)(
        IMFMediaEvent* This,
        REFGUID guidKey,
        double *pfValue);

    HRESULT (STDMETHODCALLTYPE *GetGUID)(
        IMFMediaEvent* This,
        REFGUID guidKey,
        GUID *pguidValue);

    HRESULT (STDMETHODCALLTYPE *GetStringLength)(
        IMFMediaEvent* This,
        REFGUID guidKey,
        UINT32 *pcchLength);

    HRESULT (STDMETHODCALLTYPE *GetString)(
        IMFMediaEvent* This,
        REFGUID guidKey,
        LPWSTR pwszValue,
        UINT32 cchBufSize,
        UINT32 *pcchLength);

    HRESULT (STDMETHODCALLTYPE *GetAllocatedString)(
        IMFMediaEvent* This,
        REFGUID guidKey,
        LPWSTR *ppwszValue,
        UINT32 *pcchLength);

    HRESULT (STDMETHODCALLTYPE *GetBlobSize)(
        IMFMediaEvent* This,
        REFGUID guidKey,
        UINT32 *pcbBlobSize);

    HRESULT (STDMETHODCALLTYPE *GetBlob)(
        IMFMediaEvent* This,
        REFGUID guidKey,
        UINT8 *pBuf,
        UINT32 cbBufSize,
        UINT32 *pcbBlobSize);

    HRESULT (STDMETHODCALLTYPE *GetAllocatedBlob)(
        IMFMediaEvent* This,
        REFGUID guidKey,
        UINT8 **ppBuf,
        UINT32 *pcbSize);

    HRESULT (STDMETHODCALLTYPE *GetUnknown)(
        IMFMediaEvent* This,
        REFGUID guidKey,
        REFIID riid,
        LPVOID *ppv);

    HRESULT (STDMETHODCALLTYPE *SetItem)(
        IMFMediaEvent* This,
        REFGUID guidKey,
        REFPROPVARIANT Value);

    HRESULT (STDMETHODCALLTYPE *DeleteItem)(
        IMFMediaEvent* This,
        REFGUID guidKey);

    HRESULT (STDMETHODCALLTYPE *DeleteAllItems)(
        IMFMediaEvent* This);

    HRESULT (STDMETHODCALLTYPE *SetUINT32)(
        IMFMediaEvent* This,
        REFGUID guidKey,
        UINT32 unValue);

    HRESULT (STDMETHODCALLTYPE *SetUINT64)(
        IMFMediaEvent* This,
        REFGUID guidKey,
        UINT64 unValue);

    HRESULT (STDMETHODCALLTYPE *SetDouble)(
        IMFMediaEvent* This,
        REFGUID guidKey,
        double fValue);

    HRESULT (STDMETHODCALLTYPE *SetGUID)(
        IMFMediaEvent* This,
        REFGUID guidKey,
        REFGUID guidValue);

    HRESULT (STDMETHODCALLTYPE *SetString)(
        IMFMediaEvent* This,
        REFGUID guidKey,
        LPCWSTR wszValue);

    HRESULT (STDMETHODCALLTYPE *SetBlob)(
        IMFMediaEvent* This,
        REFGUID guidKey,
        const UINT8 *pBuf,
        UINT32 cbBufSize);

    HRESULT (STDMETHODCALLTYPE *SetUnknown)(
        IMFMediaEvent* This,
        REFGUID guidKey,
        IUnknown *pUnknown);

    HRESULT (STDMETHODCALLTYPE *LockStore)(
        IMFMediaEvent* This);

    HRESULT (STDMETHODCALLTYPE *UnlockStore)(
        IMFMediaEvent* This);

    HRESULT (STDMETHODCALLTYPE *GetCount)(
        IMFMediaEvent* This,
        UINT32 *pcItems);

    HRESULT (STDMETHODCALLTYPE *GetItemByIndex)(
        IMFMediaEvent* This,
        UINT32 unIndex,
        GUID *pguidKey,
        PROPVARIANT *pValue);

    HRESULT (STDMETHODCALLTYPE *CopyAllItems)(
        IMFMediaEvent* This,
        IMFAttributes *pDest);

    /*** IMFMediaEvent methods ***/
    HRESULT (STDMETHODCALLTYPE *GetType)(
        IMFMediaEvent* This,
        MediaEventType *pmet);

    HRESULT (STDMETHODCALLTYPE *GetExtendedType)(
        IMFMediaEvent* This,
        GUID *pguidExtendedType);

    HRESULT (STDMETHODCALLTYPE *GetStatus)(
        IMFMediaEvent* This,
        HRESULT *phrStatus);

    HRESULT (STDMETHODCALLTYPE *GetValue)(
        IMFMediaEvent* This,
        PROPVARIANT *pvValue);

    END_INTERFACE
} IMFMediaEventVtbl;
interface IMFMediaEvent {
    CONST_VTBL IMFMediaEventVtbl* lpVtbl;
};

#ifdef COBJMACROS
#ifndef WIDL_C_INLINE_WRAPPERS
/*** IUnknown methods ***/
#define IMFMediaEvent_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
#define IMFMediaEvent_AddRef(This) (This)->lpVtbl->AddRef(This)
#define IMFMediaEvent_Release(This) (This)->lpVtbl->Release(This)
/*** IMFAttributes methods ***/
#define IMFMediaEvent_GetItem(This,guidKey,pValue) (This)->lpVtbl->GetItem(This,guidKey,pValue)
#define IMFMediaEvent_GetItemType(This,guidKey,pType) (This)->lpVtbl->GetItemType(This,guidKey,pType)
#define IMFMediaEvent_CompareItem(This,guidKey,Value,pbResult) (This)->lpVtbl->CompareItem(This,guidKey,Value,pbResult)
#define IMFMediaEvent_Compare(This,pTheirs,MatchType,pbResult) (This)->lpVtbl->Compare(This,pTheirs,MatchType,pbResult)
#define IMFMediaEvent_GetUINT32(This,guidKey,punValue) (This)->lpVtbl->GetUINT32(This,guidKey,punValue)
#define IMFMediaEvent_GetUINT64(This,guidKey,punValue) (This)->lpVtbl->GetUINT64(This,guidKey,punValue)
#define IMFMediaEvent_GetDouble(This,guidKey,pfValue) (This)->lpVtbl->GetDouble(This,guidKey,pfValue)
#define IMFMediaEvent_GetGUID(This,guidKey,pguidValue) (This)->lpVtbl->GetGUID(This,guidKey,pguidValue)
#define IMFMediaEvent_GetStringLength(This,guidKey,pcchLength) (This)->lpVtbl->GetStringLength(This,guidKey,pcchLength)
#define IMFMediaEvent_GetString(This,guidKey,pwszValue,cchBufSize,pcchLength) (This)->lpVtbl->GetString(This,guidKey,pwszValue,cchBufSize,pcchLength)
#define IMFMediaEvent_GetAllocatedString(This,guidKey,ppwszValue,pcchLength) (This)->lpVtbl->GetAllocatedString(This,guidKey,ppwszValue,pcchLength)
#define IMFMediaEvent_GetBlobSize(This,guidKey,pcbBlobSize) (This)->lpVtbl->GetBlobSize(This,guidKey,pcbBlobSize)
#define IMFMediaEvent_GetBlob(This,guidKey,pBuf,cbBufSize,pcbBlobSize) (This)->lpVtbl->GetBlob(This,guidKey,pBuf,cbBufSize,pcbBlobSize)
#define IMFMediaEvent_GetAllocatedBlob(This,guidKey,ppBuf,pcbSize) (This)->lpVtbl->GetAllocatedBlob(This,guidKey,ppBuf,pcbSize)
#define IMFMediaEvent_GetUnknown(This,guidKey,riid,ppv) (This)->lpVtbl->GetUnknown(This,guidKey,riid,ppv)
#define IMFMediaEvent_SetItem(This,guidKey,Value) (This)->lpVtbl->SetItem(This,guidKey,Value)
#define IMFMediaEvent_DeleteItem(This,guidKey) (This)->lpVtbl->DeleteItem(This,guidKey)
#define IMFMediaEvent_DeleteAllItems(This) (This)->lpVtbl->DeleteAllItems(This)
#define IMFMediaEvent_SetUINT32(This,guidKey,unValue) (This)->lpVtbl->SetUINT32(This,guidKey,unValue)
#define IMFMediaEvent_SetUINT64(This,guidKey,unValue) (This)->lpVtbl->SetUINT64(This,guidKey,unValue)
#define IMFMediaEvent_SetDouble(This,guidKey,fValue) (This)->lpVtbl->SetDouble(This,guidKey,fValue)
#define IMFMediaEvent_SetGUID(This,guidKey,guidValue) (This)->lpVtbl->SetGUID(This,guidKey,guidValue)
#define IMFMediaEvent_SetString(This,guidKey,wszValue) (This)->lpVtbl->SetString(This,guidKey,wszValue)
#define IMFMediaEvent_SetBlob(This,guidKey,pBuf,cbBufSize) (This)->lpVtbl->SetBlob(This,guidKey,pBuf,cbBufSize)
#define IMFMediaEvent_SetUnknown(This,guidKey,pUnknown) (This)->lpVtbl->SetUnknown(This,guidKey,pUnknown)
#define IMFMediaEvent_LockStore(This) (This)->lpVtbl->LockStore(This)
#define IMFMediaEvent_UnlockStore(This) (This)->lpVtbl->UnlockStore(This)
#define IMFMediaEvent_GetCount(This,pcItems) (This)->lpVtbl->GetCount(This,pcItems)
#define IMFMediaEvent_GetItemByIndex(This,unIndex,pguidKey,pValue) (This)->lpVtbl->GetItemByIndex(This,unIndex,pguidKey,pValue)
#define IMFMediaEvent_CopyAllItems(This,pDest) (This)->lpVtbl->CopyAllItems(This,pDest)
/*** IMFMediaEvent methods ***/
#define IMFMediaEvent_GetType(This,pmet) (This)->lpVtbl->GetType(This,pmet)
#define IMFMediaEvent_GetExtendedType(This,pguidExtendedType) (This)->lpVtbl->GetExtendedType(This,pguidExtendedType)
#define IMFMediaEvent_GetStatus(This,phrStatus) (This)->lpVtbl->GetStatus(This,phrStatus)
#define IMFMediaEvent_GetValue(This,pvValue) (This)->lpVtbl->GetValue(This,pvValue)
#else
/*** IUnknown methods ***/
static FORCEINLINE HRESULT IMFMediaEvent_QueryInterface(IMFMediaEvent* This,REFIID riid,void **ppvObject) {
    return This->lpVtbl->QueryInterface(This,riid,ppvObject);
}
static FORCEINLINE ULONG IMFMediaEvent_AddRef(IMFMediaEvent* This) {
    return This->lpVtbl->AddRef(This);
}
static FORCEINLINE ULONG IMFMediaEvent_Release(IMFMediaEvent* This) {
    return This->lpVtbl->Release(This);
}
/*** IMFAttributes methods ***/
static FORCEINLINE HRESULT IMFMediaEvent_GetItem(IMFMediaEvent* This,REFGUID guidKey,PROPVARIANT *pValue) {
    return This->lpVtbl->GetItem(This,guidKey,pValue);
}
static FORCEINLINE HRESULT IMFMediaEvent_GetItemType(IMFMediaEvent* This,REFGUID guidKey,MF_ATTRIBUTE_TYPE *pType) {
    return This->lpVtbl->GetItemType(This,guidKey,pType);
}
static FORCEINLINE HRESULT IMFMediaEvent_CompareItem(IMFMediaEvent* This,REFGUID guidKey,REFPROPVARIANT Value,WINBOOL *pbResult) {
    return This->lpVtbl->CompareItem(This,guidKey,Value,pbResult);
}
static FORCEINLINE HRESULT IMFMediaEvent_Compare(IMFMediaEvent* This,IMFAttributes *pTheirs,MF_ATTRIBUTES_MATCH_TYPE MatchType,WINBOOL *pbResult) {
    return This->lpVtbl->Compare(This,pTheirs,MatchType,pbResult);
}
static FORCEINLINE HRESULT IMFMediaEvent_GetUINT32(IMFMediaEvent* This,REFGUID guidKey,UINT32 *punValue) {
    return This->lpVtbl->GetUINT32(This,guidKey,punValue);
}
static FORCEINLINE HRESULT IMFMediaEvent_GetUINT64(IMFMediaEvent* This,REFGUID guidKey,UINT64 *punValue) {
    return This->lpVtbl->GetUINT64(This,guidKey,punValue);
}
static FORCEINLINE HRESULT IMFMediaEvent_GetDouble(IMFMediaEvent* This,REFGUID guidKey,double *pfValue) {
    return This->lpVtbl->GetDouble(This,guidKey,pfValue);
}
static FORCEINLINE HRESULT IMFMediaEvent_GetGUID(IMFMediaEvent* This,REFGUID guidKey,GUID *pguidValue) {
    return This->lpVtbl->GetGUID(This,guidKey,pguidValue);
}
static FORCEINLINE HRESULT IMFMediaEvent_GetStringLength(IMFMediaEvent* This,REFGUID guidKey,UINT32 *pcchLength) {
    return This->lpVtbl->GetStringLength(This,guidKey,pcchLength);
}
static FORCEINLINE HRESULT IMFMediaEvent_GetString(IMFMediaEvent* This,REFGUID guidKey,LPWSTR pwszValue,UINT32 cchBufSize,UINT32 *pcchLength) {
    return This->lpVtbl->GetString(This,guidKey,pwszValue,cchBufSize,pcchLength);
}
static FORCEINLINE HRESULT IMFMediaEvent_GetAllocatedString(IMFMediaEvent* This,REFGUID guidKey,LPWSTR *ppwszValue,UINT32 *pcchLength) {
    return This->lpVtbl->GetAllocatedString(This,guidKey,ppwszValue,pcchLength);
}
static FORCEINLINE HRESULT IMFMediaEvent_GetBlobSize(IMFMediaEvent* This,REFGUID guidKey,UINT32 *pcbBlobSize) {
    return This->lpVtbl->GetBlobSize(This,guidKey,pcbBlobSize);
}
static FORCEINLINE HRESULT IMFMediaEvent_GetBlob(IMFMediaEvent* This,REFGUID guidKey,UINT8 *pBuf,UINT32 cbBufSize,UINT32 *pcbBlobSize) {
    return This->lpVtbl->GetBlob(This,guidKey,pBuf,cbBufSize,pcbBlobSize);
}
static FORCEINLINE HRESULT IMFMediaEvent_GetAllocatedBlob(IMFMediaEvent* This,REFGUID guidKey,UINT8 **ppBuf,UINT32 *pcbSize) {
    return This->lpVtbl->GetAllocatedBlob(This,guidKey,ppBuf,pcbSize);
}
static FORCEINLINE HRESULT IMFMediaEvent_GetUnknown(IMFMediaEvent* This,REFGUID guidKey,REFIID riid,LPVOID *ppv) {
    return This->lpVtbl->GetUnknown(This,guidKey,riid,ppv);
}
static FORCEINLINE HRESULT IMFMediaEvent_SetItem(IMFMediaEvent* This,REFGUID guidKey,REFPROPVARIANT Value) {
    return This->lpVtbl->SetItem(This,guidKey,Value);
}
static FORCEINLINE HRESULT IMFMediaEvent_DeleteItem(IMFMediaEvent* This,REFGUID guidKey) {
    return This->lpVtbl->DeleteItem(This,guidKey);
}
static FORCEINLINE HRESULT IMFMediaEvent_DeleteAllItems(IMFMediaEvent* This) {
    return This->lpVtbl->DeleteAllItems(This);
}
static FORCEINLINE HRESULT IMFMediaEvent_SetUINT32(IMFMediaEvent* This,REFGUID guidKey,UINT32 unValue) {
    return This->lpVtbl->SetUINT32(This,guidKey,unValue);
}
static FORCEINLINE HRESULT IMFMediaEvent_SetUINT64(IMFMediaEvent* This,REFGUID guidKey,UINT64 unValue) {
    return This->lpVtbl->SetUINT64(This,guidKey,unValue);
}
static FORCEINLINE HRESULT IMFMediaEvent_SetDouble(IMFMediaEvent* This,REFGUID guidKey,double fValue) {
    return This->lpVtbl->SetDouble(This,guidKey,fValue);
}
static FORCEINLINE HRESULT IMFMediaEvent_SetGUID(IMFMediaEvent* This,REFGUID guidKey,REFGUID guidValue) {
    return This->lpVtbl->SetGUID(This,guidKey,guidValue);
}
static FORCEINLINE HRESULT IMFMediaEvent_SetString(IMFMediaEvent* This,REFGUID guidKey,LPCWSTR wszValue) {
    return This->lpVtbl->SetString(This,guidKey,wszValue);
}
static FORCEINLINE HRESULT IMFMediaEvent_SetBlob(IMFMediaEvent* This,REFGUID guidKey,const UINT8 *pBuf,UINT32 cbBufSize) {
    return This->lpVtbl->SetBlob(This,guidKey,pBuf,cbBufSize);
}
static FORCEINLINE HRESULT IMFMediaEvent_SetUnknown(IMFMediaEvent* This,REFGUID guidKey,IUnknown *pUnknown) {
    return This->lpVtbl->SetUnknown(This,guidKey,pUnknown);
}
static FORCEINLINE HRESULT IMFMediaEvent_LockStore(IMFMediaEvent* This) {
    return This->lpVtbl->LockStore(This);
}
static FORCEINLINE HRESULT IMFMediaEvent_UnlockStore(IMFMediaEvent* This) {
    return This->lpVtbl->UnlockStore(This);
}
static FORCEINLINE HRESULT IMFMediaEvent_GetCount(IMFMediaEvent* This,UINT32 *pcItems) {
    return This->lpVtbl->GetCount(This,pcItems);
}
static FORCEINLINE HRESULT IMFMediaEvent_GetItemByIndex(IMFMediaEvent* This,UINT32 unIndex,GUID *pguidKey,PROPVARIANT *pValue) {
    return This->lpVtbl->GetItemByIndex(This,unIndex,pguidKey,pValue);
}
static FORCEINLINE HRESULT IMFMediaEvent_CopyAllItems(IMFMediaEvent* This,IMFAttributes *pDest) {
    return This->lpVtbl->CopyAllItems(This,pDest);
}
/*** IMFMediaEvent methods ***/
static FORCEINLINE HRESULT IMFMediaEvent_GetType(IMFMediaEvent* This,MediaEventType *pmet) {
    return This->lpVtbl->GetType(This,pmet);
}
static FORCEINLINE HRESULT IMFMediaEvent_GetExtendedType(IMFMediaEvent* This,GUID *pguidExtendedType) {
    return This->lpVtbl->GetExtendedType(This,pguidExtendedType);
}
static FORCEINLINE HRESULT IMFMediaEvent_GetStatus(IMFMediaEvent* This,HRESULT *phrStatus) {
    return This->lpVtbl->GetStatus(This,phrStatus);
}
static FORCEINLINE HRESULT IMFMediaEvent_GetValue(IMFMediaEvent* This,PROPVARIANT *pvValue) {
    return This->lpVtbl->GetValue(This,pvValue);
}
#endif
#endif

#endif

HRESULT STDMETHODCALLTYPE IMFMediaEvent_GetType_Proxy(
    IMFMediaEvent* This,
    MediaEventType *pmet);
void __RPC_STUB IMFMediaEvent_GetType_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFMediaEvent_GetExtendedType_Proxy(
    IMFMediaEvent* This,
    GUID *pguidExtendedType);
void __RPC_STUB IMFMediaEvent_GetExtendedType_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFMediaEvent_GetStatus_Proxy(
    IMFMediaEvent* This,
    HRESULT *phrStatus);
void __RPC_STUB IMFMediaEvent_GetStatus_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFMediaEvent_GetValue_Proxy(
    IMFMediaEvent* This,
    PROPVARIANT *pvValue);
void __RPC_STUB IMFMediaEvent_GetValue_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IMFMediaEvent_INTERFACE_DEFINED__ */


#define MF_EVENT_FLAG_NO_WAIT 0x00000001

#ifndef __IMFRemoteAsyncCallback_FWD_DEFINED__
#define __IMFRemoteAsyncCallback_FWD_DEFINED__
typedef interface IMFRemoteAsyncCallback IMFRemoteAsyncCallback;
#endif


/*****************************************************************************
 * IMFMediaEventGenerator interface
 */
#ifndef __IMFMediaEventGenerator_INTERFACE_DEFINED__
#define __IMFMediaEventGenerator_INTERFACE_DEFINED__

DEFINE_GUID(IID_IMFMediaEventGenerator, 0x2cd0bd52, 0xbcd5, 0x4b89, 0xb6,0x2c, 0xea,0xdc,0x0c,0x03,0x1e,0x7d);
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("2cd0bd52-bcd5-4b89-b62c-eadc0c031e7d")
IMFMediaEventGenerator : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE GetEvent(
        DWORD dwFlags,
        IMFMediaEvent **ppEvent) = 0;

    virtual HRESULT STDMETHODCALLTYPE BeginGetEvent(
        IMFAsyncCallback *pCallback,
        IUnknown *punkState) = 0;

    virtual HRESULT STDMETHODCALLTYPE EndGetEvent(
        IMFAsyncResult *pResult,
        IMFMediaEvent **ppEvent) = 0;

    virtual HRESULT STDMETHODCALLTYPE QueueEvent(
        MediaEventType met,
        REFGUID guidExtendedType,
        HRESULT hrStatus,
        const PROPVARIANT *pvValue) = 0;

};
#ifdef __CRT_UUID_DECL
__CRT_UUID_DECL(IMFMediaEventGenerator, 0x2cd0bd52, 0xbcd5, 0x4b89, 0xb6,0x2c, 0xea,0xdc,0x0c,0x03,0x1e,0x7d)
#endif
#else
typedef struct IMFMediaEventGeneratorVtbl {
    BEGIN_INTERFACE

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

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

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

    /*** IMFMediaEventGenerator methods ***/
    HRESULT (STDMETHODCALLTYPE *GetEvent)(
        IMFMediaEventGenerator* This,
        DWORD dwFlags,
        IMFMediaEvent **ppEvent);

    HRESULT (STDMETHODCALLTYPE *BeginGetEvent)(
        IMFMediaEventGenerator* This,
        IMFAsyncCallback *pCallback,
        IUnknown *punkState);

    HRESULT (STDMETHODCALLTYPE *EndGetEvent)(
        IMFMediaEventGenerator* This,
        IMFAsyncResult *pResult,
        IMFMediaEvent **ppEvent);

    HRESULT (STDMETHODCALLTYPE *QueueEvent)(
        IMFMediaEventGenerator* This,
        MediaEventType met,
        REFGUID guidExtendedType,
        HRESULT hrStatus,
        const PROPVARIANT *pvValue);

    END_INTERFACE
} IMFMediaEventGeneratorVtbl;
interface IMFMediaEventGenerator {
    CONST_VTBL IMFMediaEventGeneratorVtbl* lpVtbl;
};

#ifdef COBJMACROS
#ifndef WIDL_C_INLINE_WRAPPERS
/*** IUnknown methods ***/
#define IMFMediaEventGenerator_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
#define IMFMediaEventGenerator_AddRef(This) (This)->lpVtbl->AddRef(This)
#define IMFMediaEventGenerator_Release(This) (This)->lpVtbl->Release(This)
/*** IMFMediaEventGenerator methods ***/
#define IMFMediaEventGenerator_GetEvent(This,dwFlags,ppEvent) (This)->lpVtbl->GetEvent(This,dwFlags,ppEvent)
#define IMFMediaEventGenerator_BeginGetEvent(This,pCallback,punkState) (This)->lpVtbl->BeginGetEvent(This,pCallback,punkState)
#define IMFMediaEventGenerator_EndGetEvent(This,pResult,ppEvent) (This)->lpVtbl->EndGetEvent(This,pResult,ppEvent)
#define IMFMediaEventGenerator_QueueEvent(This,met,guidExtendedType,hrStatus,pvValue) (This)->lpVtbl->QueueEvent(This,met,guidExtendedType,hrStatus,pvValue)
#else
/*** IUnknown methods ***/
static FORCEINLINE HRESULT IMFMediaEventGenerator_QueryInterface(IMFMediaEventGenerator* This,REFIID riid,void **ppvObject) {
    return This->lpVtbl->QueryInterface(This,riid,ppvObject);
}
static FORCEINLINE ULONG IMFMediaEventGenerator_AddRef(IMFMediaEventGenerator* This) {
    return This->lpVtbl->AddRef(This);
}
static FORCEINLINE ULONG IMFMediaEventGenerator_Release(IMFMediaEventGenerator* This) {
    return This->lpVtbl->Release(This);
}
/*** IMFMediaEventGenerator methods ***/
static FORCEINLINE HRESULT IMFMediaEventGenerator_GetEvent(IMFMediaEventGenerator* This,DWORD dwFlags,IMFMediaEvent **ppEvent) {
    return This->lpVtbl->GetEvent(This,dwFlags,ppEvent);
}
static FORCEINLINE HRESULT IMFMediaEventGenerator_BeginGetEvent(IMFMediaEventGenerator* This,IMFAsyncCallback *pCallback,IUnknown *punkState) {
    return This->lpVtbl->BeginGetEvent(This,pCallback,punkState);
}
static FORCEINLINE HRESULT IMFMediaEventGenerator_EndGetEvent(IMFMediaEventGenerator* This,IMFAsyncResult *pResult,IMFMediaEvent **ppEvent) {
    return This->lpVtbl->EndGetEvent(This,pResult,ppEvent);
}
static FORCEINLINE HRESULT IMFMediaEventGenerator_QueueEvent(IMFMediaEventGenerator* This,MediaEventType met,REFGUID guidExtendedType,HRESULT hrStatus,const PROPVARIANT *pvValue) {
    return This->lpVtbl->QueueEvent(This,met,guidExtendedType,hrStatus,pvValue);
}
#endif
#endif

#endif

HRESULT STDMETHODCALLTYPE IMFMediaEventGenerator_GetEvent_Proxy(
    IMFMediaEventGenerator* This,
    DWORD dwFlags,
    IMFMediaEvent **ppEvent);
void __RPC_STUB IMFMediaEventGenerator_GetEvent_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFMediaEventGenerator_RemoteBeginGetEvent_Proxy(
    IMFMediaEventGenerator* This,
    IMFRemoteAsyncCallback *pCallback);
void __RPC_STUB IMFMediaEventGenerator_RemoteBeginGetEvent_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFMediaEventGenerator_RemoteEndGetEvent_Proxy(
    IMFMediaEventGenerator* This,
    IUnknown *pResult,
    DWORD *pcbEvent,
    BYTE **ppbEvent);
void __RPC_STUB IMFMediaEventGenerator_RemoteEndGetEvent_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFMediaEventGenerator_QueueEvent_Proxy(
    IMFMediaEventGenerator* This,
    MediaEventType met,
    REFGUID guidExtendedType,
    HRESULT hrStatus,
    const PROPVARIANT *pvValue);
void __RPC_STUB IMFMediaEventGenerator_QueueEvent_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMFMediaEventGenerator_BeginGetEvent_Proxy(
    IMFMediaEventGenerator* This,
    IMFAsyncCallback *pCallback,
    IUnknown *punkState);
HRESULT __RPC_STUB IMFMediaEventGenerator_BeginGetEvent_Stub(
    IMFMediaEventGenerator* This,
    IMFRemoteAsyncCallback *pCallback);
HRESULT CALLBACK IMFMediaEventGenerator_EndGetEvent_Proxy(
    IMFMediaEventGenerator* This,
    IMFAsyncResult *pResult,
    IMFMediaEvent **ppEvent);
HRESULT __RPC_STUB IMFMediaEventGenerator_EndGetEvent_Stub(
    IMFMediaEventGenerator* This,
    IUnknown *pResult,
    DWORD *pcbEvent,
    BYTE **ppbEvent);

#endif  /* __IMFMediaEventGenerator_INTERFACE_DEFINED__ */

#endif

#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
/*****************************************************************************
 * IMFRemoteAsyncCallback interface
 */
#ifndef __IMFRemoteAsyncCallback_INTERFACE_DEFINED__
#define __IMFRemoteAsyncCallback_INTERFACE_DEFINED__

DEFINE_GUID(IID_IMFRemoteAsyncCallback, 0xa27003d0, 0x2354, 0x4f2a, 0x8d,0x6a, 0xab,0x7c,0xff,0x15,0x43,0x7e);
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("a27003d0-2354-4f2a-8d6a-ab7cff15437e")
IMFRemoteAsyncCallback : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE Invoke(
        HRESULT hr,
        IUnknown *pRemoteResult) = 0;

};
#ifdef __CRT_UUID_DECL
__CRT_UUID_DECL(IMFRemoteAsyncCallback, 0xa27003d0, 0x2354, 0x4f2a, 0x8d,0x6a, 0xab,0x7c,0xff,0x15,0x43,0x7e)
#endif
#else
typedef struct IMFRemoteAsyncCallbackVtbl {
    BEGIN_INTERFACE

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

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

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

    /*** IMFRemoteAsyncCallback methods ***/
    HRESULT (STDMETHODCALLTYPE *Invoke)(
        IMFRemoteAsyncCallback* This,
        HRESULT hr,
        IUnknown *pRemoteResult);

    END_INTERFACE
} IMFRemoteAsyncCallbackVtbl;
interface IMFRemoteAsyncCallback {
    CONST_VTBL IMFRemoteAsyncCallbackVtbl* lpVtbl;
};

#ifdef COBJMACROS
#ifndef WIDL_C_INLINE_WRAPPERS
/*** IUnknown methods ***/
#define IMFRemoteAsyncCallback_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
#define IMFRemoteAsyncCallback_AddRef(This) (This)->lpVtbl->AddRef(This)
#define IMFRemoteAsyncCallback_Release(This) (This)->lpVtbl->Release(This)
/*** IMFRemoteAsyncCallback methods ***/
#define IMFRemoteAsyncCallback_Invoke(This,hr,pRemoteResult) (This)->lpVtbl->Invoke(This,hr,pRemoteResult)
#else
/*** IUnknown methods ***/
static FORCEINLINE HRESULT IMFRemoteAsyncCallback_QueryInterface(IMFRemoteAsyncCallback* This,REFIID riid,void **ppvObject) {
    return This->lpVtbl->QueryInterface(This,riid,ppvObject);
}
static FORCEINLINE ULONG IMFRemoteAsyncCallback_AddRef(IMFRemoteAsyncCallback* This) {
    return This->lpVtbl->AddRef(This);
}
static FORCEINLINE ULONG IMFRemoteAsyncCallback_Release(IMFRemoteAsyncCallback* This) {
    return This->lpVtbl->Release(This);
}
/*** IMFRemoteAsyncCallback methods ***/
static FORCEINLINE HRESULT IMFRemoteAsyncCallback_Invoke(IMFRemoteAsyncCallback* This,HRESULT hr,IUnknown *pRemoteResult) {
    return This->lpVtbl->Invoke(This,hr,pRemoteResult);
}
#endif
#endif

#endif

HRESULT STDMETHODCALLTYPE IMFRemoteAsyncCallback_Invoke_Proxy(
    IMFRemoteAsyncCallback* This,
    HRESULT hr,
    IUnknown *pRemoteResult);
void __RPC_STUB IMFRemoteAsyncCallback_Invoke_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IMFRemoteAsyncCallback_INTERFACE_DEFINED__ */

#endif

#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)

typedef enum _MFBYTESTREAM_SEEK_ORIGIN {
    msoBegin = 0,
    msoCurrent = 1
} MFBYTESTREAM_SEEK_ORIGIN;

/*****************************************************************************
 * IMFByteStream interface
 */
#ifndef __IMFByteStream_INTERFACE_DEFINED__
#define __IMFByteStream_INTERFACE_DEFINED__

DEFINE_GUID(IID_IMFByteStream, 0xad4c1b00, 0x4bf7, 0x422f, 0x91,0x75, 0x75,0x66,0x93,0xd9,0x13,0x0d);
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("ad4c1b00-4bf7-422f-9175-756693d9130d")
IMFByteStream : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE GetCapabilities(
        DWORD *pdwCapabilities) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetLength(
        QWORD *pqwLength) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetLength(
        QWORD qwLength) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetCurrentPosition(
        QWORD *pqwPosition) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetCurrentPosition(
        QWORD qwPosition) = 0;

    virtual HRESULT STDMETHODCALLTYPE IsEndOfStream(
        WINBOOL *pfEndOfStream) = 0;

    virtual HRESULT STDMETHODCALLTYPE Read(
        BYTE *pb,
        ULONG cb,
        ULONG *pcbRead) = 0;

    virtual HRESULT STDMETHODCALLTYPE BeginRead(
        BYTE *pb,
        ULONG cb,
        IMFAsyncCallback *pCallback,
        IUnknown *punkState) = 0;

    virtual HRESULT STDMETHODCALLTYPE EndRead(
        IMFAsyncResult *pResult,
        ULONG *pcbRead) = 0;

    virtual HRESULT STDMETHODCALLTYPE Write(
        const BYTE *pb,
        ULONG cb,
        ULONG *pcbWritten) = 0;

    virtual HRESULT STDMETHODCALLTYPE BeginWrite(
        const BYTE *pb,
        ULONG cb,
        IMFAsyncCallback *pCallback,
        IUnknown *punkState) = 0;

    virtual HRESULT STDMETHODCALLTYPE EndWrite(
        IMFAsyncResult *pResult,
        ULONG *pcbWritten) = 0;

    virtual HRESULT STDMETHODCALLTYPE Seek(
        MFBYTESTREAM_SEEK_ORIGIN SeekOrigin,
        LONGLONG llSeekOffset,
        DWORD dwSeekFlags,
        QWORD *pqwCurrentPosition) = 0;

    virtual HRESULT STDMETHODCALLTYPE Flush(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE Close(
        ) = 0;

};
#ifdef __CRT_UUID_DECL
__CRT_UUID_DECL(IMFByteStream, 0xad4c1b00, 0x4bf7, 0x422f, 0x91,0x75, 0x75,0x66,0x93,0xd9,0x13,0x0d)
#endif
#else
typedef struct IMFByteStreamVtbl {
    BEGIN_INTERFACE

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

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

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

    /*** IMFByteStream methods ***/
    HRESULT (STDMETHODCALLTYPE *GetCapabilities)(
        IMFByteStream* This,
        DWORD *pdwCapabilities);

    HRESULT (STDMETHODCALLTYPE *GetLength)(
        IMFByteStream* This,
        QWORD *pqwLength);

    HRESULT (STDMETHODCALLTYPE *SetLength)(
        IMFByteStream* This,
        QWORD qwLength);

    HRESULT (STDMETHODCALLTYPE *GetCurrentPosition)(
        IMFByteStream* This,
        QWORD *pqwPosition);

    HRESULT (STDMETHODCALLTYPE *SetCurrentPosition)(
        IMFByteStream* This,
        QWORD qwPosition);

    HRESULT (STDMETHODCALLTYPE *IsEndOfStream)(
        IMFByteStream* This,
        WINBOOL *pfEndOfStream);

    HRESULT (STDMETHODCALLTYPE *Read)(
        IMFByteStream* This,
        BYTE *pb,
        ULONG cb,
        ULONG *pcbRead);

    HRESULT (STDMETHODCALLTYPE *BeginRead)(
        IMFByteStream* This,
        BYTE *pb,
        ULONG cb,
        IMFAsyncCallback *pCallback,
        IUnknown *punkState);

    HRESULT (STDMETHODCALLTYPE *EndRead)(
        IMFByteStream* This,
        IMFAsyncResult *pResult,
        ULONG *pcbRead);

    HRESULT (STDMETHODCALLTYPE *Write)(
        IMFByteStream* This,
        const BYTE *pb,
        ULONG cb,
        ULONG *pcbWritten);

    HRESULT (STDMETHODCALLTYPE *BeginWrite)(
        IMFByteStream* This,
        const BYTE *pb,
        ULONG cb,
        IMFAsyncCallback *pCallback,
        IUnknown *punkState);

    HRESULT (STDMETHODCALLTYPE *EndWrite)(
        IMFByteStream* This,
        IMFAsyncResult *pResult,
        ULONG *pcbWritten);

    HRESULT (STDMETHODCALLTYPE *Seek)(
        IMFByteStream* This,
        MFBYTESTREAM_SEEK_ORIGIN SeekOrigin,
        LONGLONG llSeekOffset,
        DWORD dwSeekFlags,
        QWORD *pqwCurrentPosition);

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

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

    END_INTERFACE
} IMFByteStreamVtbl;
interface IMFByteStream {
    CONST_VTBL IMFByteStreamVtbl* lpVtbl;
};

#ifdef COBJMACROS
#ifndef WIDL_C_INLINE_WRAPPERS
/*** IUnknown methods ***/
#define IMFByteStream_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
#define IMFByteStream_AddRef(This) (This)->lpVtbl->AddRef(This)
#define IMFByteStream_Release(This) (This)->lpVtbl->Release(This)
/*** IMFByteStream methods ***/
#define IMFByteStream_GetCapabilities(This,pdwCapabilities) (This)->lpVtbl->GetCapabilities(This,pdwCapabilities)
#define IMFByteStream_GetLength(This,pqwLength) (This)->lpVtbl->GetLength(This,pqwLength)
#define IMFByteStream_SetLength(This,qwLength) (This)->lpVtbl->SetLength(This,qwLength)
#define IMFByteStream_GetCurrentPosition(This,pqwPosition) (This)->lpVtbl->GetCurrentPosition(This,pqwPosition)
#define IMFByteStream_SetCurrentPosition(This,qwPosition) (This)->lpVtbl->SetCurrentPosition(This,qwPosition)
#define IMFByteStream_IsEndOfStream(This,pfEndOfStream) (This)->lpVtbl->IsEndOfStream(This,pfEndOfStream)
#define IMFByteStream_Read(This,pb,cb,pcbRead) (This)->lpVtbl->Read(This,pb,cb,pcbRead)
#define IMFByteStream_BeginRead(This,pb,cb,pCallback,punkState) (This)->lpVtbl->BeginRead(This,pb,cb,pCallback,punkState)
#define IMFByteStream_EndRead(This,pResult,pcbRead) (This)->lpVtbl->EndRead(This,pResult,pcbRead)
#define IMFByteStream_Write(This,pb,cb,pcbWritten) (This)->lpVtbl->Write(This,pb,cb,pcbWritten)
#define IMFByteStream_BeginWrite(This,pb,cb,pCallback,punkState) (This)->lpVtbl->BeginWrite(This,pb,cb,pCallback,punkState)
#define IMFByteStream_EndWrite(This,pResult,pcbWritten) (This)->lpVtbl->EndWrite(This,pResult,pcbWritten)
#define IMFByteStream_Seek(This,SeekOrigin,llSeekOffset,dwSeekFlags,pqwCurrentPosition) (This)->lpVtbl->Seek(This,SeekOrigin,llSeekOffset,dwSeekFlags,pqwCurrentPosition)
#define IMFByteStream_Flush(This) (This)->lpVtbl->Flush(This)
#define IMFByteStream_Close(This) (This)->lpVtbl->Close(This)
#else
/*** IUnknown methods ***/
static FORCEINLINE HRESULT IMFByteStream_QueryInterface(IMFByteStream* This,REFIID riid,void **ppvObject) {
    return This->lpVtbl->QueryInterface(This,riid,ppvObject);
}
static FORCEINLINE ULONG IMFByteStream_AddRef(IMFByteStream* This) {
    return This->lpVtbl->AddRef(This);
}
static FORCEINLINE ULONG IMFByteStream_Release(IMFByteStream* This) {
    return This->lpVtbl->Release(This);
}
/*** IMFByteStream methods ***/
static FORCEINLINE HRESULT IMFByteStream_GetCapabilities(IMFByteStream* This,DWORD *pdwCapabilities) {
    return This->lpVtbl->GetCapabilities(This,pdwCapabilities);
}
static FORCEINLINE HRESULT IMFByteStream_GetLength(IMFByteStream* This,QWORD *pqwLength) {
    return This->lpVtbl->GetLength(This,pqwLength);
}
static FORCEINLINE HRESULT IMFByteStream_SetLength(IMFByteStream* This,QWORD qwLength) {
    return This->lpVtbl->SetLength(This,qwLength);
}
static FORCEINLINE HRESULT IMFByteStream_GetCurrentPosition(IMFByteStream* This,QWORD *pqwPosition) {
    return This->lpVtbl->GetCurrentPosition(This,pqwPosition);
}
static FORCEINLINE HRESULT IMFByteStream_SetCurrentPosition(IMFByteStream* This,QWORD qwPosition) {
    return This->lpVtbl->SetCurrentPosition(This,qwPosition);
}
static FORCEINLINE HRESULT IMFByteStream_IsEndOfStream(IMFByteStream* This,WINBOOL *pfEndOfStream) {
    return This->lpVtbl->IsEndOfStream(This,pfEndOfStream);
}
static FORCEINLINE HRESULT IMFByteStream_Read(IMFByteStream* This,BYTE *pb,ULONG cb,ULONG *pcbRead) {
    return This->lpVtbl->Read(This,pb,cb,pcbRead);
}
static FORCEINLINE HRESULT IMFByteStream_BeginRead(IMFByteStream* This,BYTE *pb,ULONG cb,IMFAsyncCallback *pCallback,IUnknown *punkState) {
    return This->lpVtbl->BeginRead(This,pb,cb,pCallback,punkState);
}
static FORCEINLINE HRESULT IMFByteStream_EndRead(IMFByteStream* This,IMFAsyncResult *pResult,ULONG *pcbRead) {
    return This->lpVtbl->EndRead(This,pResult,pcbRead);
}
static FORCEINLINE HRESULT IMFByteStream_Write(IMFByteStream* This,const BYTE *pb,ULONG cb,ULONG *pcbWritten) {
    return This->lpVtbl->Write(This,pb,cb,pcbWritten);
}
static FORCEINLINE HRESULT IMFByteStream_BeginWrite(IMFByteStream* This,const BYTE *pb,ULONG cb,IMFAsyncCallback *pCallback,IUnknown *punkState) {
    return This->lpVtbl->BeginWrite(This,pb,cb,pCallback,punkState);
}
static FORCEINLINE HRESULT IMFByteStream_EndWrite(IMFByteStream* This,IMFAsyncResult *pResult,ULONG *pcbWritten) {
    return This->lpVtbl->EndWrite(This,pResult,pcbWritten);
}
static FORCEINLINE HRESULT IMFByteStream_Seek(IMFByteStream* This,MFBYTESTREAM_SEEK_ORIGIN SeekOrigin,LONGLONG llSeekOffset,DWORD dwSeekFlags,QWORD *pqwCurrentPosition) {
    return This->lpVtbl->Seek(This,SeekOrigin,llSeekOffset,dwSeekFlags,pqwCurrentPosition);
}
static FORCEINLINE HRESULT IMFByteStream_Flush(IMFByteStream* This) {
    return This->lpVtbl->Flush(This);
}
static FORCEINLINE HRESULT IMFByteStream_Close(IMFByteStream* This) {
    return This->lpVtbl->Close(This);
}
#endif
#endif

#endif

HRESULT STDMETHODCALLTYPE IMFByteStream_GetCapabilities_Proxy(
    IMFByteStream* This,
    DWORD *pdwCapabilities);
void __RPC_STUB IMFByteStream_GetCapabilities_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFByteStream_GetLength_Proxy(
    IMFByteStream* This,
    QWORD *pqwLength);
void __RPC_STUB IMFByteStream_GetLength_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFByteStream_SetLength_Proxy(
    IMFByteStream* This,
    QWORD qwLength);
void __RPC_STUB IMFByteStream_SetLength_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFByteStream_GetCurrentPosition_Proxy(
    IMFByteStream* This,
    QWORD *pqwPosition);
void __RPC_STUB IMFByteStream_GetCurrentPosition_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFByteStream_SetCurrentPosition_Proxy(
    IMFByteStream* This,
    QWORD qwPosition);
void __RPC_STUB IMFByteStream_SetCurrentPosition_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFByteStream_IsEndOfStream_Proxy(
    IMFByteStream* This,
    WINBOOL *pfEndOfStream);
void __RPC_STUB IMFByteStream_IsEndOfStream_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFByteStream_Read_Proxy(
    IMFByteStream* This,
    BYTE *pb,
    ULONG cb,
    ULONG *pcbRead);
void __RPC_STUB IMFByteStream_Read_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFByteStream_RemoteBeginRead_Proxy(
    IMFByteStream* This,
    ULONG cb,
    IMFRemoteAsyncCallback *pCallback);
void __RPC_STUB IMFByteStream_RemoteBeginRead_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFByteStream_RemoteEndRead_Proxy(
    IMFByteStream* This,
    IUnknown *punkResult,
    BYTE *pb,
    ULONG cb,
    ULONG *pcbRead);
void __RPC_STUB IMFByteStream_RemoteEndRead_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFByteStream_Write_Proxy(
    IMFByteStream* This,
    const BYTE *pb,
    ULONG cb,
    ULONG *pcbWritten);
void __RPC_STUB IMFByteStream_Write_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFByteStream_RemoteBeginWrite_Proxy(
    IMFByteStream* This,
    const BYTE *pb,
    ULONG cb,
    IMFRemoteAsyncCallback *pCallback);
void __RPC_STUB IMFByteStream_RemoteBeginWrite_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFByteStream_RemoteEndWrite_Proxy(
    IMFByteStream* This,
    IUnknown *punkResult,
    ULONG *pcbWritten);
void __RPC_STUB IMFByteStream_RemoteEndWrite_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFByteStream_Seek_Proxy(
    IMFByteStream* This,
    MFBYTESTREAM_SEEK_ORIGIN SeekOrigin,
    LONGLONG llSeekOffset,
    DWORD dwSeekFlags,
    QWORD *pqwCurrentPosition);
void __RPC_STUB IMFByteStream_Seek_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFByteStream_Flush_Proxy(
    IMFByteStream* This);
void __RPC_STUB IMFByteStream_Flush_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFByteStream_Close_Proxy(
    IMFByteStream* This);
void __RPC_STUB IMFByteStream_Close_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMFByteStream_BeginRead_Proxy(
    IMFByteStream* This,
    BYTE *pb,
    ULONG cb,
    IMFAsyncCallback *pCallback,
    IUnknown *punkState);
HRESULT __RPC_STUB IMFByteStream_BeginRead_Stub(
    IMFByteStream* This,
    ULONG cb,
    IMFRemoteAsyncCallback *pCallback);
HRESULT CALLBACK IMFByteStream_EndRead_Proxy(
    IMFByteStream* This,
    IMFAsyncResult *pResult,
    ULONG *pcbRead);
HRESULT __RPC_STUB IMFByteStream_EndRead_Stub(
    IMFByteStream* This,
    IUnknown *punkResult,
    BYTE *pb,
    ULONG cb,
    ULONG *pcbRead);
HRESULT CALLBACK IMFByteStream_BeginWrite_Proxy(
    IMFByteStream* This,
    const BYTE *pb,
    ULONG cb,
    IMFAsyncCallback *pCallback,
    IUnknown *punkState);
HRESULT __RPC_STUB IMFByteStream_BeginWrite_Stub(
    IMFByteStream* This,
    const BYTE *pb,
    ULONG cb,
    IMFRemoteAsyncCallback *pCallback);
HRESULT CALLBACK IMFByteStream_EndWrite_Proxy(
    IMFByteStream* This,
    IMFAsyncResult *pResult,
    ULONG *pcbWritten);
HRESULT __RPC_STUB IMFByteStream_EndWrite_Stub(
    IMFByteStream* This,
    IUnknown *punkResult,
    ULONG *pcbWritten);

#endif  /* __IMFByteStream_INTERFACE_DEFINED__ */


#define MFBYTESTREAM_IS_READABLE 0x00000001
#define MFBYTESTREAM_IS_WRITABLE 0x00000002
#define MFBYTESTREAM_IS_SEEKABLE 0x00000004
#define MFBYTESTREAM_IS_REMOTE 0x00000008
#define MFBYTESTREAM_IS_DIRECTORY 0x00000080
#define MFBYTESTREAM_HAS_SLOW_SEEK 0x00000100
#define MFBYTESTREAM_IS_PARTIALLY_DOWNLOADED 0x00000200
#if WINVER >= _WIN32_WINNT_WIN7
#define MFBYTESTREAM_SHARE_WRITE 0x00000400
#endif
#if WINVER >= _WIN32_WINNT_WIN8
#define MFBYTESTREAM_DOES_NOT_USE_NETWORK 0x00000800
#endif

#define MFBYTESTREAM_SEEK_FLAG_CANCEL_PENDING_IO 0x00000001

EXTERN_GUID( MF_BYTESTREAM_ORIGIN_NAME, 0xfc358288, 0x3cb6, 0x460c, 0xa4, 0x24, 0xb6, 0x68, 0x12, 0x60, 0x37, 0x5a);
EXTERN_GUID( MF_BYTESTREAM_CONTENT_TYPE, 0xfc358289, 0x3cb6, 0x460c, 0xa4, 0x24, 0xb6, 0x68, 0x12, 0x60, 0x37, 0x5a);
EXTERN_GUID( MF_BYTESTREAM_DURATION, 0xfc35828a, 0x3cb6, 0x460c, 0xa4, 0x24, 0xb6, 0x68, 0x12, 0x60, 0x37, 0x5a);
EXTERN_GUID( MF_BYTESTREAM_LAST_MODIFIED_TIME, 0xfc35828b, 0x3cb6, 0x460c, 0xa4, 0x24, 0xb6, 0x68, 0x12, 0x60, 0x37, 0x5a);
#if (WINVER >= _WIN32_WINNT_WIN7)
EXTERN_GUID( MF_BYTESTREAM_IFO_FILE_URI, 0xfc35828c, 0x3cb6, 0x460c, 0xa4, 0x24, 0xb6, 0x68, 0x12, 0x60, 0x37, 0x5a);
EXTERN_GUID( MF_BYTESTREAM_DLNA_PROFILE_ID, 0xfc35828d, 0x3cb6, 0x460c, 0xa4, 0x24, 0xb6, 0x68, 0x12, 0x60, 0x37, 0x5a);
EXTERN_GUID( MF_BYTESTREAM_EFFECTIVE_URL, 0x9afa0209, 0x89d1, 0x42af, 0x84, 0x56, 0x1d, 0xe6, 0xb5, 0x62, 0xd6, 0x91);
EXTERN_GUID( MF_BYTESTREAM_TRANSCODED, 0xb6c5c282, 0x4dc9, 0x4db9, 0xab, 0x48, 0xcf, 0x3b, 0x6d, 0x8b, 0xc5, 0xe0 );
#endif
#endif

#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
EXTERN_GUID(CLSID_MFByteStreamProxyClassFactory, 0x770e8e77, 0x4916, 0x441c, 0xa9, 0xa7, 0xb3, 0x42, 0xd0, 0xee, 0xbc, 0x71 );

/*****************************************************************************
 * IMFByteStreamProxyClassFactory interface
 */
#ifndef __IMFByteStreamProxyClassFactory_INTERFACE_DEFINED__
#define __IMFByteStreamProxyClassFactory_INTERFACE_DEFINED__

DEFINE_GUID(IID_IMFByteStreamProxyClassFactory, 0xa6b43f84, 0x5c0a, 0x42e8, 0xa4,0x4d, 0xb1,0x85,0x7a,0x76,0x99,0x2f);
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("a6b43f84-5c0a-42e8-a44d-b1857a76992f")
IMFByteStreamProxyClassFactory : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE CreateByteStreamProxy(
        IMFByteStream *pByteStream,
        IMFAttributes *pAttributes,
        REFIID riid,
        LPVOID *ppvObject) = 0;

};
#ifdef __CRT_UUID_DECL
__CRT_UUID_DECL(IMFByteStreamProxyClassFactory, 0xa6b43f84, 0x5c0a, 0x42e8, 0xa4,0x4d, 0xb1,0x85,0x7a,0x76,0x99,0x2f)
#endif
#else
typedef struct IMFByteStreamProxyClassFactoryVtbl {
    BEGIN_INTERFACE

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

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

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

    /*** IMFByteStreamProxyClassFactory methods ***/
    HRESULT (STDMETHODCALLTYPE *CreateByteStreamProxy)(
        IMFByteStreamProxyClassFactory* This,
        IMFByteStream *pByteStream,
        IMFAttributes *pAttributes,
        REFIID riid,
        LPVOID *ppvObject);

    END_INTERFACE
} IMFByteStreamProxyClassFactoryVtbl;
interface IMFByteStreamProxyClassFactory {
    CONST_VTBL IMFByteStreamProxyClassFactoryVtbl* lpVtbl;
};

#ifdef COBJMACROS
#ifndef WIDL_C_INLINE_WRAPPERS
/*** IUnknown methods ***/
#define IMFByteStreamProxyClassFactory_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
#define IMFByteStreamProxyClassFactory_AddRef(This) (This)->lpVtbl->AddRef(This)
#define IMFByteStreamProxyClassFactory_Release(This) (This)->lpVtbl->Release(This)
/*** IMFByteStreamProxyClassFactory methods ***/
#define IMFByteStreamProxyClassFactory_CreateByteStreamProxy(This,pByteStream,pAttributes,riid,ppvObject) (This)->lpVtbl->CreateByteStreamProxy(This,pByteStream,pAttributes,riid,ppvObject)
#else
/*** IUnknown methods ***/
static FORCEINLINE HRESULT IMFByteStreamProxyClassFactory_QueryInterface(IMFByteStreamProxyClassFactory* This,REFIID riid,void **ppvObject) {
    return This->lpVtbl->QueryInterface(This,riid,ppvObject);
}
static FORCEINLINE ULONG IMFByteStreamProxyClassFactory_AddRef(IMFByteStreamProxyClassFactory* This) {
    return This->lpVtbl->AddRef(This);
}
static FORCEINLINE ULONG IMFByteStreamProxyClassFactory_Release(IMFByteStreamProxyClassFactory* This) {
    return This->lpVtbl->Release(This);
}
/*** IMFByteStreamProxyClassFactory methods ***/
static FORCEINLINE HRESULT IMFByteStreamProxyClassFactory_CreateByteStreamProxy(IMFByteStreamProxyClassFactory* This,IMFByteStream *pByteStream,IMFAttributes *pAttributes,REFIID riid,LPVOID *ppvObject) {
    return This->lpVtbl->CreateByteStreamProxy(This,pByteStream,pAttributes,riid,ppvObject);
}
#endif
#endif

#endif

HRESULT STDMETHODCALLTYPE IMFByteStreamProxyClassFactory_CreateByteStreamProxy_Proxy(
    IMFByteStreamProxyClassFactory* This,
    IMFByteStream *pByteStream,
    IMFAttributes *pAttributes,
    REFIID riid,
    LPVOID *ppvObject);
void __RPC_STUB IMFByteStreamProxyClassFactory_CreateByteStreamProxy_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IMFByteStreamProxyClassFactory_INTERFACE_DEFINED__ */


typedef enum __WIDL_mfobjects_generated_name_00000017 {
    MF_ACCESSMODE_READ = 1,
    MF_ACCESSMODE_WRITE = 2,
    MF_ACCESSMODE_READWRITE = 3
} MF_FILE_ACCESSMODE;

typedef enum __WIDL_mfobjects_generated_name_00000018 {
    MF_OPENMODE_FAIL_IF_NOT_EXIST = 0,
    MF_OPENMODE_FAIL_IF_EXIST = 1,
    MF_OPENMODE_RESET_IF_EXIST = 2,
    MF_OPENMODE_APPEND_IF_EXIST = 3,
    MF_OPENMODE_DELETE_IF_EXIST = 4
} MF_FILE_OPENMODE;

typedef enum __WIDL_mfobjects_generated_name_00000019 {
    MF_FILEFLAGS_NONE = 0x0,
    MF_FILEFLAGS_NOBUFFERING = 0x1
} MF_FILE_FLAGS;
#endif

#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
/*****************************************************************************
 * IMFSampleOutputStream interface
 */
#ifndef __IMFSampleOutputStream_INTERFACE_DEFINED__
#define __IMFSampleOutputStream_INTERFACE_DEFINED__

DEFINE_GUID(IID_IMFSampleOutputStream, 0x8feed468, 0x6f7e, 0x440d, 0x86,0x9a, 0x49,0xbd,0xd2,0x83,0xad,0x0d);
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("8feed468-6f7e-440d-869a-49bdd283ad0d")
IMFSampleOutputStream : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE BeginWriteSample(
        IMFSample *pSample,
        IMFAsyncCallback *pCallback,
        IUnknown *punkState) = 0;

    virtual HRESULT STDMETHODCALLTYPE EndWriteSample(
        IMFAsyncResult *pResult) = 0;

    virtual HRESULT STDMETHODCALLTYPE Close(
        ) = 0;

};
#ifdef __CRT_UUID_DECL
__CRT_UUID_DECL(IMFSampleOutputStream, 0x8feed468, 0x6f7e, 0x440d, 0x86,0x9a, 0x49,0xbd,0xd2,0x83,0xad,0x0d)
#endif
#else
typedef struct IMFSampleOutputStreamVtbl {
    BEGIN_INTERFACE

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

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

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

    /*** IMFSampleOutputStream methods ***/
    HRESULT (STDMETHODCALLTYPE *BeginWriteSample)(
        IMFSampleOutputStream* This,
        IMFSample *pSample,
        IMFAsyncCallback *pCallback,
        IUnknown *punkState);

    HRESULT (STDMETHODCALLTYPE *EndWriteSample)(
        IMFSampleOutputStream* This,
        IMFAsyncResult *pResult);

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

    END_INTERFACE
} IMFSampleOutputStreamVtbl;
interface IMFSampleOutputStream {
    CONST_VTBL IMFSampleOutputStreamVtbl* lpVtbl;
};

#ifdef COBJMACROS
#ifndef WIDL_C_INLINE_WRAPPERS
/*** IUnknown methods ***/
#define IMFSampleOutputStream_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
#define IMFSampleOutputStream_AddRef(This) (This)->lpVtbl->AddRef(This)
#define IMFSampleOutputStream_Release(This) (This)->lpVtbl->Release(This)
/*** IMFSampleOutputStream methods ***/
#define IMFSampleOutputStream_BeginWriteSample(This,pSample,pCallback,punkState) (This)->lpVtbl->BeginWriteSample(This,pSample,pCallback,punkState)
#define IMFSampleOutputStream_EndWriteSample(This,pResult) (This)->lpVtbl->EndWriteSample(This,pResult)
#define IMFSampleOutputStream_Close(This) (This)->lpVtbl->Close(This)
#else
/*** IUnknown methods ***/
static FORCEINLINE HRESULT IMFSampleOutputStream_QueryInterface(IMFSampleOutputStream* This,REFIID riid,void **ppvObject) {
    return This->lpVtbl->QueryInterface(This,riid,ppvObject);
}
static FORCEINLINE ULONG IMFSampleOutputStream_AddRef(IMFSampleOutputStream* This) {
    return This->lpVtbl->AddRef(This);
}
static FORCEINLINE ULONG IMFSampleOutputStream_Release(IMFSampleOutputStream* This) {
    return This->lpVtbl->Release(This);
}
/*** IMFSampleOutputStream methods ***/
static FORCEINLINE HRESULT IMFSampleOutputStream_BeginWriteSample(IMFSampleOutputStream* This,IMFSample *pSample,IMFAsyncCallback *pCallback,IUnknown *punkState) {
    return This->lpVtbl->BeginWriteSample(This,pSample,pCallback,punkState);
}
static FORCEINLINE HRESULT IMFSampleOutputStream_EndWriteSample(IMFSampleOutputStream* This,IMFAsyncResult *pResult) {
    return This->lpVtbl->EndWriteSample(This,pResult);
}
static FORCEINLINE HRESULT IMFSampleOutputStream_Close(IMFSampleOutputStream* This) {
    return This->lpVtbl->Close(This);
}
#endif
#endif

#endif

HRESULT STDMETHODCALLTYPE IMFSampleOutputStream_BeginWriteSample_Proxy(
    IMFSampleOutputStream* This,
    IMFSample *pSample,
    IMFAsyncCallback *pCallback,
    IUnknown *punkState);
void __RPC_STUB IMFSampleOutputStream_BeginWriteSample_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFSampleOutputStream_EndWriteSample_Proxy(
    IMFSampleOutputStream* This,
    IMFAsyncResult *pResult);
void __RPC_STUB IMFSampleOutputStream_EndWriteSample_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFSampleOutputStream_Close_Proxy(
    IMFSampleOutputStream* This);
void __RPC_STUB IMFSampleOutputStream_Close_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IMFSampleOutputStream_INTERFACE_DEFINED__ */


/*****************************************************************************
 * IMFCollection interface
 */
#ifndef __IMFCollection_INTERFACE_DEFINED__
#define __IMFCollection_INTERFACE_DEFINED__

DEFINE_GUID(IID_IMFCollection, 0x5bc8a76b, 0x869a, 0x46a3, 0x9b,0x03, 0xfa,0x21,0x8a,0x66,0xae,0xbe);
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("5bc8a76b-869a-46a3-9b03-fa218a66aebe")
IMFCollection : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE GetElementCount(
        DWORD *pcElements) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetElement(
        DWORD dwElementIndex,
        IUnknown **ppUnkElement) = 0;

    virtual HRESULT STDMETHODCALLTYPE AddElement(
        IUnknown *pUnkElement) = 0;

    virtual HRESULT STDMETHODCALLTYPE RemoveElement(
        DWORD dwElementIndex,
        IUnknown **ppUnkElement) = 0;

    virtual HRESULT STDMETHODCALLTYPE InsertElementAt(
        DWORD dwIndex,
        IUnknown *pUnknown) = 0;

    virtual HRESULT STDMETHODCALLTYPE RemoveAllElements(
        ) = 0;

};
#ifdef __CRT_UUID_DECL
__CRT_UUID_DECL(IMFCollection, 0x5bc8a76b, 0x869a, 0x46a3, 0x9b,0x03, 0xfa,0x21,0x8a,0x66,0xae,0xbe)
#endif
#else
typedef struct IMFCollectionVtbl {
    BEGIN_INTERFACE

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

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

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

    /*** IMFCollection methods ***/
    HRESULT (STDMETHODCALLTYPE *GetElementCount)(
        IMFCollection* This,
        DWORD *pcElements);

    HRESULT (STDMETHODCALLTYPE *GetElement)(
        IMFCollection* This,
        DWORD dwElementIndex,
        IUnknown **ppUnkElement);

    HRESULT (STDMETHODCALLTYPE *AddElement)(
        IMFCollection* This,
        IUnknown *pUnkElement);

    HRESULT (STDMETHODCALLTYPE *RemoveElement)(
        IMFCollection* This,
        DWORD dwElementIndex,
        IUnknown **ppUnkElement);

    HRESULT (STDMETHODCALLTYPE *InsertElementAt)(
        IMFCollection* This,
        DWORD dwIndex,
        IUnknown *pUnknown);

    HRESULT (STDMETHODCALLTYPE *RemoveAllElements)(
        IMFCollection* This);

    END_INTERFACE
} IMFCollectionVtbl;
interface IMFCollection {
    CONST_VTBL IMFCollectionVtbl* lpVtbl;
};

#ifdef COBJMACROS
#ifndef WIDL_C_INLINE_WRAPPERS
/*** IUnknown methods ***/
#define IMFCollection_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
#define IMFCollection_AddRef(This) (This)->lpVtbl->AddRef(This)
#define IMFCollection_Release(This) (This)->lpVtbl->Release(This)
/*** IMFCollection methods ***/
#define IMFCollection_GetElementCount(This,pcElements) (This)->lpVtbl->GetElementCount(This,pcElements)
#define IMFCollection_GetElement(This,dwElementIndex,ppUnkElement) (This)->lpVtbl->GetElement(This,dwElementIndex,ppUnkElement)
#define IMFCollection_AddElement(This,pUnkElement) (This)->lpVtbl->AddElement(This,pUnkElement)
#define IMFCollection_RemoveElement(This,dwElementIndex,ppUnkElement) (This)->lpVtbl->RemoveElement(This,dwElementIndex,ppUnkElement)
#define IMFCollection_InsertElementAt(This,dwIndex,pUnknown) (This)->lpVtbl->InsertElementAt(This,dwIndex,pUnknown)
#define IMFCollection_RemoveAllElements(This) (This)->lpVtbl->RemoveAllElements(This)
#else
/*** IUnknown methods ***/
static FORCEINLINE HRESULT IMFCollection_QueryInterface(IMFCollection* This,REFIID riid,void **ppvObject) {
    return This->lpVtbl->QueryInterface(This,riid,ppvObject);
}
static FORCEINLINE ULONG IMFCollection_AddRef(IMFCollection* This) {
    return This->lpVtbl->AddRef(This);
}
static FORCEINLINE ULONG IMFCollection_Release(IMFCollection* This) {
    return This->lpVtbl->Release(This);
}
/*** IMFCollection methods ***/
static FORCEINLINE HRESULT IMFCollection_GetElementCount(IMFCollection* This,DWORD *pcElements) {
    return This->lpVtbl->GetElementCount(This,pcElements);
}
static FORCEINLINE HRESULT IMFCollection_GetElement(IMFCollection* This,DWORD dwElementIndex,IUnknown **ppUnkElement) {
    return This->lpVtbl->GetElement(This,dwElementIndex,ppUnkElement);
}
static FORCEINLINE HRESULT IMFCollection_AddElement(IMFCollection* This,IUnknown *pUnkElement) {
    return This->lpVtbl->AddElement(This,pUnkElement);
}
static FORCEINLINE HRESULT IMFCollection_RemoveElement(IMFCollection* This,DWORD dwElementIndex,IUnknown **ppUnkElement) {
    return This->lpVtbl->RemoveElement(This,dwElementIndex,ppUnkElement);
}
static FORCEINLINE HRESULT IMFCollection_InsertElementAt(IMFCollection* This,DWORD dwIndex,IUnknown *pUnknown) {
    return This->lpVtbl->InsertElementAt(This,dwIndex,pUnknown);
}
static FORCEINLINE HRESULT IMFCollection_RemoveAllElements(IMFCollection* This) {
    return This->lpVtbl->RemoveAllElements(This);
}
#endif
#endif

#endif

HRESULT STDMETHODCALLTYPE IMFCollection_GetElementCount_Proxy(
    IMFCollection* This,
    DWORD *pcElements);
void __RPC_STUB IMFCollection_GetElementCount_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFCollection_GetElement_Proxy(
    IMFCollection* This,
    DWORD dwElementIndex,
    IUnknown **ppUnkElement);
void __RPC_STUB IMFCollection_GetElement_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFCollection_AddElement_Proxy(
    IMFCollection* This,
    IUnknown *pUnkElement);
void __RPC_STUB IMFCollection_AddElement_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFCollection_RemoveElement_Proxy(
    IMFCollection* This,
    DWORD dwElementIndex,
    IUnknown **ppUnkElement);
void __RPC_STUB IMFCollection_RemoveElement_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFCollection_InsertElementAt_Proxy(
    IMFCollection* This,
    DWORD dwIndex,
    IUnknown *pUnknown);
void __RPC_STUB IMFCollection_InsertElementAt_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFCollection_RemoveAllElements_Proxy(
    IMFCollection* This);
void __RPC_STUB IMFCollection_RemoveAllElements_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IMFCollection_INTERFACE_DEFINED__ */


/*****************************************************************************
 * IMFMediaEventQueue interface
 */
#ifndef __IMFMediaEventQueue_INTERFACE_DEFINED__
#define __IMFMediaEventQueue_INTERFACE_DEFINED__

DEFINE_GUID(IID_IMFMediaEventQueue, 0x36f846fc, 0x2256, 0x48b6, 0xb5,0x8e, 0xe2,0xb6,0x38,0x31,0x65,0x81);
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("36f846fc-2256-48b6-b58e-e2b638316581")
IMFMediaEventQueue : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE GetEvent(
        DWORD dwFlags,
        IMFMediaEvent **ppEvent) = 0;

    virtual HRESULT STDMETHODCALLTYPE BeginGetEvent(
        IMFAsyncCallback *pCallback,
        IUnknown *punkState) = 0;

    virtual HRESULT STDMETHODCALLTYPE EndGetEvent(
        IMFAsyncResult *pResult,
        IMFMediaEvent **ppEvent) = 0;

    virtual HRESULT STDMETHODCALLTYPE QueueEvent(
        IMFMediaEvent *pEvent) = 0;

    virtual HRESULT STDMETHODCALLTYPE QueueEventParamVar(
        MediaEventType met,
        REFGUID guidExtendedType,
        HRESULT hrStatus,
        const PROPVARIANT *pvValue) = 0;

    virtual HRESULT STDMETHODCALLTYPE QueueEventParamUnk(
        MediaEventType met,
        REFGUID guidExtendedType,
        HRESULT hrStatus,
        IUnknown *pUnk) = 0;

    virtual HRESULT STDMETHODCALLTYPE Shutdown(
        ) = 0;

};
#ifdef __CRT_UUID_DECL
__CRT_UUID_DECL(IMFMediaEventQueue, 0x36f846fc, 0x2256, 0x48b6, 0xb5,0x8e, 0xe2,0xb6,0x38,0x31,0x65,0x81)
#endif
#else
typedef struct IMFMediaEventQueueVtbl {
    BEGIN_INTERFACE

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

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

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

    /*** IMFMediaEventQueue methods ***/
    HRESULT (STDMETHODCALLTYPE *GetEvent)(
        IMFMediaEventQueue* This,
        DWORD dwFlags,
        IMFMediaEvent **ppEvent);

    HRESULT (STDMETHODCALLTYPE *BeginGetEvent)(
        IMFMediaEventQueue* This,
        IMFAsyncCallback *pCallback,
        IUnknown *punkState);

    HRESULT (STDMETHODCALLTYPE *EndGetEvent)(
        IMFMediaEventQueue* This,
        IMFAsyncResult *pResult,
        IMFMediaEvent **ppEvent);

    HRESULT (STDMETHODCALLTYPE *QueueEvent)(
        IMFMediaEventQueue* This,
        IMFMediaEvent *pEvent);

    HRESULT (STDMETHODCALLTYPE *QueueEventParamVar)(
        IMFMediaEventQueue* This,
        MediaEventType met,
        REFGUID guidExtendedType,
        HRESULT hrStatus,
        const PROPVARIANT *pvValue);

    HRESULT (STDMETHODCALLTYPE *QueueEventParamUnk)(
        IMFMediaEventQueue* This,
        MediaEventType met,
        REFGUID guidExtendedType,
        HRESULT hrStatus,
        IUnknown *pUnk);

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

    END_INTERFACE
} IMFMediaEventQueueVtbl;
interface IMFMediaEventQueue {
    CONST_VTBL IMFMediaEventQueueVtbl* lpVtbl;
};

#ifdef COBJMACROS
#ifndef WIDL_C_INLINE_WRAPPERS
/*** IUnknown methods ***/
#define IMFMediaEventQueue_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
#define IMFMediaEventQueue_AddRef(This) (This)->lpVtbl->AddRef(This)
#define IMFMediaEventQueue_Release(This) (This)->lpVtbl->Release(This)
/*** IMFMediaEventQueue methods ***/
#define IMFMediaEventQueue_GetEvent(This,dwFlags,ppEvent) (This)->lpVtbl->GetEvent(This,dwFlags,ppEvent)
#define IMFMediaEventQueue_BeginGetEvent(This,pCallback,punkState) (This)->lpVtbl->BeginGetEvent(This,pCallback,punkState)
#define IMFMediaEventQueue_EndGetEvent(This,pResult,ppEvent) (This)->lpVtbl->EndGetEvent(This,pResult,ppEvent)
#define IMFMediaEventQueue_QueueEvent(This,pEvent) (This)->lpVtbl->QueueEvent(This,pEvent)
#define IMFMediaEventQueue_QueueEventParamVar(This,met,guidExtendedType,hrStatus,pvValue) (This)->lpVtbl->QueueEventParamVar(This,met,guidExtendedType,hrStatus,pvValue)
#define IMFMediaEventQueue_QueueEventParamUnk(This,met,guidExtendedType,hrStatus,pUnk) (This)->lpVtbl->QueueEventParamUnk(This,met,guidExtendedType,hrStatus,pUnk)
#define IMFMediaEventQueue_Shutdown(This) (This)->lpVtbl->Shutdown(This)
#else
/*** IUnknown methods ***/
static FORCEINLINE HRESULT IMFMediaEventQueue_QueryInterface(IMFMediaEventQueue* This,REFIID riid,void **ppvObject) {
    return This->lpVtbl->QueryInterface(This,riid,ppvObject);
}
static FORCEINLINE ULONG IMFMediaEventQueue_AddRef(IMFMediaEventQueue* This) {
    return This->lpVtbl->AddRef(This);
}
static FORCEINLINE ULONG IMFMediaEventQueue_Release(IMFMediaEventQueue* This) {
    return This->lpVtbl->Release(This);
}
/*** IMFMediaEventQueue methods ***/
static FORCEINLINE HRESULT IMFMediaEventQueue_GetEvent(IMFMediaEventQueue* This,DWORD dwFlags,IMFMediaEvent **ppEvent) {
    return This->lpVtbl->GetEvent(This,dwFlags,ppEvent);
}
static FORCEINLINE HRESULT IMFMediaEventQueue_BeginGetEvent(IMFMediaEventQueue* This,IMFAsyncCallback *pCallback,IUnknown *punkState) {
    return This->lpVtbl->BeginGetEvent(This,pCallback,punkState);
}
static FORCEINLINE HRESULT IMFMediaEventQueue_EndGetEvent(IMFMediaEventQueue* This,IMFAsyncResult *pResult,IMFMediaEvent **ppEvent) {
    return This->lpVtbl->EndGetEvent(This,pResult,ppEvent);
}
static FORCEINLINE HRESULT IMFMediaEventQueue_QueueEvent(IMFMediaEventQueue* This,IMFMediaEvent *pEvent) {
    return This->lpVtbl->QueueEvent(This,pEvent);
}
static FORCEINLINE HRESULT IMFMediaEventQueue_QueueEventParamVar(IMFMediaEventQueue* This,MediaEventType met,REFGUID guidExtendedType,HRESULT hrStatus,const PROPVARIANT *pvValue) {
    return This->lpVtbl->QueueEventParamVar(This,met,guidExtendedType,hrStatus,pvValue);
}
static FORCEINLINE HRESULT IMFMediaEventQueue_QueueEventParamUnk(IMFMediaEventQueue* This,MediaEventType met,REFGUID guidExtendedType,HRESULT hrStatus,IUnknown *pUnk) {
    return This->lpVtbl->QueueEventParamUnk(This,met,guidExtendedType,hrStatus,pUnk);
}
static FORCEINLINE HRESULT IMFMediaEventQueue_Shutdown(IMFMediaEventQueue* This) {
    return This->lpVtbl->Shutdown(This);
}
#endif
#endif

#endif

HRESULT STDMETHODCALLTYPE IMFMediaEventQueue_GetEvent_Proxy(
    IMFMediaEventQueue* This,
    DWORD dwFlags,
    IMFMediaEvent **ppEvent);
void __RPC_STUB IMFMediaEventQueue_GetEvent_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFMediaEventQueue_BeginGetEvent_Proxy(
    IMFMediaEventQueue* This,
    IMFAsyncCallback *pCallback,
    IUnknown *punkState);
void __RPC_STUB IMFMediaEventQueue_BeginGetEvent_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFMediaEventQueue_EndGetEvent_Proxy(
    IMFMediaEventQueue* This,
    IMFAsyncResult *pResult,
    IMFMediaEvent **ppEvent);
void __RPC_STUB IMFMediaEventQueue_EndGetEvent_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFMediaEventQueue_QueueEvent_Proxy(
    IMFMediaEventQueue* This,
    IMFMediaEvent *pEvent);
void __RPC_STUB IMFMediaEventQueue_QueueEvent_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFMediaEventQueue_QueueEventParamVar_Proxy(
    IMFMediaEventQueue* This,
    MediaEventType met,
    REFGUID guidExtendedType,
    HRESULT hrStatus,
    const PROPVARIANT *pvValue);
void __RPC_STUB IMFMediaEventQueue_QueueEventParamVar_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFMediaEventQueue_QueueEventParamUnk_Proxy(
    IMFMediaEventQueue* This,
    MediaEventType met,
    REFGUID guidExtendedType,
    HRESULT hrStatus,
    IUnknown *pUnk);
void __RPC_STUB IMFMediaEventQueue_QueueEventParamUnk_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFMediaEventQueue_Shutdown_Proxy(
    IMFMediaEventQueue* This);
void __RPC_STUB IMFMediaEventQueue_Shutdown_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IMFMediaEventQueue_INTERFACE_DEFINED__ */


/*****************************************************************************
 * IMFActivate interface
 */
#ifndef __IMFActivate_INTERFACE_DEFINED__
#define __IMFActivate_INTERFACE_DEFINED__

DEFINE_GUID(IID_IMFActivate, 0x7fee9e9a, 0x4a89, 0x47a6, 0x89,0x9c, 0xb6,0xa5,0x3a,0x70,0xfb,0x67);
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("7fee9e9a-4a89-47a6-899c-b6a53a70fb67")
IMFActivate : public IMFAttributes
{
    virtual HRESULT STDMETHODCALLTYPE ActivateObject(
        REFIID riid,
        void **ppv) = 0;

    virtual HRESULT STDMETHODCALLTYPE ShutdownObject(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE DetachObject(
        ) = 0;

};
#ifdef __CRT_UUID_DECL
__CRT_UUID_DECL(IMFActivate, 0x7fee9e9a, 0x4a89, 0x47a6, 0x89,0x9c, 0xb6,0xa5,0x3a,0x70,0xfb,0x67)
#endif
#else
typedef struct IMFActivateVtbl {
    BEGIN_INTERFACE

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

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

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

    /*** IMFAttributes methods ***/
    HRESULT (STDMETHODCALLTYPE *GetItem)(
        IMFActivate* This,
        REFGUID guidKey,
        PROPVARIANT *pValue);

    HRESULT (STDMETHODCALLTYPE *GetItemType)(
        IMFActivate* This,
        REFGUID guidKey,
        MF_ATTRIBUTE_TYPE *pType);

    HRESULT (STDMETHODCALLTYPE *CompareItem)(
        IMFActivate* This,
        REFGUID guidKey,
        REFPROPVARIANT Value,
        WINBOOL *pbResult);

    HRESULT (STDMETHODCALLTYPE *Compare)(
        IMFActivate* This,
        IMFAttributes *pTheirs,
        MF_ATTRIBUTES_MATCH_TYPE MatchType,
        WINBOOL *pbResult);

    HRESULT (STDMETHODCALLTYPE *GetUINT32)(
        IMFActivate* This,
        REFGUID guidKey,
        UINT32 *punValue);

    HRESULT (STDMETHODCALLTYPE *GetUINT64)(
        IMFActivate* This,
        REFGUID guidKey,
        UINT64 *punValue);

    HRESULT (STDMETHODCALLTYPE *GetDouble)(
        IMFActivate* This,
        REFGUID guidKey,
        double *pfValue);

    HRESULT (STDMETHODCALLTYPE *GetGUID)(
        IMFActivate* This,
        REFGUID guidKey,
        GUID *pguidValue);

    HRESULT (STDMETHODCALLTYPE *GetStringLength)(
        IMFActivate* This,
        REFGUID guidKey,
        UINT32 *pcchLength);

    HRESULT (STDMETHODCALLTYPE *GetString)(
        IMFActivate* This,
        REFGUID guidKey,
        LPWSTR pwszValue,
        UINT32 cchBufSize,
        UINT32 *pcchLength);

    HRESULT (STDMETHODCALLTYPE *GetAllocatedString)(
        IMFActivate* This,
        REFGUID guidKey,
        LPWSTR *ppwszValue,
        UINT32 *pcchLength);

    HRESULT (STDMETHODCALLTYPE *GetBlobSize)(
        IMFActivate* This,
        REFGUID guidKey,
        UINT32 *pcbBlobSize);

    HRESULT (STDMETHODCALLTYPE *GetBlob)(
        IMFActivate* This,
        REFGUID guidKey,
        UINT8 *pBuf,
        UINT32 cbBufSize,
        UINT32 *pcbBlobSize);

    HRESULT (STDMETHODCALLTYPE *GetAllocatedBlob)(
        IMFActivate* This,
        REFGUID guidKey,
        UINT8 **ppBuf,
        UINT32 *pcbSize);

    HRESULT (STDMETHODCALLTYPE *GetUnknown)(
        IMFActivate* This,
        REFGUID guidKey,
        REFIID riid,
        LPVOID *ppv);

    HRESULT (STDMETHODCALLTYPE *SetItem)(
        IMFActivate* This,
        REFGUID guidKey,
        REFPROPVARIANT Value);

    HRESULT (STDMETHODCALLTYPE *DeleteItem)(
        IMFActivate* This,
        REFGUID guidKey);

    HRESULT (STDMETHODCALLTYPE *DeleteAllItems)(
        IMFActivate* This);

    HRESULT (STDMETHODCALLTYPE *SetUINT32)(
        IMFActivate* This,
        REFGUID guidKey,
        UINT32 unValue);

    HRESULT (STDMETHODCALLTYPE *SetUINT64)(
        IMFActivate* This,
        REFGUID guidKey,
        UINT64 unValue);

    HRESULT (STDMETHODCALLTYPE *SetDouble)(
        IMFActivate* This,
        REFGUID guidKey,
        double fValue);

    HRESULT (STDMETHODCALLTYPE *SetGUID)(
        IMFActivate* This,
        REFGUID guidKey,
        REFGUID guidValue);

    HRESULT (STDMETHODCALLTYPE *SetString)(
        IMFActivate* This,
        REFGUID guidKey,
        LPCWSTR wszValue);

    HRESULT (STDMETHODCALLTYPE *SetBlob)(
        IMFActivate* This,
        REFGUID guidKey,
        const UINT8 *pBuf,
        UINT32 cbBufSize);

    HRESULT (STDMETHODCALLTYPE *SetUnknown)(
        IMFActivate* This,
        REFGUID guidKey,
        IUnknown *pUnknown);

    HRESULT (STDMETHODCALLTYPE *LockStore)(
        IMFActivate* This);

    HRESULT (STDMETHODCALLTYPE *UnlockStore)(
        IMFActivate* This);

    HRESULT (STDMETHODCALLTYPE *GetCount)(
        IMFActivate* This,
        UINT32 *pcItems);

    HRESULT (STDMETHODCALLTYPE *GetItemByIndex)(
        IMFActivate* This,
        UINT32 unIndex,
        GUID *pguidKey,
        PROPVARIANT *pValue);

    HRESULT (STDMETHODCALLTYPE *CopyAllItems)(
        IMFActivate* This,
        IMFAttributes *pDest);

    /*** IMFActivate methods ***/
    HRESULT (STDMETHODCALLTYPE *ActivateObject)(
        IMFActivate* This,
        REFIID riid,
        void **ppv);

    HRESULT (STDMETHODCALLTYPE *ShutdownObject)(
        IMFActivate* This);

    HRESULT (STDMETHODCALLTYPE *DetachObject)(
        IMFActivate* This);

    END_INTERFACE
} IMFActivateVtbl;
interface IMFActivate {
    CONST_VTBL IMFActivateVtbl* lpVtbl;
};

#ifdef COBJMACROS
#ifndef WIDL_C_INLINE_WRAPPERS
/*** IUnknown methods ***/
#define IMFActivate_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
#define IMFActivate_AddRef(This) (This)->lpVtbl->AddRef(This)
#define IMFActivate_Release(This) (This)->lpVtbl->Release(This)
/*** IMFAttributes methods ***/
#define IMFActivate_GetItem(This,guidKey,pValue) (This)->lpVtbl->GetItem(This,guidKey,pValue)
#define IMFActivate_GetItemType(This,guidKey,pType) (This)->lpVtbl->GetItemType(This,guidKey,pType)
#define IMFActivate_CompareItem(This,guidKey,Value,pbResult) (This)->lpVtbl->CompareItem(This,guidKey,Value,pbResult)
#define IMFActivate_Compare(This,pTheirs,MatchType,pbResult) (This)->lpVtbl->Compare(This,pTheirs,MatchType,pbResult)
#define IMFActivate_GetUINT32(This,guidKey,punValue) (This)->lpVtbl->GetUINT32(This,guidKey,punValue)
#define IMFActivate_GetUINT64(This,guidKey,punValue) (This)->lpVtbl->GetUINT64(This,guidKey,punValue)
#define IMFActivate_GetDouble(This,guidKey,pfValue) (This)->lpVtbl->GetDouble(This,guidKey,pfValue)
#define IMFActivate_GetGUID(This,guidKey,pguidValue) (This)->lpVtbl->GetGUID(This,guidKey,pguidValue)
#define IMFActivate_GetStringLength(This,guidKey,pcchLength) (This)->lpVtbl->GetStringLength(This,guidKey,pcchLength)
#define IMFActivate_GetString(This,guidKey,pwszValue,cchBufSize,pcchLength) (This)->lpVtbl->GetString(This,guidKey,pwszValue,cchBufSize,pcchLength)
#define IMFActivate_GetAllocatedString(This,guidKey,ppwszValue,pcchLength) (This)->lpVtbl->GetAllocatedString(This,guidKey,ppwszValue,pcchLength)
#define IMFActivate_GetBlobSize(This,guidKey,pcbBlobSize) (This)->lpVtbl->GetBlobSize(This,guidKey,pcbBlobSize)
#define IMFActivate_GetBlob(This,guidKey,pBuf,cbBufSize,pcbBlobSize) (This)->lpVtbl->GetBlob(This,guidKey,pBuf,cbBufSize,pcbBlobSize)
#define IMFActivate_GetAllocatedBlob(This,guidKey,ppBuf,pcbSize) (This)->lpVtbl->GetAllocatedBlob(This,guidKey,ppBuf,pcbSize)
#define IMFActivate_GetUnknown(This,guidKey,riid,ppv) (This)->lpVtbl->GetUnknown(This,guidKey,riid,ppv)
#define IMFActivate_SetItem(This,guidKey,Value) (This)->lpVtbl->SetItem(This,guidKey,Value)
#define IMFActivate_DeleteItem(This,guidKey) (This)->lpVtbl->DeleteItem(This,guidKey)
#define IMFActivate_DeleteAllItems(This) (This)->lpVtbl->DeleteAllItems(This)
#define IMFActivate_SetUINT32(This,guidKey,unValue) (This)->lpVtbl->SetUINT32(This,guidKey,unValue)
#define IMFActivate_SetUINT64(This,guidKey,unValue) (This)->lpVtbl->SetUINT64(This,guidKey,unValue)
#define IMFActivate_SetDouble(This,guidKey,fValue) (This)->lpVtbl->SetDouble(This,guidKey,fValue)
#define IMFActivate_SetGUID(This,guidKey,guidValue) (This)->lpVtbl->SetGUID(This,guidKey,guidValue)
#define IMFActivate_SetString(This,guidKey,wszValue) (This)->lpVtbl->SetString(This,guidKey,wszValue)
#define IMFActivate_SetBlob(This,guidKey,pBuf,cbBufSize) (This)->lpVtbl->SetBlob(This,guidKey,pBuf,cbBufSize)
#define IMFActivate_SetUnknown(This,guidKey,pUnknown) (This)->lpVtbl->SetUnknown(This,guidKey,pUnknown)
#define IMFActivate_LockStore(This) (This)->lpVtbl->LockStore(This)
#define IMFActivate_UnlockStore(This) (This)->lpVtbl->UnlockStore(This)
#define IMFActivate_GetCount(This,pcItems) (This)->lpVtbl->GetCount(This,pcItems)
#define IMFActivate_GetItemByIndex(This,unIndex,pguidKey,pValue) (This)->lpVtbl->GetItemByIndex(This,unIndex,pguidKey,pValue)
#define IMFActivate_CopyAllItems(This,pDest) (This)->lpVtbl->CopyAllItems(This,pDest)
/*** IMFActivate methods ***/
#define IMFActivate_ActivateObject(This,riid,ppv) (This)->lpVtbl->ActivateObject(This,riid,ppv)
#define IMFActivate_ShutdownObject(This) (This)->lpVtbl->ShutdownObject(This)
#define IMFActivate_DetachObject(This) (This)->lpVtbl->DetachObject(This)
#else
/*** IUnknown methods ***/
static FORCEINLINE HRESULT IMFActivate_QueryInterface(IMFActivate* This,REFIID riid,void **ppvObject) {
    return This->lpVtbl->QueryInterface(This,riid,ppvObject);
}
static FORCEINLINE ULONG IMFActivate_AddRef(IMFActivate* This) {
    return This->lpVtbl->AddRef(This);
}
static FORCEINLINE ULONG IMFActivate_Release(IMFActivate* This) {
    return This->lpVtbl->Release(This);
}
/*** IMFAttributes methods ***/
static FORCEINLINE HRESULT IMFActivate_GetItem(IMFActivate* This,REFGUID guidKey,PROPVARIANT *pValue) {
    return This->lpVtbl->GetItem(This,guidKey,pValue);
}
static FORCEINLINE HRESULT IMFActivate_GetItemType(IMFActivate* This,REFGUID guidKey,MF_ATTRIBUTE_TYPE *pType) {
    return This->lpVtbl->GetItemType(This,guidKey,pType);
}
static FORCEINLINE HRESULT IMFActivate_CompareItem(IMFActivate* This,REFGUID guidKey,REFPROPVARIANT Value,WINBOOL *pbResult) {
    return This->lpVtbl->CompareItem(This,guidKey,Value,pbResult);
}
static FORCEINLINE HRESULT IMFActivate_Compare(IMFActivate* This,IMFAttributes *pTheirs,MF_ATTRIBUTES_MATCH_TYPE MatchType,WINBOOL *pbResult) {
    return This->lpVtbl->Compare(This,pTheirs,MatchType,pbResult);
}
static FORCEINLINE HRESULT IMFActivate_GetUINT32(IMFActivate* This,REFGUID guidKey,UINT32 *punValue) {
    return This->lpVtbl->GetUINT32(This,guidKey,punValue);
}
static FORCEINLINE HRESULT IMFActivate_GetUINT64(IMFActivate* This,REFGUID guidKey,UINT64 *punValue) {
    return This->lpVtbl->GetUINT64(This,guidKey,punValue);
}
static FORCEINLINE HRESULT IMFActivate_GetDouble(IMFActivate* This,REFGUID guidKey,double *pfValue) {
    return This->lpVtbl->GetDouble(This,guidKey,pfValue);
}
static FORCEINLINE HRESULT IMFActivate_GetGUID(IMFActivate* This,REFGUID guidKey,GUID *pguidValue) {
    return This->lpVtbl->GetGUID(This,guidKey,pguidValue);
}
static FORCEINLINE HRESULT IMFActivate_GetStringLength(IMFActivate* This,REFGUID guidKey,UINT32 *pcchLength) {
    return This->lpVtbl->GetStringLength(This,guidKey,pcchLength);
}
static FORCEINLINE HRESULT IMFActivate_GetString(IMFActivate* This,REFGUID guidKey,LPWSTR pwszValue,UINT32 cchBufSize,UINT32 *pcchLength) {
    return This->lpVtbl->GetString(This,guidKey,pwszValue,cchBufSize,pcchLength);
}
static FORCEINLINE HRESULT IMFActivate_GetAllocatedString(IMFActivate* This,REFGUID guidKey,LPWSTR *ppwszValue,UINT32 *pcchLength) {
    return This->lpVtbl->GetAllocatedString(This,guidKey,ppwszValue,pcchLength);
}
static FORCEINLINE HRESULT IMFActivate_GetBlobSize(IMFActivate* This,REFGUID guidKey,UINT32 *pcbBlobSize) {
    return This->lpVtbl->GetBlobSize(This,guidKey,pcbBlobSize);
}
static FORCEINLINE HRESULT IMFActivate_GetBlob(IMFActivate* This,REFGUID guidKey,UINT8 *pBuf,UINT32 cbBufSize,UINT32 *pcbBlobSize) {
    return This->lpVtbl->GetBlob(This,guidKey,pBuf,cbBufSize,pcbBlobSize);
}
static FORCEINLINE HRESULT IMFActivate_GetAllocatedBlob(IMFActivate* This,REFGUID guidKey,UINT8 **ppBuf,UINT32 *pcbSize) {
    return This->lpVtbl->GetAllocatedBlob(This,guidKey,ppBuf,pcbSize);
}
static FORCEINLINE HRESULT IMFActivate_GetUnknown(IMFActivate* This,REFGUID guidKey,REFIID riid,LPVOID *ppv) {
    return This->lpVtbl->GetUnknown(This,guidKey,riid,ppv);
}
static FORCEINLINE HRESULT IMFActivate_SetItem(IMFActivate* This,REFGUID guidKey,REFPROPVARIANT Value) {
    return This->lpVtbl->SetItem(This,guidKey,Value);
}
static FORCEINLINE HRESULT IMFActivate_DeleteItem(IMFActivate* This,REFGUID guidKey) {
    return This->lpVtbl->DeleteItem(This,guidKey);
}
static FORCEINLINE HRESULT IMFActivate_DeleteAllItems(IMFActivate* This) {
    return This->lpVtbl->DeleteAllItems(This);
}
static FORCEINLINE HRESULT IMFActivate_SetUINT32(IMFActivate* This,REFGUID guidKey,UINT32 unValue) {
    return This->lpVtbl->SetUINT32(This,guidKey,unValue);
}
static FORCEINLINE HRESULT IMFActivate_SetUINT64(IMFActivate* This,REFGUID guidKey,UINT64 unValue) {
    return This->lpVtbl->SetUINT64(This,guidKey,unValue);
}
static FORCEINLINE HRESULT IMFActivate_SetDouble(IMFActivate* This,REFGUID guidKey,double fValue) {
    return This->lpVtbl->SetDouble(This,guidKey,fValue);
}
static FORCEINLINE HRESULT IMFActivate_SetGUID(IMFActivate* This,REFGUID guidKey,REFGUID guidValue) {
    return This->lpVtbl->SetGUID(This,guidKey,guidValue);
}
static FORCEINLINE HRESULT IMFActivate_SetString(IMFActivate* This,REFGUID guidKey,LPCWSTR wszValue) {
    return This->lpVtbl->SetString(This,guidKey,wszValue);
}
static FORCEINLINE HRESULT IMFActivate_SetBlob(IMFActivate* This,REFGUID guidKey,const UINT8 *pBuf,UINT32 cbBufSize) {
    return This->lpVtbl->SetBlob(This,guidKey,pBuf,cbBufSize);
}
static FORCEINLINE HRESULT IMFActivate_SetUnknown(IMFActivate* This,REFGUID guidKey,IUnknown *pUnknown) {
    return This->lpVtbl->SetUnknown(This,guidKey,pUnknown);
}
static FORCEINLINE HRESULT IMFActivate_LockStore(IMFActivate* This) {
    return This->lpVtbl->LockStore(This);
}
static FORCEINLINE HRESULT IMFActivate_UnlockStore(IMFActivate* This) {
    return This->lpVtbl->UnlockStore(This);
}
static FORCEINLINE HRESULT IMFActivate_GetCount(IMFActivate* This,UINT32 *pcItems) {
    return This->lpVtbl->GetCount(This,pcItems);
}
static FORCEINLINE HRESULT IMFActivate_GetItemByIndex(IMFActivate* This,UINT32 unIndex,GUID *pguidKey,PROPVARIANT *pValue) {
    return This->lpVtbl->GetItemByIndex(This,unIndex,pguidKey,pValue);
}
static FORCEINLINE HRESULT IMFActivate_CopyAllItems(IMFActivate* This,IMFAttributes *pDest) {
    return This->lpVtbl->CopyAllItems(This,pDest);
}
/*** IMFActivate methods ***/
static FORCEINLINE HRESULT IMFActivate_ActivateObject(IMFActivate* This,REFIID riid,void **ppv) {
    return This->lpVtbl->ActivateObject(This,riid,ppv);
}
static FORCEINLINE HRESULT IMFActivate_ShutdownObject(IMFActivate* This) {
    return This->lpVtbl->ShutdownObject(This);
}
static FORCEINLINE HRESULT IMFActivate_DetachObject(IMFActivate* This) {
    return This->lpVtbl->DetachObject(This);
}
#endif
#endif

#endif

HRESULT STDMETHODCALLTYPE IMFActivate_ActivateObject_Proxy(
    IMFActivate* This,
    REFIID riid,
    void **ppv);
void __RPC_STUB IMFActivate_ActivateObject_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFActivate_ShutdownObject_Proxy(
    IMFActivate* This);
void __RPC_STUB IMFActivate_ShutdownObject_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFActivate_DetachObject_Proxy(
    IMFActivate* This);
void __RPC_STUB IMFActivate_DetachObject_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IMFActivate_INTERFACE_DEFINED__ */

#endif

#if WINVER >= _WIN32_WINNT_WIN7
#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
typedef enum _MF_Plugin_Type {
    MF_Plugin_Type_MFT = 0,
    MF_Plugin_Type_MediaSource = 1,
    MF_Plugin_Type_MFT_MatchOutputType = 2,
    MF_Plugin_Type_Other = (DWORD)-1
} MF_Plugin_Type;

/*****************************************************************************
 * IMFPluginControl interface
 */
#ifndef __IMFPluginControl_INTERFACE_DEFINED__
#define __IMFPluginControl_INTERFACE_DEFINED__

DEFINE_GUID(IID_IMFPluginControl, 0x5c6c44bf, 0x1db6, 0x435b, 0x92,0x49, 0xe8,0xcd,0x10,0xfd,0xec,0x96);
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("5c6c44bf-1db6-435b-9249-e8cd10fdec96")
IMFPluginControl : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE GetPreferredClsid(
        DWORD pluginType,
        LPCWSTR selector,
        CLSID *clsid) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetPreferredClsidByIndex(
        DWORD pluginType,
        DWORD index,
        LPWSTR *selector,
        CLSID *clsid) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetPreferredClsid(
        DWORD pluginType,
        LPCWSTR selector,
        const CLSID *clsid) = 0;

    virtual HRESULT STDMETHODCALLTYPE IsDisabled(
        DWORD pluginType,
        REFCLSID clsid) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetDisabledByIndex(
        DWORD pluginType,
        DWORD index,
        CLSID *clsid) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetDisabled(
        DWORD pluginType,
        REFCLSID clsid,
        WINBOOL disabled) = 0;

};
#ifdef __CRT_UUID_DECL
__CRT_UUID_DECL(IMFPluginControl, 0x5c6c44bf, 0x1db6, 0x435b, 0x92,0x49, 0xe8,0xcd,0x10,0xfd,0xec,0x96)
#endif
#else
typedef struct IMFPluginControlVtbl {
    BEGIN_INTERFACE

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

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

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

    /*** IMFPluginControl methods ***/
    HRESULT (STDMETHODCALLTYPE *GetPreferredClsid)(
        IMFPluginControl* This,
        DWORD pluginType,
        LPCWSTR selector,
        CLSID *clsid);

    HRESULT (STDMETHODCALLTYPE *GetPreferredClsidByIndex)(
        IMFPluginControl* This,
        DWORD pluginType,
        DWORD index,
        LPWSTR *selector,
        CLSID *clsid);

    HRESULT (STDMETHODCALLTYPE *SetPreferredClsid)(
        IMFPluginControl* This,
        DWORD pluginType,
        LPCWSTR selector,
        const CLSID *clsid);

    HRESULT (STDMETHODCALLTYPE *IsDisabled)(
        IMFPluginControl* This,
        DWORD pluginType,
        REFCLSID clsid);

    HRESULT (STDMETHODCALLTYPE *GetDisabledByIndex)(
        IMFPluginControl* This,
        DWORD pluginType,
        DWORD index,
        CLSID *clsid);

    HRESULT (STDMETHODCALLTYPE *SetDisabled)(
        IMFPluginControl* This,
        DWORD pluginType,
        REFCLSID clsid,
        WINBOOL disabled);

    END_INTERFACE
} IMFPluginControlVtbl;
interface IMFPluginControl {
    CONST_VTBL IMFPluginControlVtbl* lpVtbl;
};

#ifdef COBJMACROS
#ifndef WIDL_C_INLINE_WRAPPERS
/*** IUnknown methods ***/
#define IMFPluginControl_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
#define IMFPluginControl_AddRef(This) (This)->lpVtbl->AddRef(This)
#define IMFPluginControl_Release(This) (This)->lpVtbl->Release(This)
/*** IMFPluginControl methods ***/
#define IMFPluginControl_GetPreferredClsid(This,pluginType,selector,clsid) (This)->lpVtbl->GetPreferredClsid(This,pluginType,selector,clsid)
#define IMFPluginControl_GetPreferredClsidByIndex(This,pluginType,index,selector,clsid) (This)->lpVtbl->GetPreferredClsidByIndex(This,pluginType,index,selector,clsid)
#define IMFPluginControl_SetPreferredClsid(This,pluginType,selector,clsid) (This)->lpVtbl->SetPreferredClsid(This,pluginType,selector,clsid)
#define IMFPluginControl_IsDisabled(This,pluginType,clsid) (This)->lpVtbl->IsDisabled(This,pluginType,clsid)
#define IMFPluginControl_GetDisabledByIndex(This,pluginType,index,clsid) (This)->lpVtbl->GetDisabledByIndex(This,pluginType,index,clsid)
#define IMFPluginControl_SetDisabled(This,pluginType,clsid,disabled) (This)->lpVtbl->SetDisabled(This,pluginType,clsid,disabled)
#else
/*** IUnknown methods ***/
static FORCEINLINE HRESULT IMFPluginControl_QueryInterface(IMFPluginControl* This,REFIID riid,void **ppvObject) {
    return This->lpVtbl->QueryInterface(This,riid,ppvObject);
}
static FORCEINLINE ULONG IMFPluginControl_AddRef(IMFPluginControl* This) {
    return This->lpVtbl->AddRef(This);
}
static FORCEINLINE ULONG IMFPluginControl_Release(IMFPluginControl* This) {
    return This->lpVtbl->Release(This);
}
/*** IMFPluginControl methods ***/
static FORCEINLINE HRESULT IMFPluginControl_GetPreferredClsid(IMFPluginControl* This,DWORD pluginType,LPCWSTR selector,CLSID *clsid) {
    return This->lpVtbl->GetPreferredClsid(This,pluginType,selector,clsid);
}
static FORCEINLINE HRESULT IMFPluginControl_GetPreferredClsidByIndex(IMFPluginControl* This,DWORD pluginType,DWORD index,LPWSTR *selector,CLSID *clsid) {
    return This->lpVtbl->GetPreferredClsidByIndex(This,pluginType,index,selector,clsid);
}
static FORCEINLINE HRESULT IMFPluginControl_SetPreferredClsid(IMFPluginControl* This,DWORD pluginType,LPCWSTR selector,const CLSID *clsid) {
    return This->lpVtbl->SetPreferredClsid(This,pluginType,selector,clsid);
}
static FORCEINLINE HRESULT IMFPluginControl_IsDisabled(IMFPluginControl* This,DWORD pluginType,REFCLSID clsid) {
    return This->lpVtbl->IsDisabled(This,pluginType,clsid);
}
static FORCEINLINE HRESULT IMFPluginControl_GetDisabledByIndex(IMFPluginControl* This,DWORD pluginType,DWORD index,CLSID *clsid) {
    return This->lpVtbl->GetDisabledByIndex(This,pluginType,index,clsid);
}
static FORCEINLINE HRESULT IMFPluginControl_SetDisabled(IMFPluginControl* This,DWORD pluginType,REFCLSID clsid,WINBOOL disabled) {
    return This->lpVtbl->SetDisabled(This,pluginType,clsid,disabled);
}
#endif
#endif

#endif

HRESULT STDMETHODCALLTYPE IMFPluginControl_GetPreferredClsid_Proxy(
    IMFPluginControl* This,
    DWORD pluginType,
    LPCWSTR selector,
    CLSID *clsid);
void __RPC_STUB IMFPluginControl_GetPreferredClsid_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFPluginControl_GetPreferredClsidByIndex_Proxy(
    IMFPluginControl* This,
    DWORD pluginType,
    DWORD index,
    LPWSTR *selector,
    CLSID *clsid);
void __RPC_STUB IMFPluginControl_GetPreferredClsidByIndex_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFPluginControl_SetPreferredClsid_Proxy(
    IMFPluginControl* This,
    DWORD pluginType,
    LPCWSTR selector,
    const CLSID *clsid);
void __RPC_STUB IMFPluginControl_SetPreferredClsid_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFPluginControl_IsDisabled_Proxy(
    IMFPluginControl* This,
    DWORD pluginType,
    REFCLSID clsid);
void __RPC_STUB IMFPluginControl_IsDisabled_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFPluginControl_GetDisabledByIndex_Proxy(
    IMFPluginControl* This,
    DWORD pluginType,
    DWORD index,
    CLSID *clsid);
void __RPC_STUB IMFPluginControl_GetDisabledByIndex_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFPluginControl_SetDisabled_Proxy(
    IMFPluginControl* This,
    DWORD pluginType,
    REFCLSID clsid,
    WINBOOL disabled);
void __RPC_STUB IMFPluginControl_SetDisabled_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IMFPluginControl_INTERFACE_DEFINED__ */


typedef enum MF_PLUGIN_CONTROL_POLICY {
    MF_PLUGIN_CONTROL_POLICY_USE_ALL_PLUGINS = 0,
    MF_PLUGIN_CONTROL_POLICY_USE_APPROVED_PLUGINS = 1,
    MF_PLUGIN_CONTROL_POLICY_USE_WEB_PLUGINS = 2
} MF_PLUGIN_CONTROL_POLICY;

/*****************************************************************************
 * IMFPluginControl2 interface
 */
#ifndef __IMFPluginControl2_INTERFACE_DEFINED__
#define __IMFPluginControl2_INTERFACE_DEFINED__

DEFINE_GUID(IID_IMFPluginControl2, 0xc6982083, 0x3ddc, 0x45cb, 0xaf,0x5e, 0x0f,0x7a,0x8c,0xe4,0xde,0x77);
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("c6982083-3ddc-45cb-af5e-0f7a8ce4de77")
IMFPluginControl2 : public IMFPluginControl
{
    virtual HRESULT STDMETHODCALLTYPE SetPolicy(
        MF_PLUGIN_CONTROL_POLICY policy) = 0;

};
#ifdef __CRT_UUID_DECL
__CRT_UUID_DECL(IMFPluginControl2, 0xc6982083, 0x3ddc, 0x45cb, 0xaf,0x5e, 0x0f,0x7a,0x8c,0xe4,0xde,0x77)
#endif
#else
typedef struct IMFPluginControl2Vtbl {
    BEGIN_INTERFACE

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

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

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

    /*** IMFPluginControl methods ***/
    HRESULT (STDMETHODCALLTYPE *GetPreferredClsid)(
        IMFPluginControl2* This,
        DWORD pluginType,
        LPCWSTR selector,
        CLSID *clsid);

    HRESULT (STDMETHODCALLTYPE *GetPreferredClsidByIndex)(
        IMFPluginControl2* This,
        DWORD pluginType,
        DWORD index,
        LPWSTR *selector,
        CLSID *clsid);

    HRESULT (STDMETHODCALLTYPE *SetPreferredClsid)(
        IMFPluginControl2* This,
        DWORD pluginType,
        LPCWSTR selector,
        const CLSID *clsid);

    HRESULT (STDMETHODCALLTYPE *IsDisabled)(
        IMFPluginControl2* This,
        DWORD pluginType,
        REFCLSID clsid);

    HRESULT (STDMETHODCALLTYPE *GetDisabledByIndex)(
        IMFPluginControl2* This,
        DWORD pluginType,
        DWORD index,
        CLSID *clsid);

    HRESULT (STDMETHODCALLTYPE *SetDisabled)(
        IMFPluginControl2* This,
        DWORD pluginType,
        REFCLSID clsid,
        WINBOOL disabled);

    /*** IMFPluginControl2 methods ***/
    HRESULT (STDMETHODCALLTYPE *SetPolicy)(
        IMFPluginControl2* This,
        MF_PLUGIN_CONTROL_POLICY policy);

    END_INTERFACE
} IMFPluginControl2Vtbl;
interface IMFPluginControl2 {
    CONST_VTBL IMFPluginControl2Vtbl* lpVtbl;
};

#ifdef COBJMACROS
#ifndef WIDL_C_INLINE_WRAPPERS
/*** IUnknown methods ***/
#define IMFPluginControl2_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
#define IMFPluginControl2_AddRef(This) (This)->lpVtbl->AddRef(This)
#define IMFPluginControl2_Release(This) (This)->lpVtbl->Release(This)
/*** IMFPluginControl methods ***/
#define IMFPluginControl2_GetPreferredClsid(This,pluginType,selector,clsid) (This)->lpVtbl->GetPreferredClsid(This,pluginType,selector,clsid)
#define IMFPluginControl2_GetPreferredClsidByIndex(This,pluginType,index,selector,clsid) (This)->lpVtbl->GetPreferredClsidByIndex(This,pluginType,index,selector,clsid)
#define IMFPluginControl2_SetPreferredClsid(This,pluginType,selector,clsid) (This)->lpVtbl->SetPreferredClsid(This,pluginType,selector,clsid)
#define IMFPluginControl2_IsDisabled(This,pluginType,clsid) (This)->lpVtbl->IsDisabled(This,pluginType,clsid)
#define IMFPluginControl2_GetDisabledByIndex(This,pluginType,index,clsid) (This)->lpVtbl->GetDisabledByIndex(This,pluginType,index,clsid)
#define IMFPluginControl2_SetDisabled(This,pluginType,clsid,disabled) (This)->lpVtbl->SetDisabled(This,pluginType,clsid,disabled)
/*** IMFPluginControl2 methods ***/
#define IMFPluginControl2_SetPolicy(This,policy) (This)->lpVtbl->SetPolicy(This,policy)
#else
/*** IUnknown methods ***/
static FORCEINLINE HRESULT IMFPluginControl2_QueryInterface(IMFPluginControl2* This,REFIID riid,void **ppvObject) {
    return This->lpVtbl->QueryInterface(This,riid,ppvObject);
}
static FORCEINLINE ULONG IMFPluginControl2_AddRef(IMFPluginControl2* This) {
    return This->lpVtbl->AddRef(This);
}
static FORCEINLINE ULONG IMFPluginControl2_Release(IMFPluginControl2* This) {
    return This->lpVtbl->Release(This);
}
/*** IMFPluginControl methods ***/
static FORCEINLINE HRESULT IMFPluginControl2_GetPreferredClsid(IMFPluginControl2* This,DWORD pluginType,LPCWSTR selector,CLSID *clsid) {
    return This->lpVtbl->GetPreferredClsid(This,pluginType,selector,clsid);
}
static FORCEINLINE HRESULT IMFPluginControl2_GetPreferredClsidByIndex(IMFPluginControl2* This,DWORD pluginType,DWORD index,LPWSTR *selector,CLSID *clsid) {
    return This->lpVtbl->GetPreferredClsidByIndex(This,pluginType,index,selector,clsid);
}
static FORCEINLINE HRESULT IMFPluginControl2_SetPreferredClsid(IMFPluginControl2* This,DWORD pluginType,LPCWSTR selector,const CLSID *clsid) {
    return This->lpVtbl->SetPreferredClsid(This,pluginType,selector,clsid);
}
static FORCEINLINE HRESULT IMFPluginControl2_IsDisabled(IMFPluginControl2* This,DWORD pluginType,REFCLSID clsid) {
    return This->lpVtbl->IsDisabled(This,pluginType,clsid);
}
static FORCEINLINE HRESULT IMFPluginControl2_GetDisabledByIndex(IMFPluginControl2* This,DWORD pluginType,DWORD index,CLSID *clsid) {
    return This->lpVtbl->GetDisabledByIndex(This,pluginType,index,clsid);
}
static FORCEINLINE HRESULT IMFPluginControl2_SetDisabled(IMFPluginControl2* This,DWORD pluginType,REFCLSID clsid,WINBOOL disabled) {
    return This->lpVtbl->SetDisabled(This,pluginType,clsid,disabled);
}
/*** IMFPluginControl2 methods ***/
static FORCEINLINE HRESULT IMFPluginControl2_SetPolicy(IMFPluginControl2* This,MF_PLUGIN_CONTROL_POLICY policy) {
    return This->lpVtbl->SetPolicy(This,policy);
}
#endif
#endif

#endif

HRESULT STDMETHODCALLTYPE IMFPluginControl2_SetPolicy_Proxy(
    IMFPluginControl2* This,
    MF_PLUGIN_CONTROL_POLICY policy);
void __RPC_STUB IMFPluginControl2_SetPolicy_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IMFPluginControl2_INTERFACE_DEFINED__ */

#endif

#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
/*****************************************************************************
 * IMFDXGIDeviceManager interface
 */
#ifndef __IMFDXGIDeviceManager_INTERFACE_DEFINED__
#define __IMFDXGIDeviceManager_INTERFACE_DEFINED__

DEFINE_GUID(IID_IMFDXGIDeviceManager, 0xeb533d5d, 0x2db6, 0x40f8, 0x97,0xa9, 0x49,0x46,0x92,0x01,0x4f,0x07);
#if defined(__cplusplus) && !defined(CINTERFACE)
MIDL_INTERFACE("eb533d5d-2db6-40f8-97a9-494692014f07")
IMFDXGIDeviceManager : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE CloseDeviceHandle(
        HANDLE hDevice) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetVideoService(
        HANDLE hDevice,
        REFIID riid,
        void **ppService) = 0;

    virtual HRESULT STDMETHODCALLTYPE LockDevice(
        HANDLE hDevice,
        REFIID riid,
        void **ppUnkDevice,
        WINBOOL fBlock) = 0;

    virtual HRESULT STDMETHODCALLTYPE OpenDeviceHandle(
        HANDLE *phDevice) = 0;

    virtual HRESULT STDMETHODCALLTYPE ResetDevice(
        IUnknown *pUnkDevice,
        UINT resetToken) = 0;

    virtual HRESULT STDMETHODCALLTYPE TestDevice(
        HANDLE hDevice) = 0;

    virtual HRESULT STDMETHODCALLTYPE UnlockDevice(
        HANDLE hDevice,
        WINBOOL fSaveState) = 0;

};
#ifdef __CRT_UUID_DECL
__CRT_UUID_DECL(IMFDXGIDeviceManager, 0xeb533d5d, 0x2db6, 0x40f8, 0x97,0xa9, 0x49,0x46,0x92,0x01,0x4f,0x07)
#endif
#else
typedef struct IMFDXGIDeviceManagerVtbl {
    BEGIN_INTERFACE

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

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

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

    /*** IMFDXGIDeviceManager methods ***/
    HRESULT (STDMETHODCALLTYPE *CloseDeviceHandle)(
        IMFDXGIDeviceManager* This,
        HANDLE hDevice);

    HRESULT (STDMETHODCALLTYPE *GetVideoService)(
        IMFDXGIDeviceManager* This,
        HANDLE hDevice,
        REFIID riid,
        void **ppService);

    HRESULT (STDMETHODCALLTYPE *LockDevice)(
        IMFDXGIDeviceManager* This,
        HANDLE hDevice,
        REFIID riid,
        void **ppUnkDevice,
        WINBOOL fBlock);

    HRESULT (STDMETHODCALLTYPE *OpenDeviceHandle)(
        IMFDXGIDeviceManager* This,
        HANDLE *phDevice);

    HRESULT (STDMETHODCALLTYPE *ResetDevice)(
        IMFDXGIDeviceManager* This,
        IUnknown *pUnkDevice,
        UINT resetToken);

    HRESULT (STDMETHODCALLTYPE *TestDevice)(
        IMFDXGIDeviceManager* This,
        HANDLE hDevice);

    HRESULT (STDMETHODCALLTYPE *UnlockDevice)(
        IMFDXGIDeviceManager* This,
        HANDLE hDevice,
        WINBOOL fSaveState);

    END_INTERFACE
} IMFDXGIDeviceManagerVtbl;
interface IMFDXGIDeviceManager {
    CONST_VTBL IMFDXGIDeviceManagerVtbl* lpVtbl;
};

#ifdef COBJMACROS
#ifndef WIDL_C_INLINE_WRAPPERS
/*** IUnknown methods ***/
#define IMFDXGIDeviceManager_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
#define IMFDXGIDeviceManager_AddRef(This) (This)->lpVtbl->AddRef(This)
#define IMFDXGIDeviceManager_Release(This) (This)->lpVtbl->Release(This)
/*** IMFDXGIDeviceManager methods ***/
#define IMFDXGIDeviceManager_CloseDeviceHandle(This,hDevice) (This)->lpVtbl->CloseDeviceHandle(This,hDevice)
#define IMFDXGIDeviceManager_GetVideoService(This,hDevice,riid,ppService) (This)->lpVtbl->GetVideoService(This,hDevice,riid,ppService)
#define IMFDXGIDeviceManager_LockDevice(This,hDevice,riid,ppUnkDevice,fBlock) (This)->lpVtbl->LockDevice(This,hDevice,riid,ppUnkDevice,fBlock)
#define IMFDXGIDeviceManager_OpenDeviceHandle(This,phDevice) (This)->lpVtbl->OpenDeviceHandle(This,phDevice)
#define IMFDXGIDeviceManager_ResetDevice(This,pUnkDevice,resetToken) (This)->lpVtbl->ResetDevice(This,pUnkDevice,resetToken)
#define IMFDXGIDeviceManager_TestDevice(This,hDevice) (This)->lpVtbl->TestDevice(This,hDevice)
#define IMFDXGIDeviceManager_UnlockDevice(This,hDevice,fSaveState) (This)->lpVtbl->UnlockDevice(This,hDevice,fSaveState)
#else
/*** IUnknown methods ***/
static FORCEINLINE HRESULT IMFDXGIDeviceManager_QueryInterface(IMFDXGIDeviceManager* This,REFIID riid,void **ppvObject) {
    return This->lpVtbl->QueryInterface(This,riid,ppvObject);
}
static FORCEINLINE ULONG IMFDXGIDeviceManager_AddRef(IMFDXGIDeviceManager* This) {
    return This->lpVtbl->AddRef(This);
}
static FORCEINLINE ULONG IMFDXGIDeviceManager_Release(IMFDXGIDeviceManager* This) {
    return This->lpVtbl->Release(This);
}
/*** IMFDXGIDeviceManager methods ***/
static FORCEINLINE HRESULT IMFDXGIDeviceManager_CloseDeviceHandle(IMFDXGIDeviceManager* This,HANDLE hDevice) {
    return This->lpVtbl->CloseDeviceHandle(This,hDevice);
}
static FORCEINLINE HRESULT IMFDXGIDeviceManager_GetVideoService(IMFDXGIDeviceManager* This,HANDLE hDevice,REFIID riid,void **ppService) {
    return This->lpVtbl->GetVideoService(This,hDevice,riid,ppService);
}
static FORCEINLINE HRESULT IMFDXGIDeviceManager_LockDevice(IMFDXGIDeviceManager* This,HANDLE hDevice,REFIID riid,void **ppUnkDevice,WINBOOL fBlock) {
    return This->lpVtbl->LockDevice(This,hDevice,riid,ppUnkDevice,fBlock);
}
static FORCEINLINE HRESULT IMFDXGIDeviceManager_OpenDeviceHandle(IMFDXGIDeviceManager* This,HANDLE *phDevice) {
    return This->lpVtbl->OpenDeviceHandle(This,phDevice);
}
static FORCEINLINE HRESULT IMFDXGIDeviceManager_ResetDevice(IMFDXGIDeviceManager* This,IUnknown *pUnkDevice,UINT resetToken) {
    return This->lpVtbl->ResetDevice(This,pUnkDevice,resetToken);
}
static FORCEINLINE HRESULT IMFDXGIDeviceManager_TestDevice(IMFDXGIDeviceManager* This,HANDLE hDevice) {
    return This->lpVtbl->TestDevice(This,hDevice);
}
static FORCEINLINE HRESULT IMFDXGIDeviceManager_UnlockDevice(IMFDXGIDeviceManager* This,HANDLE hDevice,WINBOOL fSaveState) {
    return This->lpVtbl->UnlockDevice(This,hDevice,fSaveState);
}
#endif
#endif

#endif

HRESULT STDMETHODCALLTYPE IMFDXGIDeviceManager_CloseDeviceHandle_Proxy(
    IMFDXGIDeviceManager* This,
    HANDLE hDevice);
void __RPC_STUB IMFDXGIDeviceManager_CloseDeviceHandle_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFDXGIDeviceManager_GetVideoService_Proxy(
    IMFDXGIDeviceManager* This,
    HANDLE hDevice,
    REFIID riid,
    void **ppService);
void __RPC_STUB IMFDXGIDeviceManager_GetVideoService_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFDXGIDeviceManager_LockDevice_Proxy(
    IMFDXGIDeviceManager* This,
    HANDLE hDevice,
    REFIID riid,
    void **ppUnkDevice,
    WINBOOL fBlock);
void __RPC_STUB IMFDXGIDeviceManager_LockDevice_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFDXGIDeviceManager_OpenDeviceHandle_Proxy(
    IMFDXGIDeviceManager* This,
    HANDLE *phDevice);
void __RPC_STUB IMFDXGIDeviceManager_OpenDeviceHandle_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFDXGIDeviceManager_ResetDevice_Proxy(
    IMFDXGIDeviceManager* This,
    IUnknown *pUnkDevice,
    UINT resetToken);
void __RPC_STUB IMFDXGIDeviceManager_ResetDevice_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFDXGIDeviceManager_TestDevice_Proxy(
    IMFDXGIDeviceManager* This,
    HANDLE hDevice);
void __RPC_STUB IMFDXGIDeviceManager_TestDevice_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT STDMETHODCALLTYPE IMFDXGIDeviceManager_UnlockDevice_Proxy(
    IMFDXGIDeviceManager* This,
    HANDLE hDevice,
    WINBOOL fSaveState);
void __RPC_STUB IMFDXGIDeviceManager_UnlockDevice_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IMFDXGIDeviceManager_INTERFACE_DEFINED__ */

#endif

#endif
/* Begin additional prototypes for all interfaces */

ULONG           __RPC_USER BSTR_UserSize     (ULONG *, ULONG, BSTR *);
unsigned char * __RPC_USER BSTR_UserMarshal  (ULONG *, unsigned char *, BSTR *);
unsigned char * __RPC_USER BSTR_UserUnmarshal(ULONG *, unsigned char *, BSTR *);
void            __RPC_USER BSTR_UserFree     (ULONG *, BSTR *);
ULONG           __RPC_USER LPSAFEARRAY_UserSize     (ULONG *, ULONG, LPSAFEARRAY *);
unsigned char * __RPC_USER LPSAFEARRAY_UserMarshal  (ULONG *, unsigned char *, LPSAFEARRAY *);
unsigned char * __RPC_USER LPSAFEARRAY_UserUnmarshal(ULONG *, unsigned char *, LPSAFEARRAY *);
void            __RPC_USER LPSAFEARRAY_UserFree     (ULONG *, LPSAFEARRAY *);

/* End additional prototypes */

#ifdef __cplusplus
}
#endif

#endif /* __mfobjects_h__ */