diff --git a/360/xaudio-c/objbase.h b/360/xaudio-c/objbase.h new file mode 100644 index 0000000000..b07913be81 --- /dev/null +++ b/360/xaudio-c/objbase.h @@ -0,0 +1,1003 @@ +#if !defined( _XOBJBASE_H_ ) +#define _XOBJBASE_H_ + +#include + +#if _MSC_VER > 1000 +#pragma once +#endif + +#define __RPC_FAR + +typedef unsigned char byte; +typedef unsigned char boolean; + +typedef double DOUBLE; + +#ifdef CONST_VTABLE +#define CONST_VTBL const +#else +#define CONST_VTBL +#endif + +/**************************************************************************** + * Special things for VC5 Com support + ****************************************************************************/ + +#ifndef DECLSPEC_SELECTANY +#if (_MSC_VER >= 1100) +#define DECLSPEC_SELECTANY __declspec(selectany) +#else +#define DECLSPEC_SELECTANY +#endif +#endif + +#ifndef DECLSPEC_NOVTABLE +#if (_MSC_VER >= 1100) && defined(__cplusplus) +#define DECLSPEC_NOVTABLE __declspec(novtable) +#else +#define DECLSPEC_NOVTABLE +#endif +#endif + +#ifndef DECLSPEC_UUID +#if (_MSC_VER >= 1100) && defined(__cplusplus) +#define DECLSPEC_UUID(x) __declspec(uuid(x)) +#else +#define DECLSPEC_UUID(x) +#endif +#endif + +#define MIDL_INTERFACE(x) struct DECLSPEC_UUID(x) DECLSPEC_NOVTABLE + +#if _MSC_VER >= 1100 +#define EXTERN_GUID(itf,l1,s1,s2,c1,c2,c3,c4,c5,c6,c7,c8) \ + EXTERN_C const IID DECLSPEC_SELECTANY itf = {l1,s1,s2,{c1,c2,c3,c4,c5,c6,c7,c8}} +#else +#define EXTERN_GUID(itf,l1,s1,s2,c1,c2,c3,c4,c5,c6,c7,c8) EXTERN_C const IID itf +#endif + +#include + +#define WINOLEAPI EXTERN_C DECLSPEC_IMPORT HRESULT STDAPICALLTYPE +#define WINOLEAPI_(type) EXTERN_C DECLSPEC_IMPORT type STDAPICALLTYPE + +/****** Interface Declaration ***********************************************/ + +/* + * These are macros for declaring interfaces. They exist so that + * a single definition of the interface is simulataneously a proper + * declaration of the interface structures (C++ abstract classes) + * for both C and C++. + * + * DECLARE_INTERFACE(iface) is used to declare an interface that does + * not derive from a base interface. + * DECLARE_INTERFACE_(iface, baseiface) is used to declare an interface + * that does derive from a base interface. + * + * By default if the source file has a .c extension the C version of + * the interface declaratations will be expanded; if it has a .cpp + * extension the C++ version will be expanded. if you want to force + * the C version expansion even though the source file has a .cpp + * extension, then define the macro "CINTERFACE". + * eg. cl -DCINTERFACE file.cpp + * + * + * Example C expansion: + * + * typedef struct IClassFactory + * { + * const struct IClassFactoryVtbl FAR* lpVtbl; + * } IClassFactory; + * + * typedef struct IClassFactoryVtbl IClassFactoryVtbl; + * + * struct IClassFactoryVtbl + * { + * HRESULT (STDMETHODCALLTYPE * QueryInterface) ( + * IClassFactory FAR* This, + * IID FAR* riid, + * LPVOID FAR* ppvObj) ; + * ULONG (STDMETHODCALLTYPE * AddRef) (IClassFactory FAR* This) ; + * ULONG (STDMETHODCALLTYPE * Release) (IClassFactory FAR* This) ; + * HRESULT (STDMETHODCALLTYPE * CreateInstance) ( + * IClassFactory FAR* This, + * LPUNKNOWN pUnkOuter, + * IID FAR* riid, + * LPVOID FAR* ppvObject); + * HRESULT (STDMETHODCALLTYPE * LockServer) ( + * IClassFactory FAR* This, + * BOOL fLock); + * }; + */ + +#if defined(__cplusplus) && !defined(CINTERFACE) +//#define interface struct FAR +#define interface struct +#define STDMETHOD(method) virtual HRESULT STDMETHODCALLTYPE method +#define STDMETHOD_(type,method) virtual type STDMETHODCALLTYPE method +#define STDMETHODV(method) virtual HRESULT STDMETHODVCALLTYPE method +#define STDMETHODV_(type,method) virtual type STDMETHODVCALLTYPE method +#define PURE = 0 +#define THIS_ +#define THIS void +#define DECLARE_INTERFACE(iface) interface DECLSPEC_NOVTABLE iface +#define DECLARE_INTERFACE_(iface, baseiface) interface DECLSPEC_NOVTABLE iface : public baseiface + + +#if !defined(BEGIN_INTERFACE) + #define BEGIN_INTERFACE + #define END_INTERFACE +#endif + +#else + +#define interface struct + +#define STDMETHOD(method) HRESULT (STDMETHODCALLTYPE * method) +#define STDMETHOD_(type,method) type (STDMETHODCALLTYPE * method) +#define STDMETHODV(method) HRESULT (STDMETHODVCALLTYPE * method) +#define STDMETHODV_(type,method) type (STDMETHODVCALLTYPE * method) + +#if !defined(BEGIN_INTERFACE) + #define BEGIN_INTERFACE + #define END_INTERFACE +#endif + + +#define PURE +#define THIS_ INTERFACE FAR* This, +#define THIS INTERFACE FAR* This +#ifdef CONST_VTABLE +#undef CONST_VTBL +#define CONST_VTBL const +#define DECLARE_INTERFACE(iface) typedef interface iface { \ + const struct iface##Vtbl FAR* lpVtbl; \ + } iface; \ + typedef const struct iface##Vtbl iface##Vtbl; \ + const struct iface##Vtbl +#else +#undef CONST_VTBL +#define CONST_VTBL +#define DECLARE_INTERFACE(iface) typedef interface iface { \ + struct iface##Vtbl FAR* lpVtbl; \ + } iface; \ + typedef struct iface##Vtbl iface##Vtbl; \ + struct iface##Vtbl +#endif +#define DECLARE_INTERFACE_(iface, baseiface) DECLARE_INTERFACE(iface) + +#endif + + + + +/****** Additional basic types **********************************************/ + + +#ifndef FARSTRUCT +#ifdef __cplusplus +#define FARSTRUCT FAR +#else +#define FARSTRUCT +#endif // __cplusplus +#endif // FARSTRUCT + + + +#ifndef HUGEP +#if defined(_WIN32) || defined(_MPPC_) +#define HUGEP +#else +#define HUGEP __huge +#endif // WIN32 +#endif // HUGEP + + +#include + +#define LISet32(li, v) ((li).HighPart = (v) < 0 ? -1 : 0, (li).LowPart = (v)) + +#define ULISet32(li, v) ((li).HighPart = 0, (li).LowPart = (v)) + + +#if defined(_WIN32) && !defined(OLE2ANSI) +typedef WCHAR OLECHAR; + +typedef /* [string] */ OLECHAR __RPC_FAR *LPOLESTR; + +typedef /* [string] */ const OLECHAR __RPC_FAR *LPCOLESTR; + +#define OLESTR(str) L##str + +#else + +typedef char OLECHAR; +typedef LPSTR LPOLESTR; +typedef LPCSTR LPCOLESTR; +#define OLESTR(str) str +#endif + + +/* Forward Declarations */ + +#ifndef __IUnknown_FWD_DEFINED__ +#define __IUnknown_FWD_DEFINED__ +typedef interface IUnknown IUnknown; +#endif /* __IUnknown_FWD_DEFINED__ */ + + +#ifndef __IUnknown_INTERFACE_DEFINED__ +#define __IUnknown_INTERFACE_DEFINED__ + + +/* interface IUnknown */ +/* [unique][uuid][object][local] */ + +typedef /* [unique] */ IUnknown __RPC_FAR *LPUNKNOWN; +typedef /* [unique] */ IUnknown __RPC_FAR *PUNKNOWN; + +////////////////////////////////////////////////////////////////// +// IID_IUnknown and all other system IIDs are provided in UUID.LIB +// Link that library in with your proxies, clients and servers +////////////////////////////////////////////////////////////////// + +#if (_MSC_VER >= 1100) && defined(__cplusplus) && !defined(CINTERFACE) + EXTERN_C const IID IID_IUnknown; + extern "C++" + { + MIDL_INTERFACE("00000000-0000-0000-C000-000000000046") + IUnknown + { + public: + BEGIN_INTERFACE + virtual HRESULT STDMETHODCALLTYPE QueryInterface( + /* [in] */ __in REFIID riid, + /* [iid_is][out] */ __deref_out void __RPC_FAR *__RPC_FAR *ppvObject) = 0; + + virtual ULONG STDMETHODCALLTYPE AddRef( void) = 0; + + virtual ULONG STDMETHODCALLTYPE Release( void) = 0; + + template + HRESULT STDMETHODCALLTYPE QueryInterface(Q** pp) + { + return QueryInterface(__uuidof(Q), (void **)pp); + } + + END_INTERFACE + }; + } // extern C++ +#else // VC6 hack + +EXTERN_C const IID IID_IUnknown; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("00000000-0000-0000-C000-000000000046") + IUnknown + { + public: + BEGIN_INTERFACE + virtual HRESULT STDMETHODCALLTYPE QueryInterface( + /* [in] */ __in REFIID riid, + /* [iid_is][out] */ __deref_out void __RPC_FAR *__RPC_FAR *ppvObject) = 0; + + virtual ULONG STDMETHODCALLTYPE AddRef( void) = 0; + + virtual ULONG STDMETHODCALLTYPE Release( void) = 0; + + END_INTERFACE + }; + +#else /* C style interface */ + + typedef struct IUnknownVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE __RPC_FAR *QueryInterface )( + IUnknown __RPC_FAR * This, + /* [in] */ __in REFIID riid, + /* [iid_is][out] */ __deref_out void __RPC_FAR *__RPC_FAR *ppvObject); + + ULONG ( STDMETHODCALLTYPE __RPC_FAR *AddRef )( + IUnknown __RPC_FAR * This); + + ULONG ( STDMETHODCALLTYPE __RPC_FAR *Release )( + IUnknown __RPC_FAR * This); + + END_INTERFACE + } IUnknownVtbl; + + interface IUnknown + { + CONST_VTBL struct IUnknownVtbl __RPC_FAR *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IUnknown_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define IUnknown_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define IUnknown_Release(This) \ + (This)->lpVtbl -> Release(This) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + +#endif /* __IUnknown_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_unknwn_0005 */ +/* [local] */ + +#endif // VC6 hack + + +#ifndef __ISequentialStream_FWD_DEFINED__ +#define __ISequentialStream_FWD_DEFINED__ +typedef interface ISequentialStream ISequentialStream; +#endif /* __ISequentialStream_FWD_DEFINED__ */ + + +#ifndef __ISequentialStream_INTERFACE_DEFINED__ +#define __ISequentialStream_INTERFACE_DEFINED__ + +/* interface ISequentialStream */ +/* [unique][uuid][object] */ + + +EXTERN_C const IID IID_ISequentialStream; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("0c733a30-2a1c-11ce-ade5-00aa0044773d") + ISequentialStream : public IUnknown + { + public: + virtual /* [local] */ HRESULT STDMETHODCALLTYPE Read( + /* [length_is][size_is][out] */ __out_bcount_part_opt(cb, *pcbRead) void __RPC_FAR *pv, + /* [in] */ __in ULONG cb, + /* [out] */ __out_opt ULONG __RPC_FAR *pcbRead) = 0; + + virtual /* [local] */ HRESULT STDMETHODCALLTYPE Write( + /* [size_is][in] */ __in_bcount_opt(cb) const void __RPC_FAR *pv, + /* [in] */ __in ULONG cb, + /* [out] */ __out_opt ULONG __RPC_FAR *pcbWritten) = 0; + + }; + +#else /* C style interface */ + + typedef struct ISequentialStreamVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE __RPC_FAR *QueryInterface )( + ISequentialStream __RPC_FAR * This, + /* [in] */ __in REFIID riid, + /* [iid_is][out] */ __deref_out void __RPC_FAR *__RPC_FAR *ppvObject); + + ULONG ( STDMETHODCALLTYPE __RPC_FAR *AddRef )( + ISequentialStream __RPC_FAR * This); + + ULONG ( STDMETHODCALLTYPE __RPC_FAR *Release )( + ISequentialStream __RPC_FAR * This); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE __RPC_FAR *Read )( + ISequentialStream __RPC_FAR * This, + /* [length_is][size_is][out] */ __out_bcount_part_opt(cb, *pcbRead) void __RPC_FAR *pv, + /* [in] */ __in ULONG cb, + /* [out] */ __out_opt ULONG __RPC_FAR *pcbRead); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE __RPC_FAR *Write )( + ISequentialStream __RPC_FAR * This, + /* [size_is][in] */ __in_bcount_opt(cb) const void __RPC_FAR *pv, + /* [in] */ __in ULONG cb, + /* [out] */ __out_opt ULONG __RPC_FAR *pcbWritten); + + END_INTERFACE + } ISequentialStreamVtbl; + + interface ISequentialStream + { + CONST_VTBL struct ISequentialStreamVtbl __RPC_FAR *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define ISequentialStream_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define ISequentialStream_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define ISequentialStream_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define ISequentialStream_Read(This,pv,cb,pcbRead) \ + (This)->lpVtbl -> Read(This,pv,cb,pcbRead) + +#define ISequentialStream_Write(This,pv,cb,pcbWritten) \ + (This)->lpVtbl -> Write(This,pv,cb,pcbWritten) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + +#endif /* __ISequentialStream_INTERFACE_DEFINED__ */ + + + +#ifndef __IStream_FWD_DEFINED__ +#define __IStream_FWD_DEFINED__ +typedef interface IStream IStream; +#endif /* __IStream_FWD_DEFINED__ */ + + +#ifndef __IStream_INTERFACE_DEFINED__ +#define __IStream_INTERFACE_DEFINED__ + +/* interface IStream */ +/* [unique][uuid][object] */ + +typedef /* [unique] */ IStream __RPC_FAR *LPSTREAM; + +typedef struct tagSTATSTG + { + LPOLESTR pwcsName; + DWORD type; + ULARGE_INTEGER cbSize; + FILETIME mtime; + FILETIME ctime; + FILETIME atime; + DWORD grfMode; + DWORD grfLocksSupported; + CLSID clsid; + DWORD grfStateBits; + DWORD reserved; + } STATSTG; + +typedef +enum tagSTGTY + { STGTY_STORAGE = 1, + STGTY_STREAM = 2, + STGTY_LOCKBYTES = 3, + STGTY_PROPERTY = 4 + } STGTY; + +typedef +enum tagSTREAM_SEEK + { STREAM_SEEK_SET = 0, + STREAM_SEEK_CUR = 1, + STREAM_SEEK_END = 2 + } STREAM_SEEK; + +typedef +enum tagLOCKTYPE + { LOCK_WRITE = 1, + LOCK_EXCLUSIVE = 2, + LOCK_ONLYONCE = 4 + } LOCKTYPE; + + +EXTERN_C const IID IID_IStream; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("0000000c-0000-0000-C000-000000000046") + IStream : public ISequentialStream + { + public: + virtual /* [local] */ HRESULT STDMETHODCALLTYPE Seek( + /* [in] */ __in LARGE_INTEGER dlibMove, + /* [in] */ __in DWORD dwOrigin, + /* [out] */ __out_opt ULARGE_INTEGER __RPC_FAR *plibNewPosition) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetSize( + /* [in] */ __in ULARGE_INTEGER libNewSize) = 0; + + virtual /* [local] */ HRESULT STDMETHODCALLTYPE CopyTo( + /* [unique][in] */ __in IStream __RPC_FAR *pstm, + /* [in] */ __in ULARGE_INTEGER cb, + /* [out] */ __out_opt ULARGE_INTEGER __RPC_FAR *pcbRead, + /* [out] */ __out_opt ULARGE_INTEGER __RPC_FAR *pcbWritten) = 0; + + virtual HRESULT STDMETHODCALLTYPE Commit( + /* [in] */ __in DWORD grfCommitFlags) = 0; + + virtual HRESULT STDMETHODCALLTYPE Revert( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE LockRegion( + /* [in] */ __in ULARGE_INTEGER libOffset, + /* [in] */ __in ULARGE_INTEGER cb, + /* [in] */ __in DWORD dwLockType) = 0; + + virtual HRESULT STDMETHODCALLTYPE UnlockRegion( + /* [in] */ __in ULARGE_INTEGER libOffset, + /* [in] */ __in ULARGE_INTEGER cb, + /* [in] */ __in DWORD dwLockType) = 0; + + virtual HRESULT STDMETHODCALLTYPE Stat( + /* [out] */ __out STATSTG __RPC_FAR *pstatstg, + /* [in] */ __in DWORD grfStatFlag) = 0; + + virtual HRESULT STDMETHODCALLTYPE Clone( + /* [out] */ __deref_out_opt IStream __RPC_FAR *__RPC_FAR *ppstm) = 0; + + }; + +#else /* C style interface */ + + typedef struct IStreamVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE __RPC_FAR *QueryInterface )( + IStream __RPC_FAR * This, + /* [in] */ __in REFIID riid, + /* [iid_is][out] */ __deref_out void __RPC_FAR *__RPC_FAR *ppvObject); + + ULONG ( STDMETHODCALLTYPE __RPC_FAR *AddRef )( + IStream __RPC_FAR * This); + + ULONG ( STDMETHODCALLTYPE __RPC_FAR *Release )( + IStream __RPC_FAR * This); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE __RPC_FAR *Read )( + IStream __RPC_FAR * This, + /* [length_is][size_is][out] */ __out_bcount_part_opt(cb, *pcbRead) void __RPC_FAR *pv, + /* [in] */ __in ULONG cb, + /* [out] */ __out_opt ULONG __RPC_FAR *pcbRead); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE __RPC_FAR *Write )( + IStream __RPC_FAR * This, + /* [size_is][in] */ __in_bcount_opt(cb) const void __RPC_FAR *pv, + /* [in] */ __in ULONG cb, + /* [out] */ __out_opt ULONG __RPC_FAR *pcbWritten); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE __RPC_FAR *Seek )( + IStream __RPC_FAR * This, + /* [in] */ __in LARGE_INTEGER dlibMove, + /* [in] */ __in DWORD dwOrigin, + /* [out] */ __out_opt ULARGE_INTEGER __RPC_FAR *plibNewPosition); + + HRESULT ( STDMETHODCALLTYPE __RPC_FAR *SetSize )( + IStream __RPC_FAR * This, + /* [in] */ __in ULARGE_INTEGER libNewSize); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE __RPC_FAR *CopyTo )( + IStream __RPC_FAR * This, + /* [unique][in] */ __in IStream __RPC_FAR *pstm, + /* [in] */ __in ULARGE_INTEGER cb, + /* [out] */ __out_opt ULARGE_INTEGER __RPC_FAR *pcbRead, + /* [out] */ __out_opt ULARGE_INTEGER __RPC_FAR *pcbWritten); + + HRESULT ( STDMETHODCALLTYPE __RPC_FAR *Commit )( + IStream __RPC_FAR * This, + /* [in] */ __in DWORD grfCommitFlags); + + HRESULT ( STDMETHODCALLTYPE __RPC_FAR *Revert )( + IStream __RPC_FAR * This); + + HRESULT ( STDMETHODCALLTYPE __RPC_FAR *LockRegion )( + IStream __RPC_FAR * This, + /* [in] */ __in ULARGE_INTEGER libOffset, + /* [in] */ __in ULARGE_INTEGER cb, + /* [in] */ __in DWORD dwLockType); + + HRESULT ( STDMETHODCALLTYPE __RPC_FAR *UnlockRegion )( + IStream __RPC_FAR * This, + /* [in] */ __in ULARGE_INTEGER libOffset, + /* [in] */ __in ULARGE_INTEGER cb, + /* [in] */ __in DWORD dwLockType); + + HRESULT ( STDMETHODCALLTYPE __RPC_FAR *Stat )( + IStream __RPC_FAR * This, + /* [out] */ __out STATSTG __RPC_FAR *pstatstg, + /* [in] */ __in DWORD grfStatFlag); + + HRESULT ( STDMETHODCALLTYPE __RPC_FAR *Clone )( + IStream __RPC_FAR * This, + /* [out] */ __deref_out_opt IStream __RPC_FAR *__RPC_FAR *ppstm); + + END_INTERFACE + } IStreamVtbl; + + interface IStream + { + CONST_VTBL struct IStreamVtbl __RPC_FAR *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IStream_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define IStream_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define IStream_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define IStream_Read(This,pv,cb,pcbRead) \ + (This)->lpVtbl -> Read(This,pv,cb,pcbRead) + +#define IStream_Write(This,pv,cb,pcbWritten) \ + (This)->lpVtbl -> Write(This,pv,cb,pcbWritten) + + +#define IStream_Seek(This,dlibMove,dwOrigin,plibNewPosition) \ + (This)->lpVtbl -> Seek(This,dlibMove,dwOrigin,plibNewPosition) + +#define IStream_SetSize(This,libNewSize) \ + (This)->lpVtbl -> SetSize(This,libNewSize) + +#define IStream_CopyTo(This,pstm,cb,pcbRead,pcbWritten) \ + (This)->lpVtbl -> CopyTo(This,pstm,cb,pcbRead,pcbWritten) + +#define IStream_Commit(This,grfCommitFlags) \ + (This)->lpVtbl -> Commit(This,grfCommitFlags) + +#define IStream_Revert(This) \ + (This)->lpVtbl -> Revert(This) + +#define IStream_LockRegion(This,libOffset,cb,dwLockType) \ + (This)->lpVtbl -> LockRegion(This,libOffset,cb,dwLockType) + +#define IStream_UnlockRegion(This,libOffset,cb,dwLockType) \ + (This)->lpVtbl -> UnlockRegion(This,libOffset,cb,dwLockType) + +#define IStream_Stat(This,pstatstg,grfStatFlag) \ + (This)->lpVtbl -> Stat(This,pstatstg,grfStatFlag) + +#define IStream_Clone(This,ppstm) \ + (This)->lpVtbl -> Clone(This,ppstm) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + +#endif /* __IStream_INTERFACE_DEFINED__ */ + + +#ifndef __IClassFactory_FWD_DEFINED__ +#define __IClassFactory_FWD_DEFINED__ +typedef interface IClassFactory IClassFactory; +#endif /* __IClassFactory_FWD_DEFINED__ */ + + +#ifndef __IClassFactory_INTERFACE_DEFINED__ +#define __IClassFactory_INTERFACE_DEFINED__ + +/* interface IClassFactory */ +/* [unique][uuid][object] */ + +typedef /* [unique] */ IClassFactory __RPC_FAR *LPCLASSFACTORY; + + +EXTERN_C const IID IID_IClassFactory; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("00000001-0000-0000-C000-000000000046") + IClassFactory : public IUnknown + { + public: + virtual /* [local] */ HRESULT STDMETHODCALLTYPE CreateInstance( + /* [unique][in] */ __in_opt IUnknown __RPC_FAR *pUnkOuter, + /* [in] */ __in REFIID riid, + /* [iid_is][out] */ __deref_out void __RPC_FAR *__RPC_FAR *ppvObject) = 0; + + virtual /* [local] */ HRESULT STDMETHODCALLTYPE LockServer( + /* [in] */ __in BOOL fLock) = 0; + + }; + +#else /* C style interface */ + + typedef struct IClassFactoryVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE __RPC_FAR *QueryInterface )( + IClassFactory __RPC_FAR * This, + /* [in] */ __in REFIID riid, + /* [iid_is][out] */ __deref_out void __RPC_FAR *__RPC_FAR *ppvObject); + + ULONG ( STDMETHODCALLTYPE __RPC_FAR *AddRef )( + IClassFactory __RPC_FAR * This); + + ULONG ( STDMETHODCALLTYPE __RPC_FAR *Release )( + IClassFactory __RPC_FAR * This); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE __RPC_FAR *CreateInstance )( + IClassFactory __RPC_FAR * This, + /* [unique][in] */ __in_opt IUnknown __RPC_FAR *pUnkOuter, + /* [in] */ __in REFIID riid, + /* [iid_is][out] */ __deref_out void __RPC_FAR *__RPC_FAR *ppvObject); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE __RPC_FAR *LockServer )( + IClassFactory __RPC_FAR * This, + /* [in] */ __in BOOL fLock); + + END_INTERFACE + } IClassFactoryVtbl; + + interface IClassFactory + { + CONST_VTBL struct IClassFactoryVtbl __RPC_FAR *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IClassFactory_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define IClassFactory_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define IClassFactory_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define IClassFactory_CreateInstance(This,pUnkOuter,riid,ppvObject) \ + (This)->lpVtbl -> CreateInstance(This,pUnkOuter,riid,ppvObject) + +#define IClassFactory_LockServer(This,fLock) \ + (This)->lpVtbl -> LockServer(This,fLock) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + +#endif /* __IClassFactory_INTERFACE_DEFINED__ */ + + + +#ifndef __IPersist_FWD_DEFINED__ +#define __IPersist_FWD_DEFINED__ +typedef interface IPersist IPersist; +#endif /* __IPersist_FWD_DEFINED__ */ + + +#ifndef __IPersist_INTERFACE_DEFINED__ +#define __IPersist_INTERFACE_DEFINED__ + +/* interface IPersist */ +/* [uuid][object] */ + +typedef /* [unique] */ IPersist __RPC_FAR *LPPERSIST; + + +EXTERN_C const IID IID_IPersist; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("0000010c-0000-0000-C000-000000000046") + IPersist : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetClassID( + /* [out] */ __out CLSID __RPC_FAR *pClassID) = 0; + + }; + +#else /* C style interface */ + + typedef struct IPersistVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE __RPC_FAR *QueryInterface )( + IPersist __RPC_FAR * This, + /* [in] */ __in REFIID riid, + /* [iid_is][out] */ __deref_out void __RPC_FAR *__RPC_FAR *ppvObject); + + ULONG ( STDMETHODCALLTYPE __RPC_FAR *AddRef )( + IPersist __RPC_FAR * This); + + ULONG ( STDMETHODCALLTYPE __RPC_FAR *Release )( + IPersist __RPC_FAR * This); + + HRESULT ( STDMETHODCALLTYPE __RPC_FAR *GetClassID )( + IPersist __RPC_FAR * This, + /* [out] */ __out CLSID __RPC_FAR *pClassID); + + END_INTERFACE + } IPersistVtbl; + + interface IPersist + { + CONST_VTBL struct IPersistVtbl __RPC_FAR *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IPersist_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define IPersist_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define IPersist_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define IPersist_GetClassID(This,pClassID) \ + (This)->lpVtbl -> GetClassID(This,pClassID) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + +#endif /* __IPersist_INTERFACE_DEFINED__ */ + + + + +#ifndef __IPersistStream_FWD_DEFINED__ +#define __IPersistStream_FWD_DEFINED__ +typedef interface IPersistStream IPersistStream; +#endif /* __IPersistStream_FWD_DEFINED__ */ + + +#ifndef __IPersistStream_INTERFACE_DEFINED__ +#define __IPersistStream_INTERFACE_DEFINED__ + +/* interface IPersistStream */ +/* [unique][uuid][object] */ + +typedef /* [unique] */ IPersistStream __RPC_FAR *LPPERSISTSTREAM; + + +EXTERN_C const IID IID_IPersistStream; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("00000109-0000-0000-C000-000000000046") + IPersistStream : public IPersist + { + public: + virtual HRESULT STDMETHODCALLTYPE IsDirty( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE Load( + /* [unique][in] */ __in_opt IStream __RPC_FAR *pStm) = 0; + + virtual HRESULT STDMETHODCALLTYPE Save( + /* [unique][in] */ __in_opt IStream __RPC_FAR *pStm, + /* [in] */ __in BOOL fClearDirty) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetSizeMax( + /* [out] */ __out ULARGE_INTEGER __RPC_FAR *pcbSize) = 0; + + }; + +#else /* C style interface */ + + typedef struct IPersistStreamVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE __RPC_FAR *QueryInterface )( + IPersistStream __RPC_FAR * This, + /* [in] */ __in REFIID riid, + /* [iid_is][out] */ __deref_out void __RPC_FAR *__RPC_FAR *ppvObject); + + ULONG ( STDMETHODCALLTYPE __RPC_FAR *AddRef )( + IPersistStream __RPC_FAR * This); + + ULONG ( STDMETHODCALLTYPE __RPC_FAR *Release )( + IPersistStream __RPC_FAR * This); + + HRESULT ( STDMETHODCALLTYPE __RPC_FAR *GetClassID )( + IPersistStream __RPC_FAR * This, + /* [out] */ __out CLSID __RPC_FAR *pClassID); + + HRESULT ( STDMETHODCALLTYPE __RPC_FAR *IsDirty )( + IPersistStream __RPC_FAR * This); + + HRESULT ( STDMETHODCALLTYPE __RPC_FAR *Load )( + IPersistStream __RPC_FAR * This, + /* [unique][in] */ __in_opt IStream __RPC_FAR *pStm); + + HRESULT ( STDMETHODCALLTYPE __RPC_FAR *Save )( + IPersistStream __RPC_FAR * This, + /* [unique][in] */ __in_opt IStream __RPC_FAR *pStm, + /* [in] */ __in BOOL fClearDirty); + + HRESULT ( STDMETHODCALLTYPE __RPC_FAR *GetSizeMax )( + IPersistStream __RPC_FAR * This, + /* [out] */ __out ULARGE_INTEGER __RPC_FAR *pcbSize); + + END_INTERFACE + } IPersistStreamVtbl; + + interface IPersistStream + { + CONST_VTBL struct IPersistStreamVtbl __RPC_FAR *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IPersistStream_QueryInterface(This,riid,ppvObject) \ + (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) + +#define IPersistStream_AddRef(This) \ + (This)->lpVtbl -> AddRef(This) + +#define IPersistStream_Release(This) \ + (This)->lpVtbl -> Release(This) + + +#define IPersistStream_GetClassID(This,pClassID) \ + (This)->lpVtbl -> GetClassID(This,pClassID) + + +#define IPersistStream_IsDirty(This) \ + (This)->lpVtbl -> IsDirty(This) + +#define IPersistStream_Load(This,pStm) \ + (This)->lpVtbl -> Load(This,pStm) + +#define IPersistStream_Save(This,pStm,fClearDirty) \ + (This)->lpVtbl -> Save(This,pStm,fClearDirty) + +#define IPersistStream_GetSizeMax(This,pcbSize) \ + (This)->lpVtbl -> GetSizeMax(This,pcbSize) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + +#endif /* __IPersistStream_INTERFACE_DEFINED__ */ + + + +#include + +#ifndef INITGUID +#include +#endif + +#ifndef RC_INVOKED +#include +#endif // RC_INVOKED + +#endif // _XOBJBASE_H_ diff --git a/360/xaudio-c/xaudio.h b/360/xaudio-c/xaudio.h index 74a335d096..496dd1fc16 100644 --- a/360/xaudio-c/xaudio.h +++ b/360/xaudio-c/xaudio.h @@ -18,9 +18,8 @@ DEFINE_IID(IXAudio2, 8bcf1f58, 9fe7, 4583, 8a, c6, e2, ad, c4, 65, c8, bb); // Ignore the rest of this header if only the GUID definitions were requested #ifndef GUID_DEFS_ONLY -#include // Xbox COM declarations (IUnknown, etc) +#include "objbase.h" // Xbox COM declarations (IUnknown, etc) -#include // Markers for documenting API semantics #include // Basic audio data types and constants #include // Data types and constants for XMA2 audio