From 7de6266d3cee23493500fef33781fd446b8a8279 Mon Sep 17 00:00:00 2001 From: Jacek Caban Date: Tue, 24 May 2016 18:49:47 +0200 Subject: Updated imported headers to current Wine version. diff --git a/mingw-w64-headers/direct-x/include/amstream.idl b/mingw-w64-headers/direct-x/include/amstream.idl index 2f32d44..d4e5e35 100644 --- a/mingw-w64-headers/direct-x/include/amstream.idl +++ b/mingw-w64-headers/direct-x/include/amstream.idl @@ -76,9 +76,9 @@ interface IDirectShowStream : IDispatch [propget, id(1), helpstring("property FileName")] HRESULT FileName([out, retval] BSTR *pVal); [propput, id(1), helpstring("property FileName")] HRESULT FileName([in] BSTR newVal); [propget, id(2), helpstring("property Video")] HRESULT Video([out, retval] OUTPUT_STATE *pVal); - [propput, id(2), helpstring("propetry Video")] HRESULT Video([in] OUTPUT_STATE newVal); + [propput, id(2), helpstring("property Video")] HRESULT Video([in] OUTPUT_STATE newVal); [propget, id(3), helpstring("property Audio")] HRESULT Audio([out, retval] OUTPUT_STATE *pVal); - [propput, id(3), helpstring("propetry Audio")] HRESULT Audio([in] OUTPUT_STATE newVal); + [propput, id(3), helpstring("property Audio")] HRESULT Audio([in] OUTPUT_STATE newVal); }; [ diff --git a/mingw-w64-headers/direct-x/include/d3d10_1.h b/mingw-w64-headers/direct-x/include/d3d10_1.h index 69e6f25..6c2884a 100644 --- a/mingw-w64-headers/direct-x/include/d3d10_1.h +++ b/mingw-w64-headers/direct-x/include/d3d10_1.h @@ -1457,6 +1457,8 @@ void __RPC_STUB ID3D10Device1_GetFeatureLevel_Stub( HRESULT WINAPI D3D10CreateDevice1(IDXGIAdapter*,D3D10_DRIVER_TYPE, HMODULE,UINT,D3D10_FEATURE_LEVEL1,UINT,ID3D10Device1**); +HRESULT __stdcall D3D10CreateDeviceAndSwapChain1(IDXGIAdapter *adapter,enum D3D10_DRIVER_TYPE driver_type,HMODULE swrast,UINT flags,D3D10_FEATURE_LEVEL1 feature_level,UINT sdk_version,DXGI_SWAP_CHAIN_DESC *swapchain_desc,IDXGISwapChain **swapchain,ID3D10Device1 **device); + /* Begin additional prototypes for all interfaces */ diff --git a/mingw-w64-headers/direct-x/include/d3d10_1.idl b/mingw-w64-headers/direct-x/include/d3d10_1.idl index 4ee49c6..a37ff9e 100644 --- a/mingw-w64-headers/direct-x/include/d3d10_1.idl +++ b/mingw-w64-headers/direct-x/include/d3d10_1.idl @@ -151,3 +151,7 @@ const UINT D3D10_1_SDK_VERSION = 0x20; cpp_quote("HRESULT WINAPI D3D10CreateDevice1(IDXGIAdapter*,D3D10_DRIVER_TYPE,") cpp_quote(" HMODULE,UINT,D3D10_FEATURE_LEVEL1,UINT,ID3D10Device1**);") + +[local] HRESULT __stdcall D3D10CreateDeviceAndSwapChain1(IDXGIAdapter *adapter, enum D3D10_DRIVER_TYPE driver_type, + HMODULE swrast, UINT flags, D3D10_FEATURE_LEVEL1 feature_level, UINT sdk_version, + DXGI_SWAP_CHAIN_DESC *swapchain_desc, IDXGISwapChain **swapchain, ID3D10Device1 **device); diff --git a/mingw-w64-headers/direct-x/include/d3d10effect.h b/mingw-w64-headers/direct-x/include/d3d10effect.h index 31de5a4..cefa10f 100644 --- a/mingw-w64-headers/direct-x/include/d3d10effect.h +++ b/mingw-w64-headers/direct-x/include/d3d10effect.h @@ -833,6 +833,8 @@ HRESULT WINAPI D3D10CompileEffectFromMemory(void *data, SIZE_T data_size, const ID3D10Blob **effect, ID3D10Blob **errors); HRESULT WINAPI D3D10CreateEffectFromMemory(void *data, SIZE_T data_size, UINT flags, ID3D10Device *device, ID3D10EffectPool *effect_pool, ID3D10Effect **effect); +HRESULT WINAPI D3D10CreateEffectPoolFromMemory(void *data, SIZE_T data_size, UINT fx_flags, + ID3D10Device *device, ID3D10EffectPool **effect_pool); HRESULT WINAPI D3D10CreateStateBlock(ID3D10Device *device, D3D10_STATE_BLOCK_MASK *mask, ID3D10StateBlock **stateblock); diff --git a/mingw-w64-headers/direct-x/include/d3d11.h b/mingw-w64-headers/direct-x/include/d3d11.h index 931fa51..23bc9e8 100644 --- a/mingw-w64-headers/direct-x/include/d3d11.h +++ b/mingw-w64-headers/direct-x/include/d3d11.h @@ -381,6 +381,10 @@ typedef interface ID3D11VideoProcessorInputView ID3D11VideoProcessorInputView; #define D3D11_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE (16) +#define D3D11_KEEP_RENDER_TARGETS_AND_DEPTH_STENCIL (0xffffffff) + +#define D3D11_KEEP_UNORDERED_ACCESS_VIEWS (0xffffffff) + #define D3D11_SHADER_MAJOR_VERSION (5) #define D3D11_SHADER_MAX_INSTANCES (65535) @@ -884,6 +888,20 @@ typedef struct D3D11_QUERY_DESC { D3D11_QUERY Query; UINT MiscFlags; } D3D11_QUERY_DESC; +#if !defined(D3D11_NO_HELPERS) && defined(__cplusplus) +struct CD3D11_QUERY_DESC : public D3D11_QUERY_DESC { + CD3D11_QUERY_DESC() {} + ~CD3D11_QUERY_DESC() {} + explicit CD3D11_QUERY_DESC(const D3D11_QUERY_DESC &other) : D3D11_QUERY_DESC(other) {} + explicit CD3D11_QUERY_DESC(D3D11_QUERY query, UINT misc_flags = 0) { + Query = query; + MiscFlags = misc_flags; + } + operator const D3D11_QUERY_DESC&() const { + return *this; + } +}; +#endif typedef struct D3D11_RASTERIZER_DESC { D3D11_FILL_MODE FillMode; D3D11_CULL_MODE CullMode; diff --git a/mingw-w64-headers/direct-x/include/d3d11.idl b/mingw-w64-headers/direct-x/include/d3d11.idl index 57d2ceb..3f57f38 100644 --- a/mingw-w64-headers/direct-x/include/d3d11.idl +++ b/mingw-w64-headers/direct-x/include/d3d11.idl @@ -103,6 +103,9 @@ const INT D3D11_VIEWPORT_BOUNDS_MIN = -32768; const UINT D3D11_VIEWPORT_AND_SCISSORRECT_MAX_INDEX = 15; const UINT D3D11_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE = 16; +const UINT D3D11_KEEP_RENDER_TARGETS_AND_DEPTH_STENCIL = 0xffffffff; +const UINT D3D11_KEEP_UNORDERED_ACCESS_VIEWS = 0xffffffff; + const UINT D3D11_SHADER_MAJOR_VERSION = 5; const UINT D3D11_SHADER_MAX_INSTANCES = 65535; const UINT D3D11_SHADER_MAX_INTERFACES = 253; @@ -629,6 +632,21 @@ typedef struct D3D11_QUERY_DESC UINT MiscFlags; } D3D11_QUERY_DESC; +cpp_quote("#if !defined(D3D11_NO_HELPERS) && defined(__cplusplus)") +cpp_quote("struct CD3D11_QUERY_DESC : public D3D11_QUERY_DESC {") +cpp_quote(" CD3D11_QUERY_DESC() {}") +cpp_quote(" ~CD3D11_QUERY_DESC() {}") +cpp_quote(" explicit CD3D11_QUERY_DESC(const D3D11_QUERY_DESC &other) : D3D11_QUERY_DESC(other) {}") +cpp_quote(" explicit CD3D11_QUERY_DESC(D3D11_QUERY query, UINT misc_flags = 0) {") +cpp_quote(" Query = query;") +cpp_quote(" MiscFlags = misc_flags;") +cpp_quote(" }") +cpp_quote(" operator const D3D11_QUERY_DESC&() const {") +cpp_quote(" return *this;") +cpp_quote(" }") +cpp_quote("};") +cpp_quote("#endif") + typedef struct D3D11_RASTERIZER_DESC { D3D11_FILL_MODE FillMode; diff --git a/mingw-w64-headers/direct-x/include/d3d11shader.h b/mingw-w64-headers/direct-x/include/d3d11shader.h index a2bccee..dd241fe 100644 --- a/mingw-w64-headers/direct-x/include/d3d11shader.h +++ b/mingw-w64-headers/direct-x/include/d3d11shader.h @@ -206,4 +206,45 @@ DECLARE_INTERFACE_(ID3D11ShaderReflection, IUnknown) }; #undef INTERFACE +DEFINE_GUID(IID_ID3D11ModuleInstance, 0x469e07f7, 0x45a, 0x48d5, 0xaa, 0x12, 0x68, 0xa4, 0x78, 0xcd, 0xf7, 0x5d); + +#define INTERFACE ID3D11ModuleInstance +DECLARE_INTERFACE_(ID3D11ModuleInstance, IUnknown) +{ + STDMETHOD(QueryInterface)(THIS_ REFIID iid, void **out) PURE; + STDMETHOD_(ULONG, AddRef)(THIS) PURE; + STDMETHOD_(ULONG, Release)(THIS) PURE; + + /* ID3D11ModuleInstance methods */ + STDMETHOD(BindConstantBuffer)(THIS_ UINT srcslot, UINT dstslot, UINT dstoffset) PURE; + STDMETHOD(BindConstantBufferByName)(THIS_ const char *name, UINT dstslot, UINT dstoffset) PURE; + + STDMETHOD(BindResource)(THIS_ UINT srcslot, UINT dstslot, UINT count) PURE; + STDMETHOD(BindResourceByName)(THIS_ const char *name, UINT dstslot, UINT count) PURE; + + STDMETHOD(BindSampler)(THIS_ UINT srcslot, UINT dstslot, UINT count) PURE; + STDMETHOD(BindSamplerByName)(THIS_ const char *name, UINT dstslot, UINT count) PURE; + + STDMETHOD(BindUnorderedAccessView)(THIS_ UINT srcslot, UINT dstslot, UINT count) PURE; + STDMETHOD(BindUnorderedAccessViewByName)(THIS_ const char *name, UINT dstslot, UINT count) PURE; + + STDMETHOD(BindResourceAsUnorderedAccessView)(THIS_ UINT srcslot, UINT dstslot, UINT count) PURE; + STDMETHOD(BindResourceAsUnorderedAccessViewByName)(THIS_ const char *name, UINT dstslot, UINT count) PURE; +}; +#undef INTERFACE + +DEFINE_GUID(IID_ID3D11Module, 0xcac701ee, 0x80fc, 0x4122, 0x82, 0x42, 0x10, 0xb3, 0x9c, 0x8c, 0xec, 0x34); + +#define INTERFACE ID3D11Module +DECLARE_INTERFACE_(ID3D11Module, IUnknown) +{ + STDMETHOD(QueryInterface)(THIS_ REFIID iid, void **out) PURE; + STDMETHOD_(ULONG, AddRef)(THIS) PURE; + STDMETHOD_(ULONG, Release)(THIS) PURE; + + /* ID3D11Module methods */ + STDMETHOD(CreateInstance)(THIS_ const char *instnamespace, ID3D11ModuleInstance **moduleinstance) PURE; +}; +#undef INTERFACE + #endif diff --git a/mingw-w64-headers/direct-x/include/d3d9.h b/mingw-w64-headers/direct-x/include/d3d9.h index c9f2be9..75da9a8 100644 --- a/mingw-w64-headers/direct-x/include/d3d9.h +++ b/mingw-w64-headers/direct-x/include/d3d9.h @@ -291,7 +291,7 @@ DECLARE_INTERFACE_(IDirect3D9Ex,IDirect3D9) UINT mode_idx, D3DDISPLAYMODEEX *mode) PURE; STDMETHOD(GetAdapterDisplayModeEx)(THIS_ UINT Adapter, D3DDISPLAYMODEEX *pMode, D3DDISPLAYROTATION *pRotation); STDMETHOD(CreateDeviceEx)(THIS_ UINT Adapter, D3DDEVTYPE DeviceType, HWND hFocusWindow, DWORD BehaviorFlags, D3DPRESENT_PARAMETERS* pPresentationParameters, D3DDISPLAYMODEEX* pFullscreenDisplayMode, struct IDirect3DDevice9Ex **ppReturnedDeviceInterface) PURE; - STDMETHOD(GetAdapterLUID)(THIS_ UINT Adatper, LUID *pLUID) PURE; + STDMETHOD(GetAdapterLUID)(THIS_ UINT adapter, LUID *luid) PURE; }; #undef INTERFACE diff --git a/mingw-w64-headers/direct-x/include/d3dcompiler.h b/mingw-w64-headers/direct-x/include/d3dcompiler.h index 1c59c66..381ad6c 100644 --- a/mingw-w64-headers/direct-x/include/d3dcompiler.h +++ b/mingw-w64-headers/direct-x/include/d3dcompiler.h @@ -121,6 +121,8 @@ typedef HRESULT (WINAPI *pD3DPreprocess)(const void *data, SIZE_T size, const ch const D3D_SHADER_MACRO *defines, ID3DInclude *include, ID3DBlob **shader, ID3DBlob **error_messages); +HRESULT WINAPI D3DLoadModule(const void *data, SIZE_T size, ID3D11Module **module); + #ifdef __cplusplus } #endif diff --git a/mingw-w64-headers/direct-x/include/d3drm.h b/mingw-w64-headers/direct-x/include/d3drm.h index 7930f58..a1de5d8 100644 --- a/mingw-w64-headers/direct-x/include/d3drm.h +++ b/mingw-w64-headers/direct-x/include/d3drm.h @@ -111,7 +111,7 @@ DECLARE_INTERFACE_(IDirect3DRM,IUnknown) #define IDirect3DRM_AddRef(p) (p)->lpVtbl->AddRef(p) #define IDirect3DRM_Release(p) (p)->lpVtbl->Release(p) /*** IDirect3DRM methods ***/ -#define IDirect3DRM_CreateObject(p,a,b,c,d) (p)->lpVtbl->CreateObject(p,a,b,d) +#define IDirect3DRM_CreateObject(p,a,b,c,d) (p)->lpVtbl->CreateObject(p,a,b,c,d) #define IDirect3DRM_CreateFrame(p,a,b) (p)->lpVtbl->CreateFrame(p,a,b) #define IDirect3DRM_CreateMesh(p,a) (p)->lpVtbl->CreateMesh(p,a) #define IDirect3DRM_CreateMeshBuilder(p,a) (p)->lpVtbl->CreateMeshBuilder(p,a) @@ -149,7 +149,7 @@ DECLARE_INTERFACE_(IDirect3DRM,IUnknown) #define IDirect3DRM_AddRef(p) (p)->AddRef() #define IDirect3DRM_Release(p) (p)->Release() /*** IDirect3DRM methods ***/ -#define IDirect3DRM_CreateObject(p,a,b,c,d) (p)->CreateObject(a,b,d) +#define IDirect3DRM_CreateObject(p,a,b,c,d) (p)->CreateObject(a,b,c,d) #define IDirect3DRM_CreateFrame(p,a,b) (p)->CreateFrame(a,b) #define IDirect3DRM_CreateMesh(p,a) (p)->CreateMesh(a) #define IDirect3DRM_CreateMeshBuilder(p,a) (p)->CreateMeshBuilder(a) @@ -252,7 +252,7 @@ DECLARE_INTERFACE_(IDirect3DRM2,IUnknown) #define IDirect3DRM2_AddRef(p) (p)->lpVtbl->AddRef(p) #define IDirect3DRM2_Release(p) (p)->lpVtbl->Release(p) /*** IDirect3DRM2 methods ***/ -#define IDirect3DRM2_CreateObject(p,a,b,c,d) (p)->lpVtbl->CreateObject(p,a,b,d) +#define IDirect3DRM2_CreateObject(p,a,b,c,d) (p)->lpVtbl->CreateObject(p,a,b,c,d) #define IDirect3DRM2_CreateFrame(p,a,b) (p)->lpVtbl->CreateFrame(p,a,b) #define IDirect3DRM2_CreateMesh(p,a) (p)->lpVtbl->CreateMesh(p,a) #define IDirect3DRM2_CreateMeshBuilder(p,a) (p)->lpVtbl->CreateMeshBuilder(p,a) @@ -291,7 +291,7 @@ DECLARE_INTERFACE_(IDirect3DRM2,IUnknown) #define IDirect3DRM2_AddRef(p) (p)->AddRef() #define IDirect3DRM2_Release(p) (p)->Release() /*** IDirect3DRM2 methods ***/ -#define IDirect3DRM2_CreateObject(p,a,b,c,d) (p)->CreateObject(a,b,d) +#define IDirect3DRM2_CreateObject(p,a,b,c,d) (p)->CreateObject(a,b,c,d) #define IDirect3DRM2_CreateFrame(p,a,b) (p)->CreateFrame(a,b) #define IDirect3DRM2_CreateMesh(p,a) (p)->CreateMesh(a) #define IDirect3DRM2_CreateMeshBuilder(p,a) (p)->CreateMeshBuilder(a) @@ -400,7 +400,7 @@ DECLARE_INTERFACE_(IDirect3DRM3,IUnknown) #define IDirect3DRM3_AddRef(p) (p)->lpVtbl->AddRef(p) #define IDirect3DRM3_Release(p) (p)->lpVtbl->Release(p) /*** IDirect3DRM3 methods ***/ -#define IDirect3DRM3_CreateObject(p,a,b,c,d) (p)->lpVtbl->CreateObject(p,a,b,d) +#define IDirect3DRM3_CreateObject(p,a,b,c,d) (p)->lpVtbl->CreateObject(p,a,b,c,d) #define IDirect3DRM3_CreateFrame(p,a,b) (p)->lpVtbl->CreateFrame(p,a,b) #define IDirect3DRM3_CreateMesh(p,a) (p)->lpVtbl->CreateMesh(p,a) #define IDirect3DRM3_CreateMeshBuilder(p,a) (p)->lpVtbl->CreateMeshBuilder(p,a) @@ -444,7 +444,7 @@ DECLARE_INTERFACE_(IDirect3DRM3,IUnknown) #define IDirect3DRM3_AddRef(p) (p)->AddRef() #define IDirect3DRM3_Release(p) (p)->Release() /*** IDirect3DRM3 methods ***/ -#define IDirect3DRM3_CreateObject(p,a,b,c,d) (p)->CreateObject(a,b,d) +#define IDirect3DRM3_CreateObject(p,a,b,c,d) (p)->CreateObject(a,b,c,d) #define IDirect3DRM3_CreateFrame(p,a,b) (p)->CreateFrame(a,b) #define IDirect3DRM3_CreateMesh(p,a) (p)->CreateMesh(a) #define IDirect3DRM3_CreateMeshBuilder(p,a) (p)->CreateMeshBuilder(a) diff --git a/mingw-w64-headers/direct-x/include/dxgi.h b/mingw-w64-headers/direct-x/include/dxgi.h index b6530c7..d116b89 100644 --- a/mingw-w64-headers/direct-x/include/dxgi.h +++ b/mingw-w64-headers/direct-x/include/dxgi.h @@ -42,6 +42,11 @@ typedef interface IDXGIKeyedMutex IDXGIKeyedMutex; typedef interface IDXGISurface IDXGISurface; #endif +#ifndef __IDXGISurface1_FWD_DEFINED__ +#define __IDXGISurface1_FWD_DEFINED__ +typedef interface IDXGISurface1 IDXGISurface1; +#endif + #ifndef __IDXGIOutput_FWD_DEFINED__ #define __IDXGIOutput_FWD_DEFINED__ typedef interface IDXGIOutput IDXGIOutput; @@ -1024,6 +1029,192 @@ void __RPC_STUB IDXGISurface_Unmap_Stub( #endif /* __IDXGISurface_INTERFACE_DEFINED__ */ /***************************************************************************** + * IDXGISurface1 interface + */ +#ifndef __IDXGISurface1_INTERFACE_DEFINED__ +#define __IDXGISurface1_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IDXGISurface1, 0x4ae63092, 0x6327, 0x4c1b, 0x80,0xae, 0xbf,0xe1,0x2e,0xa3,0x2b,0x86); +#if defined(__cplusplus) && !defined(CINTERFACE) +MIDL_INTERFACE("4ae63092-6327-4c1b-80ae-bfe12ea32b86") +IDXGISurface1 : public IDXGISurface +{ + virtual HRESULT STDMETHODCALLTYPE GetDC( + WINBOOL discard, + HDC *hdc) = 0; + + virtual HRESULT STDMETHODCALLTYPE ReleaseDC( + RECT *dirty_rect) = 0; + +}; +#ifdef __CRT_UUID_DECL +__CRT_UUID_DECL(IDXGISurface1, 0x4ae63092, 0x6327, 0x4c1b, 0x80,0xae, 0xbf,0xe1,0x2e,0xa3,0x2b,0x86) +#endif +#else +typedef struct IDXGISurface1Vtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IDXGISurface1* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IDXGISurface1* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IDXGISurface1* This); + + /*** IDXGIObject methods ***/ + HRESULT (STDMETHODCALLTYPE *SetPrivateData)( + IDXGISurface1* This, + REFGUID guid, + UINT data_size, + const void *data); + + HRESULT (STDMETHODCALLTYPE *SetPrivateDataInterface)( + IDXGISurface1* This, + REFGUID guid, + const IUnknown *object); + + HRESULT (STDMETHODCALLTYPE *GetPrivateData)( + IDXGISurface1* This, + REFGUID guid, + UINT *data_size, + void *data); + + HRESULT (STDMETHODCALLTYPE *GetParent)( + IDXGISurface1* This, + REFIID riid, + void **parent); + + /*** IDXGIDeviceSubObject methods ***/ + HRESULT (STDMETHODCALLTYPE *GetDevice)( + IDXGISurface1* This, + REFIID riid, + void **device); + + /*** IDXGISurface methods ***/ + HRESULT (STDMETHODCALLTYPE *GetDesc)( + IDXGISurface1* This, + DXGI_SURFACE_DESC *desc); + + HRESULT (STDMETHODCALLTYPE *Map)( + IDXGISurface1* This, + DXGI_MAPPED_RECT *mapped_rect, + UINT flags); + + HRESULT (STDMETHODCALLTYPE *Unmap)( + IDXGISurface1* This); + + /*** IDXGISurface1 methods ***/ + HRESULT (STDMETHODCALLTYPE *GetDC)( + IDXGISurface1* This, + WINBOOL discard, + HDC *hdc); + + HRESULT (STDMETHODCALLTYPE *ReleaseDC)( + IDXGISurface1* This, + RECT *dirty_rect); + + END_INTERFACE +} IDXGISurface1Vtbl; +interface IDXGISurface1 { + CONST_VTBL IDXGISurface1Vtbl* lpVtbl; +}; + +#ifdef COBJMACROS +#ifndef WIDL_C_INLINE_WRAPPERS +/*** IUnknown methods ***/ +#define IDXGISurface1_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IDXGISurface1_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IDXGISurface1_Release(This) (This)->lpVtbl->Release(This) +/*** IDXGIObject methods ***/ +#define IDXGISurface1_SetPrivateData(This,guid,data_size,data) (This)->lpVtbl->SetPrivateData(This,guid,data_size,data) +#define IDXGISurface1_SetPrivateDataInterface(This,guid,object) (This)->lpVtbl->SetPrivateDataInterface(This,guid,object) +#define IDXGISurface1_GetPrivateData(This,guid,data_size,data) (This)->lpVtbl->GetPrivateData(This,guid,data_size,data) +#define IDXGISurface1_GetParent(This,riid,parent) (This)->lpVtbl->GetParent(This,riid,parent) +/*** IDXGIDeviceSubObject methods ***/ +#define IDXGISurface1_GetDevice(This,riid,device) (This)->lpVtbl->GetDevice(This,riid,device) +/*** IDXGISurface methods ***/ +#define IDXGISurface1_GetDesc(This,desc) (This)->lpVtbl->GetDesc(This,desc) +#define IDXGISurface1_Map(This,mapped_rect,flags) (This)->lpVtbl->Map(This,mapped_rect,flags) +#define IDXGISurface1_Unmap(This) (This)->lpVtbl->Unmap(This) +/*** IDXGISurface1 methods ***/ +#define IDXGISurface1_GetDC(This,discard,hdc) (This)->lpVtbl->GetDC(This,discard,hdc) +#define IDXGISurface1_ReleaseDC(This,dirty_rect) (This)->lpVtbl->ReleaseDC(This,dirty_rect) +#else +/*** IUnknown methods ***/ +static FORCEINLINE HRESULT IDXGISurface1_QueryInterface(IDXGISurface1* This,REFIID riid,void **ppvObject) { + return This->lpVtbl->QueryInterface(This,riid,ppvObject); +} +static FORCEINLINE ULONG IDXGISurface1_AddRef(IDXGISurface1* This) { + return This->lpVtbl->AddRef(This); +} +static FORCEINLINE ULONG IDXGISurface1_Release(IDXGISurface1* This) { + return This->lpVtbl->Release(This); +} +/*** IDXGIObject methods ***/ +static FORCEINLINE HRESULT IDXGISurface1_SetPrivateData(IDXGISurface1* This,REFGUID guid,UINT data_size,const void *data) { + return This->lpVtbl->SetPrivateData(This,guid,data_size,data); +} +static FORCEINLINE HRESULT IDXGISurface1_SetPrivateDataInterface(IDXGISurface1* This,REFGUID guid,const IUnknown *object) { + return This->lpVtbl->SetPrivateDataInterface(This,guid,object); +} +static FORCEINLINE HRESULT IDXGISurface1_GetPrivateData(IDXGISurface1* This,REFGUID guid,UINT *data_size,void *data) { + return This->lpVtbl->GetPrivateData(This,guid,data_size,data); +} +static FORCEINLINE HRESULT IDXGISurface1_GetParent(IDXGISurface1* This,REFIID riid,void **parent) { + return This->lpVtbl->GetParent(This,riid,parent); +} +/*** IDXGIDeviceSubObject methods ***/ +static FORCEINLINE HRESULT IDXGISurface1_GetDevice(IDXGISurface1* This,REFIID riid,void **device) { + return This->lpVtbl->GetDevice(This,riid,device); +} +/*** IDXGISurface methods ***/ +static FORCEINLINE HRESULT IDXGISurface1_GetDesc(IDXGISurface1* This,DXGI_SURFACE_DESC *desc) { + return This->lpVtbl->GetDesc(This,desc); +} +static FORCEINLINE HRESULT IDXGISurface1_Map(IDXGISurface1* This,DXGI_MAPPED_RECT *mapped_rect,UINT flags) { + return This->lpVtbl->Map(This,mapped_rect,flags); +} +static FORCEINLINE HRESULT IDXGISurface1_Unmap(IDXGISurface1* This) { + return This->lpVtbl->Unmap(This); +} +/*** IDXGISurface1 methods ***/ +static FORCEINLINE HRESULT IDXGISurface1_GetDC(IDXGISurface1* This,WINBOOL discard,HDC *hdc) { + return This->lpVtbl->GetDC(This,discard,hdc); +} +static FORCEINLINE HRESULT IDXGISurface1_ReleaseDC(IDXGISurface1* This,RECT *dirty_rect) { + return This->lpVtbl->ReleaseDC(This,dirty_rect); +} +#endif +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IDXGISurface1_GetDC_Proxy( + IDXGISurface1* This, + WINBOOL discard, + HDC *hdc); +void __RPC_STUB IDXGISurface1_GetDC_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IDXGISurface1_ReleaseDC_Proxy( + IDXGISurface1* This, + RECT *dirty_rect); +void __RPC_STUB IDXGISurface1_ReleaseDC_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IDXGISurface1_INTERFACE_DEFINED__ */ + +/***************************************************************************** * IDXGIOutput interface */ #ifndef __IDXGIOutput_INTERFACE_DEFINED__ diff --git a/mingw-w64-headers/direct-x/include/dxgi.idl b/mingw-w64-headers/direct-x/include/dxgi.idl index cc98970..c7ba584 100644 --- a/mingw-w64-headers/direct-x/include/dxgi.idl +++ b/mingw-w64-headers/direct-x/include/dxgi.idl @@ -227,6 +227,22 @@ interface IDXGISurface : IDXGIDeviceSubObject [ object, local, + uuid(4ae63092-6327-4c1b-80ae-bfe12ea32b86) +] +interface IDXGISurface1 : IDXGISurface +{ + HRESULT GetDC( + [in] BOOL discard, + [out] HDC *hdc + ); + HRESULT ReleaseDC( + [in] RECT *dirty_rect + ); +} + +[ + object, + local, uuid(ae02eedb-c735-4690-8d52-5a8dc20213aa) ] interface IDXGIOutput : IDXGIObject diff --git a/mingw-w64-headers/direct-x/include/qedit.h b/mingw-w64-headers/direct-x/include/qedit.h index caa14bc..f167923 100644 --- a/mingw-w64-headers/direct-x/include/qedit.h +++ b/mingw-w64-headers/direct-x/include/qedit.h @@ -41,6 +41,55 @@ typedef struct MediaDet MediaDet; #endif /* defined __cplusplus */ #endif /* defined __MediaDet_FWD_DEFINED__ */ +#ifndef __IMediaLocator_FWD_DEFINED__ +#define __IMediaLocator_FWD_DEFINED__ +typedef interface IMediaLocator IMediaLocator; +#endif + +#ifndef __IPropertySetter_FWD_DEFINED__ +#define __IPropertySetter_FWD_DEFINED__ +typedef interface IPropertySetter IPropertySetter; +#endif + +#ifndef __IAMErrorLog_FWD_DEFINED__ +#define __IAMErrorLog_FWD_DEFINED__ +typedef interface IAMErrorLog IAMErrorLog; +#endif + +#ifndef __IAMSetErrorLog_FWD_DEFINED__ +#define __IAMSetErrorLog_FWD_DEFINED__ +typedef interface IAMSetErrorLog IAMSetErrorLog; +#endif + +#ifndef __IAMTimeline_FWD_DEFINED__ +#define __IAMTimeline_FWD_DEFINED__ +typedef interface IAMTimeline IAMTimeline; +#endif + +#ifndef __AMTimeline_FWD_DEFINED__ +#define __AMTimeline_FWD_DEFINED__ +#ifdef __cplusplus +typedef class AMTimeline AMTimeline; +#else +typedef struct AMTimeline AMTimeline; +#endif /* defined __cplusplus */ +#endif /* defined __AMTimeline_FWD_DEFINED__ */ + +#ifndef __IAMTimelineGroup_FWD_DEFINED__ +#define __IAMTimelineGroup_FWD_DEFINED__ +typedef interface IAMTimelineGroup IAMTimelineGroup; +#endif + +#ifndef __IAMTimelineObj_FWD_DEFINED__ +#define __IAMTimelineObj_FWD_DEFINED__ +typedef interface IAMTimelineObj IAMTimelineObj; +#endif + +#ifndef __IAMTimelineSrc_FWD_DEFINED__ +#define __IAMTimelineSrc_FWD_DEFINED__ +typedef interface IAMTimelineSrc IAMTimelineSrc; +#endif + /* Headers for imported files */ #include @@ -771,6 +820,3062 @@ __CRT_UUID_DECL(MediaDet, 0x65bd0711, 0x24d2, 0x4ff7, 0x93,0x24, 0xed,0x2e,0x5d, #endif #endif +/***************************************************************************** + * IMediaLocator interface + */ +#ifndef __IMediaLocator_INTERFACE_DEFINED__ +#define __IMediaLocator_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IMediaLocator, 0x288581e0, 0x66ce, 0x11d2, 0x91,0x8f, 0x00,0xc0,0xdf,0x10,0xd4,0x34); +#if defined(__cplusplus) && !defined(CINTERFACE) +MIDL_INTERFACE("288581e0-66ce-11d2-918f-00c0df10d434") +IMediaLocator : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE FindMediaFile( + BSTR input, + BSTR filter, + BSTR *output, + LONG flags) = 0; + + virtual HRESULT STDMETHODCALLTYPE AddFoundLocation( + BSTR dir) = 0; + +}; +#ifdef __CRT_UUID_DECL +__CRT_UUID_DECL(IMediaLocator, 0x288581e0, 0x66ce, 0x11d2, 0x91,0x8f, 0x00,0xc0,0xdf,0x10,0xd4,0x34) +#endif +#else +typedef struct IMediaLocatorVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IMediaLocator* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IMediaLocator* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IMediaLocator* This); + + /*** IMediaLocator methods ***/ + HRESULT (STDMETHODCALLTYPE *FindMediaFile)( + IMediaLocator* This, + BSTR input, + BSTR filter, + BSTR *output, + LONG flags); + + HRESULT (STDMETHODCALLTYPE *AddFoundLocation)( + IMediaLocator* This, + BSTR dir); + + END_INTERFACE +} IMediaLocatorVtbl; +interface IMediaLocator { + CONST_VTBL IMediaLocatorVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +#ifndef WIDL_C_INLINE_WRAPPERS +/*** IUnknown methods ***/ +#define IMediaLocator_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IMediaLocator_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IMediaLocator_Release(This) (This)->lpVtbl->Release(This) +/*** IMediaLocator methods ***/ +#define IMediaLocator_FindMediaFile(This,input,filter,output,flags) (This)->lpVtbl->FindMediaFile(This,input,filter,output,flags) +#define IMediaLocator_AddFoundLocation(This,dir) (This)->lpVtbl->AddFoundLocation(This,dir) +#else +/*** IUnknown methods ***/ +static FORCEINLINE HRESULT IMediaLocator_QueryInterface(IMediaLocator* This,REFIID riid,void **ppvObject) { + return This->lpVtbl->QueryInterface(This,riid,ppvObject); +} +static FORCEINLINE ULONG IMediaLocator_AddRef(IMediaLocator* This) { + return This->lpVtbl->AddRef(This); +} +static FORCEINLINE ULONG IMediaLocator_Release(IMediaLocator* This) { + return This->lpVtbl->Release(This); +} +/*** IMediaLocator methods ***/ +static FORCEINLINE HRESULT IMediaLocator_FindMediaFile(IMediaLocator* This,BSTR input,BSTR filter,BSTR *output,LONG flags) { + return This->lpVtbl->FindMediaFile(This,input,filter,output,flags); +} +static FORCEINLINE HRESULT IMediaLocator_AddFoundLocation(IMediaLocator* This,BSTR dir) { + return This->lpVtbl->AddFoundLocation(This,dir); +} +#endif +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IMediaLocator_FindMediaFile_Proxy( + IMediaLocator* This, + BSTR input, + BSTR filter, + BSTR *output, + LONG flags); +void __RPC_STUB IMediaLocator_FindMediaFile_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IMediaLocator_AddFoundLocation_Proxy( + IMediaLocator* This, + BSTR dir); +void __RPC_STUB IMediaLocator_AddFoundLocation_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IMediaLocator_INTERFACE_DEFINED__ */ + +typedef struct __WIDL_qedit_generated_name_0000001E { + BSTR name; + DISPID dispID; + LONG nValues; +} DEXTER_PARAM; +typedef struct __WIDL_qedit_generated_name_0000001F { + VARIANT v; + REFERENCE_TIME rt; + DWORD dwInterp; +} DEXTER_VALUE; +/***************************************************************************** + * IPropertySetter interface + */ +#ifndef __IPropertySetter_INTERFACE_DEFINED__ +#define __IPropertySetter_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IPropertySetter, 0xae9472bd, 0xb0c3, 0x11d2, 0x8d,0x24, 0x00,0xa0,0xc9,0x44,0x1e,0x20); +#if defined(__cplusplus) && !defined(CINTERFACE) +MIDL_INTERFACE("ae9472bd-b0c3-11d2-8d24-00a0c9441e20") +IPropertySetter : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE LoadXML( + IUnknown *pxml) = 0; + + virtual HRESULT STDMETHODCALLTYPE PrintXML( + char *xml, + int size, + int *printed, + int indent) = 0; + + virtual HRESULT STDMETHODCALLTYPE CloneProps( + IPropertySetter **setter, + REFERENCE_TIME start, + REFERENCE_TIME stop) = 0; + + virtual HRESULT STDMETHODCALLTYPE AddProp( + DEXTER_PARAM param, + DEXTER_VALUE *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetProps( + LONG *params, + DEXTER_PARAM **param, + DEXTER_VALUE **value) = 0; + + virtual HRESULT STDMETHODCALLTYPE FreeProps( + LONG params, + DEXTER_PARAM *param, + DEXTER_VALUE *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE ClearProps( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE SaveToBlob( + LONG *size, + BYTE **blob) = 0; + + virtual HRESULT STDMETHODCALLTYPE LoadFromBlob( + LONG size, + BYTE *blob) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetProps( + IUnknown *target, + REFERENCE_TIME now) = 0; + +}; +#ifdef __CRT_UUID_DECL +__CRT_UUID_DECL(IPropertySetter, 0xae9472bd, 0xb0c3, 0x11d2, 0x8d,0x24, 0x00,0xa0,0xc9,0x44,0x1e,0x20) +#endif +#else +typedef struct IPropertySetterVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IPropertySetter* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IPropertySetter* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IPropertySetter* This); + + /*** IPropertySetter methods ***/ + HRESULT (STDMETHODCALLTYPE *LoadXML)( + IPropertySetter* This, + IUnknown *pxml); + + HRESULT (STDMETHODCALLTYPE *PrintXML)( + IPropertySetter* This, + char *xml, + int size, + int *printed, + int indent); + + HRESULT (STDMETHODCALLTYPE *CloneProps)( + IPropertySetter* This, + IPropertySetter **setter, + REFERENCE_TIME start, + REFERENCE_TIME stop); + + HRESULT (STDMETHODCALLTYPE *AddProp)( + IPropertySetter* This, + DEXTER_PARAM param, + DEXTER_VALUE *value); + + HRESULT (STDMETHODCALLTYPE *GetProps)( + IPropertySetter* This, + LONG *params, + DEXTER_PARAM **param, + DEXTER_VALUE **value); + + HRESULT (STDMETHODCALLTYPE *FreeProps)( + IPropertySetter* This, + LONG params, + DEXTER_PARAM *param, + DEXTER_VALUE *value); + + HRESULT (STDMETHODCALLTYPE *ClearProps)( + IPropertySetter* This); + + HRESULT (STDMETHODCALLTYPE *SaveToBlob)( + IPropertySetter* This, + LONG *size, + BYTE **blob); + + HRESULT (STDMETHODCALLTYPE *LoadFromBlob)( + IPropertySetter* This, + LONG size, + BYTE *blob); + + HRESULT (STDMETHODCALLTYPE *SetProps)( + IPropertySetter* This, + IUnknown *target, + REFERENCE_TIME now); + + END_INTERFACE +} IPropertySetterVtbl; +interface IPropertySetter { + CONST_VTBL IPropertySetterVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +#ifndef WIDL_C_INLINE_WRAPPERS +/*** IUnknown methods ***/ +#define IPropertySetter_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IPropertySetter_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IPropertySetter_Release(This) (This)->lpVtbl->Release(This) +/*** IPropertySetter methods ***/ +#define IPropertySetter_LoadXML(This,pxml) (This)->lpVtbl->LoadXML(This,pxml) +#define IPropertySetter_PrintXML(This,xml,size,printed,indent) (This)->lpVtbl->PrintXML(This,xml,size,printed,indent) +#define IPropertySetter_CloneProps(This,setter,start,stop) (This)->lpVtbl->CloneProps(This,setter,start,stop) +#define IPropertySetter_AddProp(This,param,value) (This)->lpVtbl->AddProp(This,param,value) +#define IPropertySetter_GetProps(This,params,param,value) (This)->lpVtbl->GetProps(This,params,param,value) +#define IPropertySetter_FreeProps(This,params,param,value) (This)->lpVtbl->FreeProps(This,params,param,value) +#define IPropertySetter_ClearProps(This) (This)->lpVtbl->ClearProps(This) +#define IPropertySetter_SaveToBlob(This,size,blob) (This)->lpVtbl->SaveToBlob(This,size,blob) +#define IPropertySetter_LoadFromBlob(This,size,blob) (This)->lpVtbl->LoadFromBlob(This,size,blob) +#define IPropertySetter_SetProps(This,target,now) (This)->lpVtbl->SetProps(This,target,now) +#else +/*** IUnknown methods ***/ +static FORCEINLINE HRESULT IPropertySetter_QueryInterface(IPropertySetter* This,REFIID riid,void **ppvObject) { + return This->lpVtbl->QueryInterface(This,riid,ppvObject); +} +static FORCEINLINE ULONG IPropertySetter_AddRef(IPropertySetter* This) { + return This->lpVtbl->AddRef(This); +} +static FORCEINLINE ULONG IPropertySetter_Release(IPropertySetter* This) { + return This->lpVtbl->Release(This); +} +/*** IPropertySetter methods ***/ +static FORCEINLINE HRESULT IPropertySetter_LoadXML(IPropertySetter* This,IUnknown *pxml) { + return This->lpVtbl->LoadXML(This,pxml); +} +static FORCEINLINE HRESULT IPropertySetter_PrintXML(IPropertySetter* This,char *xml,int size,int *printed,int indent) { + return This->lpVtbl->PrintXML(This,xml,size,printed,indent); +} +static FORCEINLINE HRESULT IPropertySetter_CloneProps(IPropertySetter* This,IPropertySetter **setter,REFERENCE_TIME start,REFERENCE_TIME stop) { + return This->lpVtbl->CloneProps(This,setter,start,stop); +} +static FORCEINLINE HRESULT IPropertySetter_AddProp(IPropertySetter* This,DEXTER_PARAM param,DEXTER_VALUE *value) { + return This->lpVtbl->AddProp(This,param,value); +} +static FORCEINLINE HRESULT IPropertySetter_GetProps(IPropertySetter* This,LONG *params,DEXTER_PARAM **param,DEXTER_VALUE **value) { + return This->lpVtbl->GetProps(This,params,param,value); +} +static FORCEINLINE HRESULT IPropertySetter_FreeProps(IPropertySetter* This,LONG params,DEXTER_PARAM *param,DEXTER_VALUE *value) { + return This->lpVtbl->FreeProps(This,params,param,value); +} +static FORCEINLINE HRESULT IPropertySetter_ClearProps(IPropertySetter* This) { + return This->lpVtbl->ClearProps(This); +} +static FORCEINLINE HRESULT IPropertySetter_SaveToBlob(IPropertySetter* This,LONG *size,BYTE **blob) { + return This->lpVtbl->SaveToBlob(This,size,blob); +} +static FORCEINLINE HRESULT IPropertySetter_LoadFromBlob(IPropertySetter* This,LONG size,BYTE *blob) { + return This->lpVtbl->LoadFromBlob(This,size,blob); +} +static FORCEINLINE HRESULT IPropertySetter_SetProps(IPropertySetter* This,IUnknown *target,REFERENCE_TIME now) { + return This->lpVtbl->SetProps(This,target,now); +} +#endif +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IPropertySetter_LoadXML_Proxy( + IPropertySetter* This, + IUnknown *pxml); +void __RPC_STUB IPropertySetter_LoadXML_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IPropertySetter_PrintXML_Proxy( + IPropertySetter* This, + char *xml, + int size, + int *printed, + int indent); +void __RPC_STUB IPropertySetter_PrintXML_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IPropertySetter_CloneProps_Proxy( + IPropertySetter* This, + IPropertySetter **setter, + REFERENCE_TIME start, + REFERENCE_TIME stop); +void __RPC_STUB IPropertySetter_CloneProps_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IPropertySetter_AddProp_Proxy( + IPropertySetter* This, + DEXTER_PARAM param, + DEXTER_VALUE *value); +void __RPC_STUB IPropertySetter_AddProp_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IPropertySetter_GetProps_Proxy( + IPropertySetter* This, + LONG *params, + DEXTER_PARAM **param, + DEXTER_VALUE **value); +void __RPC_STUB IPropertySetter_GetProps_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IPropertySetter_FreeProps_Proxy( + IPropertySetter* This, + LONG params, + DEXTER_PARAM *param, + DEXTER_VALUE *value); +void __RPC_STUB IPropertySetter_FreeProps_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IPropertySetter_ClearProps_Proxy( + IPropertySetter* This); +void __RPC_STUB IPropertySetter_ClearProps_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IPropertySetter_SaveToBlob_Proxy( + IPropertySetter* This, + LONG *size, + BYTE **blob); +void __RPC_STUB IPropertySetter_SaveToBlob_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IPropertySetter_LoadFromBlob_Proxy( + IPropertySetter* This, + LONG size, + BYTE *blob); +void __RPC_STUB IPropertySetter_LoadFromBlob_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IPropertySetter_SetProps_Proxy( + IPropertySetter* This, + IUnknown *target, + REFERENCE_TIME now); +void __RPC_STUB IPropertySetter_SetProps_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IPropertySetter_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IAMErrorLog interface + */ +#ifndef __IAMErrorLog_INTERFACE_DEFINED__ +#define __IAMErrorLog_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IAMErrorLog, 0xe43e73a2, 0x0efa, 0x11d3, 0x96,0x01, 0x00,0xa0,0xc9,0x44,0x1e,0x20); +#if defined(__cplusplus) && !defined(CINTERFACE) +MIDL_INTERFACE("e43e73a2-0efa-11d3-9601-00a0c9441e20") +IAMErrorLog : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE LogError( + LONG severity, + BSTR error_str, + LONG error_code, + LONG hresult, + VARIANT *extra) = 0; + +}; +#ifdef __CRT_UUID_DECL +__CRT_UUID_DECL(IAMErrorLog, 0xe43e73a2, 0x0efa, 0x11d3, 0x96,0x01, 0x00,0xa0,0xc9,0x44,0x1e,0x20) +#endif +#else +typedef struct IAMErrorLogVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IAMErrorLog* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IAMErrorLog* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IAMErrorLog* This); + + /*** IAMErrorLog methods ***/ + HRESULT (STDMETHODCALLTYPE *LogError)( + IAMErrorLog* This, + LONG severity, + BSTR error_str, + LONG error_code, + LONG hresult, + VARIANT *extra); + + END_INTERFACE +} IAMErrorLogVtbl; +interface IAMErrorLog { + CONST_VTBL IAMErrorLogVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +#ifndef WIDL_C_INLINE_WRAPPERS +/*** IUnknown methods ***/ +#define IAMErrorLog_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IAMErrorLog_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IAMErrorLog_Release(This) (This)->lpVtbl->Release(This) +/*** IAMErrorLog methods ***/ +#define IAMErrorLog_LogError(This,severity,error_str,error_code,hresult,extra) (This)->lpVtbl->LogError(This,severity,error_str,error_code,hresult,extra) +#else +/*** IUnknown methods ***/ +static FORCEINLINE HRESULT IAMErrorLog_QueryInterface(IAMErrorLog* This,REFIID riid,void **ppvObject) { + return This->lpVtbl->QueryInterface(This,riid,ppvObject); +} +static FORCEINLINE ULONG IAMErrorLog_AddRef(IAMErrorLog* This) { + return This->lpVtbl->AddRef(This); +} +static FORCEINLINE ULONG IAMErrorLog_Release(IAMErrorLog* This) { + return This->lpVtbl->Release(This); +} +/*** IAMErrorLog methods ***/ +static FORCEINLINE HRESULT IAMErrorLog_LogError(IAMErrorLog* This,LONG severity,BSTR error_str,LONG error_code,LONG hresult,VARIANT *extra) { + return This->lpVtbl->LogError(This,severity,error_str,error_code,hresult,extra); +} +#endif +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IAMErrorLog_LogError_Proxy( + IAMErrorLog* This, + LONG severity, + BSTR error_str, + LONG error_code, + LONG hresult, + VARIANT *extra); +void __RPC_STUB IAMErrorLog_LogError_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IAMErrorLog_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IAMSetErrorLog interface + */ +#ifndef __IAMSetErrorLog_INTERFACE_DEFINED__ +#define __IAMSetErrorLog_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IAMSetErrorLog, 0x963566da, 0xbe21, 0x4eaf, 0x88,0xe9, 0x35,0x70,0x4f,0x8f,0x52,0xa1); +#if defined(__cplusplus) && !defined(CINTERFACE) +MIDL_INTERFACE("963566da-be21-4eaf-88e9-35704f8f52a1") +IAMSetErrorLog : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE get_ErrorLog( + IAMErrorLog **log) = 0; + + virtual HRESULT STDMETHODCALLTYPE put_ErrorLog( + IAMErrorLog *log) = 0; + +}; +#ifdef __CRT_UUID_DECL +__CRT_UUID_DECL(IAMSetErrorLog, 0x963566da, 0xbe21, 0x4eaf, 0x88,0xe9, 0x35,0x70,0x4f,0x8f,0x52,0xa1) +#endif +#else +typedef struct IAMSetErrorLogVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IAMSetErrorLog* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IAMSetErrorLog* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IAMSetErrorLog* This); + + /*** IAMSetErrorLog methods ***/ + HRESULT (STDMETHODCALLTYPE *get_ErrorLog)( + IAMSetErrorLog* This, + IAMErrorLog **log); + + HRESULT (STDMETHODCALLTYPE *put_ErrorLog)( + IAMSetErrorLog* This, + IAMErrorLog *log); + + END_INTERFACE +} IAMSetErrorLogVtbl; +interface IAMSetErrorLog { + CONST_VTBL IAMSetErrorLogVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +#ifndef WIDL_C_INLINE_WRAPPERS +/*** IUnknown methods ***/ +#define IAMSetErrorLog_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IAMSetErrorLog_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IAMSetErrorLog_Release(This) (This)->lpVtbl->Release(This) +/*** IAMSetErrorLog methods ***/ +#define IAMSetErrorLog_get_ErrorLog(This,log) (This)->lpVtbl->get_ErrorLog(This,log) +#define IAMSetErrorLog_put_ErrorLog(This,log) (This)->lpVtbl->put_ErrorLog(This,log) +#else +/*** IUnknown methods ***/ +static FORCEINLINE HRESULT IAMSetErrorLog_QueryInterface(IAMSetErrorLog* This,REFIID riid,void **ppvObject) { + return This->lpVtbl->QueryInterface(This,riid,ppvObject); +} +static FORCEINLINE ULONG IAMSetErrorLog_AddRef(IAMSetErrorLog* This) { + return This->lpVtbl->AddRef(This); +} +static FORCEINLINE ULONG IAMSetErrorLog_Release(IAMSetErrorLog* This) { + return This->lpVtbl->Release(This); +} +/*** IAMSetErrorLog methods ***/ +static FORCEINLINE HRESULT IAMSetErrorLog_get_ErrorLog(IAMSetErrorLog* This,IAMErrorLog **log) { + return This->lpVtbl->get_ErrorLog(This,log); +} +static FORCEINLINE HRESULT IAMSetErrorLog_put_ErrorLog(IAMSetErrorLog* This,IAMErrorLog *log) { + return This->lpVtbl->put_ErrorLog(This,log); +} +#endif +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IAMSetErrorLog_get_ErrorLog_Proxy( + IAMSetErrorLog* This, + IAMErrorLog **log); +void __RPC_STUB IAMSetErrorLog_get_ErrorLog_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMSetErrorLog_put_ErrorLog_Proxy( + IAMSetErrorLog* This, + IAMErrorLog *log); +void __RPC_STUB IAMSetErrorLog_put_ErrorLog_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IAMSetErrorLog_INTERFACE_DEFINED__ */ + +#ifndef __IAMTimeline_FWD_DEFINED__ +#define __IAMTimeline_FWD_DEFINED__ +typedef interface IAMTimeline IAMTimeline; +#endif + +#ifndef __IAMTimelineGroup_FWD_DEFINED__ +#define __IAMTimelineGroup_FWD_DEFINED__ +typedef interface IAMTimelineGroup IAMTimelineGroup; +#endif + +#ifndef __IAMTimelineObj_FWD_DEFINED__ +#define __IAMTimelineObj_FWD_DEFINED__ +typedef interface IAMTimelineObj IAMTimelineObj; +#endif + +#ifndef __IAMTimelineSrc_FWD_DEFINED__ +#define __IAMTimelineSrc_FWD_DEFINED__ +typedef interface IAMTimelineSrc IAMTimelineSrc; +#endif + +typedef enum __WIDL_qedit_generated_name_00000020 { + TIMELINE_MAJOR_TYPE_COMPOSITE = 1, + TIMELINE_MAJOR_TYPE_TRACK = 2, + TIMELINE_MAJOR_TYPE_SOURCE = 4, + TIMELINE_MAJOR_TYPE_TRANSITION = 8, + TIMELINE_MAJOR_TYPE_EFFECT = 16, + TIMELINE_MAJOR_TYPE_GROUP = 128 +} TIMELINE_MAJOR_TYPE; +/***************************************************************************** + * IAMTimeline interface + */ +#ifndef __IAMTimeline_INTERFACE_DEFINED__ +#define __IAMTimeline_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IAMTimeline, 0x78530b74, 0x61f9, 0x11d2, 0x8c,0xad, 0x00,0xa0,0x24,0x58,0x09,0x02); +#if defined(__cplusplus) && !defined(CINTERFACE) +MIDL_INTERFACE("78530b74-61f9-11d2-8cad-00a024580902") +IAMTimeline : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE CreateEmptyNode( + IAMTimelineObj **obj, + TIMELINE_MAJOR_TYPE type) = 0; + + virtual HRESULT STDMETHODCALLTYPE AddGroup( + IAMTimelineObj *group) = 0; + + virtual HRESULT STDMETHODCALLTYPE RemGroupFromList( + IAMTimelineObj *group) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetGroup( + IAMTimelineObj **group, + LONG index) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetGroupCount( + LONG *count) = 0; + + virtual HRESULT STDMETHODCALLTYPE ClearAllGroups( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetInsertMode( + LONG *mode) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetInsertMode( + LONG mode) = 0; + + virtual HRESULT STDMETHODCALLTYPE EnableTransitions( + WINBOOL enabled) = 0; + + virtual HRESULT STDMETHODCALLTYPE TransitionsEnabled( + WINBOOL *enabled) = 0; + + virtual HRESULT STDMETHODCALLTYPE EnableEffects( + WINBOOL enabled) = 0; + + virtual HRESULT STDMETHODCALLTYPE EffectsEnabled( + WINBOOL *enabled) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetInterestRange( + REFERENCE_TIME start, + REFERENCE_TIME stop) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDuration( + REFERENCE_TIME *duration) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDuration2( + double *duration) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetDefaultFPS( + double fps) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDefaultFPS( + double *fps) = 0; + + virtual HRESULT STDMETHODCALLTYPE IsDirty( + WINBOOL *dirty) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDirtyRange( + REFERENCE_TIME *start, + REFERENCE_TIME *stop) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetCountOfType( + LONG group, + LONG *value, + LONG *value_with_comps, + TIMELINE_MAJOR_TYPE type) = 0; + + virtual HRESULT STDMETHODCALLTYPE ValidateSourceNames( + LONG flags, + IMediaLocator *override, + LONG_PTR notify_event) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetDefaultTransition( + GUID *guid) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDefaultTransition( + GUID *guid) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetDefaultEffect( + GUID *guid) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDefaultEffect( + GUID *guid) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetDefaultTransitionB( + BSTR guidb) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDefaultTransitionB( + BSTR *guidb) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetDefaultEffectB( + BSTR guidb) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDefaultEffectB( + BSTR *guidb) = 0; + +}; +#ifdef __CRT_UUID_DECL +__CRT_UUID_DECL(IAMTimeline, 0x78530b74, 0x61f9, 0x11d2, 0x8c,0xad, 0x00,0xa0,0x24,0x58,0x09,0x02) +#endif +#else +typedef struct IAMTimelineVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IAMTimeline* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IAMTimeline* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IAMTimeline* This); + + /*** IAMTimeline methods ***/ + HRESULT (STDMETHODCALLTYPE *CreateEmptyNode)( + IAMTimeline* This, + IAMTimelineObj **obj, + TIMELINE_MAJOR_TYPE type); + + HRESULT (STDMETHODCALLTYPE *AddGroup)( + IAMTimeline* This, + IAMTimelineObj *group); + + HRESULT (STDMETHODCALLTYPE *RemGroupFromList)( + IAMTimeline* This, + IAMTimelineObj *group); + + HRESULT (STDMETHODCALLTYPE *GetGroup)( + IAMTimeline* This, + IAMTimelineObj **group, + LONG index); + + HRESULT (STDMETHODCALLTYPE *GetGroupCount)( + IAMTimeline* This, + LONG *count); + + HRESULT (STDMETHODCALLTYPE *ClearAllGroups)( + IAMTimeline* This); + + HRESULT (STDMETHODCALLTYPE *GetInsertMode)( + IAMTimeline* This, + LONG *mode); + + HRESULT (STDMETHODCALLTYPE *SetInsertMode)( + IAMTimeline* This, + LONG mode); + + HRESULT (STDMETHODCALLTYPE *EnableTransitions)( + IAMTimeline* This, + WINBOOL enabled); + + HRESULT (STDMETHODCALLTYPE *TransitionsEnabled)( + IAMTimeline* This, + WINBOOL *enabled); + + HRESULT (STDMETHODCALLTYPE *EnableEffects)( + IAMTimeline* This, + WINBOOL enabled); + + HRESULT (STDMETHODCALLTYPE *EffectsEnabled)( + IAMTimeline* This, + WINBOOL *enabled); + + HRESULT (STDMETHODCALLTYPE *SetInterestRange)( + IAMTimeline* This, + REFERENCE_TIME start, + REFERENCE_TIME stop); + + HRESULT (STDMETHODCALLTYPE *GetDuration)( + IAMTimeline* This, + REFERENCE_TIME *duration); + + HRESULT (STDMETHODCALLTYPE *GetDuration2)( + IAMTimeline* This, + double *duration); + + HRESULT (STDMETHODCALLTYPE *SetDefaultFPS)( + IAMTimeline* This, + double fps); + + HRESULT (STDMETHODCALLTYPE *GetDefaultFPS)( + IAMTimeline* This, + double *fps); + + HRESULT (STDMETHODCALLTYPE *IsDirty)( + IAMTimeline* This, + WINBOOL *dirty); + + HRESULT (STDMETHODCALLTYPE *GetDirtyRange)( + IAMTimeline* This, + REFERENCE_TIME *start, + REFERENCE_TIME *stop); + + HRESULT (STDMETHODCALLTYPE *GetCountOfType)( + IAMTimeline* This, + LONG group, + LONG *value, + LONG *value_with_comps, + TIMELINE_MAJOR_TYPE type); + + HRESULT (STDMETHODCALLTYPE *ValidateSourceNames)( + IAMTimeline* This, + LONG flags, + IMediaLocator *override, + LONG_PTR notify_event); + + HRESULT (STDMETHODCALLTYPE *SetDefaultTransition)( + IAMTimeline* This, + GUID *guid); + + HRESULT (STDMETHODCALLTYPE *GetDefaultTransition)( + IAMTimeline* This, + GUID *guid); + + HRESULT (STDMETHODCALLTYPE *SetDefaultEffect)( + IAMTimeline* This, + GUID *guid); + + HRESULT (STDMETHODCALLTYPE *GetDefaultEffect)( + IAMTimeline* This, + GUID *guid); + + HRESULT (STDMETHODCALLTYPE *SetDefaultTransitionB)( + IAMTimeline* This, + BSTR guidb); + + HRESULT (STDMETHODCALLTYPE *GetDefaultTransitionB)( + IAMTimeline* This, + BSTR *guidb); + + HRESULT (STDMETHODCALLTYPE *SetDefaultEffectB)( + IAMTimeline* This, + BSTR guidb); + + HRESULT (STDMETHODCALLTYPE *GetDefaultEffectB)( + IAMTimeline* This, + BSTR *guidb); + + END_INTERFACE +} IAMTimelineVtbl; +interface IAMTimeline { + CONST_VTBL IAMTimelineVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +#ifndef WIDL_C_INLINE_WRAPPERS +/*** IUnknown methods ***/ +#define IAMTimeline_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IAMTimeline_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IAMTimeline_Release(This) (This)->lpVtbl->Release(This) +/*** IAMTimeline methods ***/ +#define IAMTimeline_CreateEmptyNode(This,obj,type) (This)->lpVtbl->CreateEmptyNode(This,obj,type) +#define IAMTimeline_AddGroup(This,group) (This)->lpVtbl->AddGroup(This,group) +#define IAMTimeline_RemGroupFromList(This,group) (This)->lpVtbl->RemGroupFromList(This,group) +#define IAMTimeline_GetGroup(This,group,index) (This)->lpVtbl->GetGroup(This,group,index) +#define IAMTimeline_GetGroupCount(This,count) (This)->lpVtbl->GetGroupCount(This,count) +#define IAMTimeline_ClearAllGroups(This) (This)->lpVtbl->ClearAllGroups(This) +#define IAMTimeline_GetInsertMode(This,mode) (This)->lpVtbl->GetInsertMode(This,mode) +#define IAMTimeline_SetInsertMode(This,mode) (This)->lpVtbl->SetInsertMode(This,mode) +#define IAMTimeline_EnableTransitions(This,enabled) (This)->lpVtbl->EnableTransitions(This,enabled) +#define IAMTimeline_TransitionsEnabled(This,enabled) (This)->lpVtbl->TransitionsEnabled(This,enabled) +#define IAMTimeline_EnableEffects(This,enabled) (This)->lpVtbl->EnableEffects(This,enabled) +#define IAMTimeline_EffectsEnabled(This,enabled) (This)->lpVtbl->EffectsEnabled(This,enabled) +#define IAMTimeline_SetInterestRange(This,start,stop) (This)->lpVtbl->SetInterestRange(This,start,stop) +#define IAMTimeline_GetDuration(This,duration) (This)->lpVtbl->GetDuration(This,duration) +#define IAMTimeline_GetDuration2(This,duration) (This)->lpVtbl->GetDuration2(This,duration) +#define IAMTimeline_SetDefaultFPS(This,fps) (This)->lpVtbl->SetDefaultFPS(This,fps) +#define IAMTimeline_GetDefaultFPS(This,fps) (This)->lpVtbl->GetDefaultFPS(This,fps) +#define IAMTimeline_IsDirty(This,dirty) (This)->lpVtbl->IsDirty(This,dirty) +#define IAMTimeline_GetDirtyRange(This,start,stop) (This)->lpVtbl->GetDirtyRange(This,start,stop) +#define IAMTimeline_GetCountOfType(This,group,value,value_with_comps,type) (This)->lpVtbl->GetCountOfType(This,group,value,value_with_comps,type) +#define IAMTimeline_ValidateSourceNames(This,flags,override,notify_event) (This)->lpVtbl->ValidateSourceNames(This,flags,override,notify_event) +#define IAMTimeline_SetDefaultTransition(This,guid) (This)->lpVtbl->SetDefaultTransition(This,guid) +#define IAMTimeline_GetDefaultTransition(This,guid) (This)->lpVtbl->GetDefaultTransition(This,guid) +#define IAMTimeline_SetDefaultEffect(This,guid) (This)->lpVtbl->SetDefaultEffect(This,guid) +#define IAMTimeline_GetDefaultEffect(This,guid) (This)->lpVtbl->GetDefaultEffect(This,guid) +#define IAMTimeline_SetDefaultTransitionB(This,guidb) (This)->lpVtbl->SetDefaultTransitionB(This,guidb) +#define IAMTimeline_GetDefaultTransitionB(This,guidb) (This)->lpVtbl->GetDefaultTransitionB(This,guidb) +#define IAMTimeline_SetDefaultEffectB(This,guidb) (This)->lpVtbl->SetDefaultEffectB(This,guidb) +#define IAMTimeline_GetDefaultEffectB(This,guidb) (This)->lpVtbl->GetDefaultEffectB(This,guidb) +#else +/*** IUnknown methods ***/ +static FORCEINLINE HRESULT IAMTimeline_QueryInterface(IAMTimeline* This,REFIID riid,void **ppvObject) { + return This->lpVtbl->QueryInterface(This,riid,ppvObject); +} +static FORCEINLINE ULONG IAMTimeline_AddRef(IAMTimeline* This) { + return This->lpVtbl->AddRef(This); +} +static FORCEINLINE ULONG IAMTimeline_Release(IAMTimeline* This) { + return This->lpVtbl->Release(This); +} +/*** IAMTimeline methods ***/ +static FORCEINLINE HRESULT IAMTimeline_CreateEmptyNode(IAMTimeline* This,IAMTimelineObj **obj,TIMELINE_MAJOR_TYPE type) { + return This->lpVtbl->CreateEmptyNode(This,obj,type); +} +static FORCEINLINE HRESULT IAMTimeline_AddGroup(IAMTimeline* This,IAMTimelineObj *group) { + return This->lpVtbl->AddGroup(This,group); +} +static FORCEINLINE HRESULT IAMTimeline_RemGroupFromList(IAMTimeline* This,IAMTimelineObj *group) { + return This->lpVtbl->RemGroupFromList(This,group); +} +static FORCEINLINE HRESULT IAMTimeline_GetGroup(IAMTimeline* This,IAMTimelineObj **group,LONG index) { + return This->lpVtbl->GetGroup(This,group,index); +} +static FORCEINLINE HRESULT IAMTimeline_GetGroupCount(IAMTimeline* This,LONG *count) { + return This->lpVtbl->GetGroupCount(This,count); +} +static FORCEINLINE HRESULT IAMTimeline_ClearAllGroups(IAMTimeline* This) { + return This->lpVtbl->ClearAllGroups(This); +} +static FORCEINLINE HRESULT IAMTimeline_GetInsertMode(IAMTimeline* This,LONG *mode) { + return This->lpVtbl->GetInsertMode(This,mode); +} +static FORCEINLINE HRESULT IAMTimeline_SetInsertMode(IAMTimeline* This,LONG mode) { + return This->lpVtbl->SetInsertMode(This,mode); +} +static FORCEINLINE HRESULT IAMTimeline_EnableTransitions(IAMTimeline* This,WINBOOL enabled) { + return This->lpVtbl->EnableTransitions(This,enabled); +} +static FORCEINLINE HRESULT IAMTimeline_TransitionsEnabled(IAMTimeline* This,WINBOOL *enabled) { + return This->lpVtbl->TransitionsEnabled(This,enabled); +} +static FORCEINLINE HRESULT IAMTimeline_EnableEffects(IAMTimeline* This,WINBOOL enabled) { + return This->lpVtbl->EnableEffects(This,enabled); +} +static FORCEINLINE HRESULT IAMTimeline_EffectsEnabled(IAMTimeline* This,WINBOOL *enabled) { + return This->lpVtbl->EffectsEnabled(This,enabled); +} +static FORCEINLINE HRESULT IAMTimeline_SetInterestRange(IAMTimeline* This,REFERENCE_TIME start,REFERENCE_TIME stop) { + return This->lpVtbl->SetInterestRange(This,start,stop); +} +static FORCEINLINE HRESULT IAMTimeline_GetDuration(IAMTimeline* This,REFERENCE_TIME *duration) { + return This->lpVtbl->GetDuration(This,duration); +} +static FORCEINLINE HRESULT IAMTimeline_GetDuration2(IAMTimeline* This,double *duration) { + return This->lpVtbl->GetDuration2(This,duration); +} +static FORCEINLINE HRESULT IAMTimeline_SetDefaultFPS(IAMTimeline* This,double fps) { + return This->lpVtbl->SetDefaultFPS(This,fps); +} +static FORCEINLINE HRESULT IAMTimeline_GetDefaultFPS(IAMTimeline* This,double *fps) { + return This->lpVtbl->GetDefaultFPS(This,fps); +} +static FORCEINLINE HRESULT IAMTimeline_IsDirty(IAMTimeline* This,WINBOOL *dirty) { + return This->lpVtbl->IsDirty(This,dirty); +} +static FORCEINLINE HRESULT IAMTimeline_GetDirtyRange(IAMTimeline* This,REFERENCE_TIME *start,REFERENCE_TIME *stop) { + return This->lpVtbl->GetDirtyRange(This,start,stop); +} +static FORCEINLINE HRESULT IAMTimeline_GetCountOfType(IAMTimeline* This,LONG group,LONG *value,LONG *value_with_comps,TIMELINE_MAJOR_TYPE type) { + return This->lpVtbl->GetCountOfType(This,group,value,value_with_comps,type); +} +static FORCEINLINE HRESULT IAMTimeline_ValidateSourceNames(IAMTimeline* This,LONG flags,IMediaLocator *override,LONG_PTR notify_event) { + return This->lpVtbl->ValidateSourceNames(This,flags,override,notify_event); +} +static FORCEINLINE HRESULT IAMTimeline_SetDefaultTransition(IAMTimeline* This,GUID *guid) { + return This->lpVtbl->SetDefaultTransition(This,guid); +} +static FORCEINLINE HRESULT IAMTimeline_GetDefaultTransition(IAMTimeline* This,GUID *guid) { + return This->lpVtbl->GetDefaultTransition(This,guid); +} +static FORCEINLINE HRESULT IAMTimeline_SetDefaultEffect(IAMTimeline* This,GUID *guid) { + return This->lpVtbl->SetDefaultEffect(This,guid); +} +static FORCEINLINE HRESULT IAMTimeline_GetDefaultEffect(IAMTimeline* This,GUID *guid) { + return This->lpVtbl->GetDefaultEffect(This,guid); +} +static FORCEINLINE HRESULT IAMTimeline_SetDefaultTransitionB(IAMTimeline* This,BSTR guidb) { + return This->lpVtbl->SetDefaultTransitionB(This,guidb); +} +static FORCEINLINE HRESULT IAMTimeline_GetDefaultTransitionB(IAMTimeline* This,BSTR *guidb) { + return This->lpVtbl->GetDefaultTransitionB(This,guidb); +} +static FORCEINLINE HRESULT IAMTimeline_SetDefaultEffectB(IAMTimeline* This,BSTR guidb) { + return This->lpVtbl->SetDefaultEffectB(This,guidb); +} +static FORCEINLINE HRESULT IAMTimeline_GetDefaultEffectB(IAMTimeline* This,BSTR *guidb) { + return This->lpVtbl->GetDefaultEffectB(This,guidb); +} +#endif +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IAMTimeline_CreateEmptyNode_Proxy( + IAMTimeline* This, + IAMTimelineObj **obj, + TIMELINE_MAJOR_TYPE type); +void __RPC_STUB IAMTimeline_CreateEmptyNode_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimeline_AddGroup_Proxy( + IAMTimeline* This, + IAMTimelineObj *group); +void __RPC_STUB IAMTimeline_AddGroup_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimeline_RemGroupFromList_Proxy( + IAMTimeline* This, + IAMTimelineObj *group); +void __RPC_STUB IAMTimeline_RemGroupFromList_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimeline_GetGroup_Proxy( + IAMTimeline* This, + IAMTimelineObj **group, + LONG index); +void __RPC_STUB IAMTimeline_GetGroup_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimeline_GetGroupCount_Proxy( + IAMTimeline* This, + LONG *count); +void __RPC_STUB IAMTimeline_GetGroupCount_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimeline_ClearAllGroups_Proxy( + IAMTimeline* This); +void __RPC_STUB IAMTimeline_ClearAllGroups_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimeline_GetInsertMode_Proxy( + IAMTimeline* This, + LONG *mode); +void __RPC_STUB IAMTimeline_GetInsertMode_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimeline_SetInsertMode_Proxy( + IAMTimeline* This, + LONG mode); +void __RPC_STUB IAMTimeline_SetInsertMode_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimeline_EnableTransitions_Proxy( + IAMTimeline* This, + WINBOOL enabled); +void __RPC_STUB IAMTimeline_EnableTransitions_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimeline_TransitionsEnabled_Proxy( + IAMTimeline* This, + WINBOOL *enabled); +void __RPC_STUB IAMTimeline_TransitionsEnabled_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimeline_EnableEffects_Proxy( + IAMTimeline* This, + WINBOOL enabled); +void __RPC_STUB IAMTimeline_EnableEffects_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimeline_EffectsEnabled_Proxy( + IAMTimeline* This, + WINBOOL *enabled); +void __RPC_STUB IAMTimeline_EffectsEnabled_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimeline_SetInterestRange_Proxy( + IAMTimeline* This, + REFERENCE_TIME start, + REFERENCE_TIME stop); +void __RPC_STUB IAMTimeline_SetInterestRange_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimeline_GetDuration_Proxy( + IAMTimeline* This, + REFERENCE_TIME *duration); +void __RPC_STUB IAMTimeline_GetDuration_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimeline_GetDuration2_Proxy( + IAMTimeline* This, + double *duration); +void __RPC_STUB IAMTimeline_GetDuration2_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimeline_SetDefaultFPS_Proxy( + IAMTimeline* This, + double fps); +void __RPC_STUB IAMTimeline_SetDefaultFPS_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimeline_GetDefaultFPS_Proxy( + IAMTimeline* This, + double *fps); +void __RPC_STUB IAMTimeline_GetDefaultFPS_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimeline_IsDirty_Proxy( + IAMTimeline* This, + WINBOOL *dirty); +void __RPC_STUB IAMTimeline_IsDirty_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimeline_GetDirtyRange_Proxy( + IAMTimeline* This, + REFERENCE_TIME *start, + REFERENCE_TIME *stop); +void __RPC_STUB IAMTimeline_GetDirtyRange_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimeline_GetCountOfType_Proxy( + IAMTimeline* This, + LONG group, + LONG *value, + LONG *value_with_comps, + TIMELINE_MAJOR_TYPE type); +void __RPC_STUB IAMTimeline_GetCountOfType_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimeline_ValidateSourceNames_Proxy( + IAMTimeline* This, + LONG flags, + IMediaLocator *override, + LONG_PTR notify_event); +void __RPC_STUB IAMTimeline_ValidateSourceNames_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimeline_SetDefaultTransition_Proxy( + IAMTimeline* This, + GUID *guid); +void __RPC_STUB IAMTimeline_SetDefaultTransition_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimeline_GetDefaultTransition_Proxy( + IAMTimeline* This, + GUID *guid); +void __RPC_STUB IAMTimeline_GetDefaultTransition_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimeline_SetDefaultEffect_Proxy( + IAMTimeline* This, + GUID *guid); +void __RPC_STUB IAMTimeline_SetDefaultEffect_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimeline_GetDefaultEffect_Proxy( + IAMTimeline* This, + GUID *guid); +void __RPC_STUB IAMTimeline_GetDefaultEffect_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimeline_SetDefaultTransitionB_Proxy( + IAMTimeline* This, + BSTR guidb); +void __RPC_STUB IAMTimeline_SetDefaultTransitionB_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimeline_GetDefaultTransitionB_Proxy( + IAMTimeline* This, + BSTR *guidb); +void __RPC_STUB IAMTimeline_GetDefaultTransitionB_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimeline_SetDefaultEffectB_Proxy( + IAMTimeline* This, + BSTR guidb); +void __RPC_STUB IAMTimeline_SetDefaultEffectB_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimeline_GetDefaultEffectB_Proxy( + IAMTimeline* This, + BSTR *guidb); +void __RPC_STUB IAMTimeline_GetDefaultEffectB_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IAMTimeline_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * AMTimeline coclass + */ + +DEFINE_GUID(CLSID_AMTimeline, 0x78530b75, 0x61f9, 0x11d2, 0x8c,0xad, 0x00,0xa0,0x24,0x58,0x09,0x02); + +#ifdef __cplusplus +class DECLSPEC_UUID("78530b75-61f9-11d2-8cad-00a024580902") AMTimeline; +#ifdef __CRT_UUID_DECL +__CRT_UUID_DECL(AMTimeline, 0x78530b75, 0x61f9, 0x11d2, 0x8c,0xad, 0x00,0xa0,0x24,0x58,0x09,0x02) +#endif +#endif + +/***************************************************************************** + * IAMTimelineGroup interface + */ +#ifndef __IAMTimelineGroup_INTERFACE_DEFINED__ +#define __IAMTimelineGroup_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IAMTimelineGroup, 0x9eed4f00, 0xb8a6, 0x11d2, 0x80,0x23, 0x00,0xc0,0xdf,0x10,0xd4,0x34); +#if defined(__cplusplus) && !defined(CINTERFACE) +MIDL_INTERFACE("9eed4f00-b8a6-11d2-8023-00c0df10d434") +IAMTimelineGroup : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE SetTimeline( + IAMTimeline *timeline) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetTimeline( + IAMTimeline **timeline) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetPriority( + LONG *priority) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetMediaType( + AM_MEDIA_TYPE *a) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetMediaType( + AM_MEDIA_TYPE *a) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetOutputFPS( + double fps) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetOutputFPS( + double *fps) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetGroupName( + BSTR name) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetGroupName( + BSTR *name) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetPreviewMode( + WINBOOL preview) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetPreviewMode( + WINBOOL *preview) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetMediaTypeForVB( + LONG type) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetOutputBuffering( + int *buffer) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetOutputBuffering( + int buffer) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetSmartRecompressFormat( + LONG *format) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetSmartRecompressFormat( + LONG **format) = 0; + + virtual HRESULT STDMETHODCALLTYPE IsSmartRecompressFormatSet( + WINBOOL *set) = 0; + + virtual HRESULT STDMETHODCALLTYPE IsRecompressFormatDirty( + WINBOOL *dirty) = 0; + + virtual HRESULT STDMETHODCALLTYPE ClearRecompressFormatDirty( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetRecompFormatFromSource( + IAMTimelineSrc *source) = 0; + +}; +#ifdef __CRT_UUID_DECL +__CRT_UUID_DECL(IAMTimelineGroup, 0x9eed4f00, 0xb8a6, 0x11d2, 0x80,0x23, 0x00,0xc0,0xdf,0x10,0xd4,0x34) +#endif +#else +typedef struct IAMTimelineGroupVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IAMTimelineGroup* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IAMTimelineGroup* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IAMTimelineGroup* This); + + /*** IAMTimelineGroup methods ***/ + HRESULT (STDMETHODCALLTYPE *SetTimeline)( + IAMTimelineGroup* This, + IAMTimeline *timeline); + + HRESULT (STDMETHODCALLTYPE *GetTimeline)( + IAMTimelineGroup* This, + IAMTimeline **timeline); + + HRESULT (STDMETHODCALLTYPE *GetPriority)( + IAMTimelineGroup* This, + LONG *priority); + + HRESULT (STDMETHODCALLTYPE *GetMediaType)( + IAMTimelineGroup* This, + AM_MEDIA_TYPE *a); + + HRESULT (STDMETHODCALLTYPE *SetMediaType)( + IAMTimelineGroup* This, + AM_MEDIA_TYPE *a); + + HRESULT (STDMETHODCALLTYPE *SetOutputFPS)( + IAMTimelineGroup* This, + double fps); + + HRESULT (STDMETHODCALLTYPE *GetOutputFPS)( + IAMTimelineGroup* This, + double *fps); + + HRESULT (STDMETHODCALLTYPE *SetGroupName)( + IAMTimelineGroup* This, + BSTR name); + + HRESULT (STDMETHODCALLTYPE *GetGroupName)( + IAMTimelineGroup* This, + BSTR *name); + + HRESULT (STDMETHODCALLTYPE *SetPreviewMode)( + IAMTimelineGroup* This, + WINBOOL preview); + + HRESULT (STDMETHODCALLTYPE *GetPreviewMode)( + IAMTimelineGroup* This, + WINBOOL *preview); + + HRESULT (STDMETHODCALLTYPE *SetMediaTypeForVB)( + IAMTimelineGroup* This, + LONG type); + + HRESULT (STDMETHODCALLTYPE *GetOutputBuffering)( + IAMTimelineGroup* This, + int *buffer); + + HRESULT (STDMETHODCALLTYPE *SetOutputBuffering)( + IAMTimelineGroup* This, + int buffer); + + HRESULT (STDMETHODCALLTYPE *SetSmartRecompressFormat)( + IAMTimelineGroup* This, + LONG *format); + + HRESULT (STDMETHODCALLTYPE *GetSmartRecompressFormat)( + IAMTimelineGroup* This, + LONG **format); + + HRESULT (STDMETHODCALLTYPE *IsSmartRecompressFormatSet)( + IAMTimelineGroup* This, + WINBOOL *set); + + HRESULT (STDMETHODCALLTYPE *IsRecompressFormatDirty)( + IAMTimelineGroup* This, + WINBOOL *dirty); + + HRESULT (STDMETHODCALLTYPE *ClearRecompressFormatDirty)( + IAMTimelineGroup* This); + + HRESULT (STDMETHODCALLTYPE *SetRecompFormatFromSource)( + IAMTimelineGroup* This, + IAMTimelineSrc *source); + + END_INTERFACE +} IAMTimelineGroupVtbl; +interface IAMTimelineGroup { + CONST_VTBL IAMTimelineGroupVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +#ifndef WIDL_C_INLINE_WRAPPERS +/*** IUnknown methods ***/ +#define IAMTimelineGroup_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IAMTimelineGroup_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IAMTimelineGroup_Release(This) (This)->lpVtbl->Release(This) +/*** IAMTimelineGroup methods ***/ +#define IAMTimelineGroup_SetTimeline(This,timeline) (This)->lpVtbl->SetTimeline(This,timeline) +#define IAMTimelineGroup_GetTimeline(This,timeline) (This)->lpVtbl->GetTimeline(This,timeline) +#define IAMTimelineGroup_GetPriority(This,priority) (This)->lpVtbl->GetPriority(This,priority) +#define IAMTimelineGroup_GetMediaType(This,a) (This)->lpVtbl->GetMediaType(This,a) +#define IAMTimelineGroup_SetMediaType(This,a) (This)->lpVtbl->SetMediaType(This,a) +#define IAMTimelineGroup_SetOutputFPS(This,fps) (This)->lpVtbl->SetOutputFPS(This,fps) +#define IAMTimelineGroup_GetOutputFPS(This,fps) (This)->lpVtbl->GetOutputFPS(This,fps) +#define IAMTimelineGroup_SetGroupName(This,name) (This)->lpVtbl->SetGroupName(This,name) +#define IAMTimelineGroup_GetGroupName(This,name) (This)->lpVtbl->GetGroupName(This,name) +#define IAMTimelineGroup_SetPreviewMode(This,preview) (This)->lpVtbl->SetPreviewMode(This,preview) +#define IAMTimelineGroup_GetPreviewMode(This,preview) (This)->lpVtbl->GetPreviewMode(This,preview) +#define IAMTimelineGroup_SetMediaTypeForVB(This,type) (This)->lpVtbl->SetMediaTypeForVB(This,type) +#define IAMTimelineGroup_GetOutputBuffering(This,buffer) (This)->lpVtbl->GetOutputBuffering(This,buffer) +#define IAMTimelineGroup_SetOutputBuffering(This,buffer) (This)->lpVtbl->SetOutputBuffering(This,buffer) +#define IAMTimelineGroup_SetSmartRecompressFormat(This,format) (This)->lpVtbl->SetSmartRecompressFormat(This,format) +#define IAMTimelineGroup_GetSmartRecompressFormat(This,format) (This)->lpVtbl->GetSmartRecompressFormat(This,format) +#define IAMTimelineGroup_IsSmartRecompressFormatSet(This,set) (This)->lpVtbl->IsSmartRecompressFormatSet(This,set) +#define IAMTimelineGroup_IsRecompressFormatDirty(This,dirty) (This)->lpVtbl->IsRecompressFormatDirty(This,dirty) +#define IAMTimelineGroup_ClearRecompressFormatDirty(This) (This)->lpVtbl->ClearRecompressFormatDirty(This) +#define IAMTimelineGroup_SetRecompFormatFromSource(This,source) (This)->lpVtbl->SetRecompFormatFromSource(This,source) +#else +/*** IUnknown methods ***/ +static FORCEINLINE HRESULT IAMTimelineGroup_QueryInterface(IAMTimelineGroup* This,REFIID riid,void **ppvObject) { + return This->lpVtbl->QueryInterface(This,riid,ppvObject); +} +static FORCEINLINE ULONG IAMTimelineGroup_AddRef(IAMTimelineGroup* This) { + return This->lpVtbl->AddRef(This); +} +static FORCEINLINE ULONG IAMTimelineGroup_Release(IAMTimelineGroup* This) { + return This->lpVtbl->Release(This); +} +/*** IAMTimelineGroup methods ***/ +static FORCEINLINE HRESULT IAMTimelineGroup_SetTimeline(IAMTimelineGroup* This,IAMTimeline *timeline) { + return This->lpVtbl->SetTimeline(This,timeline); +} +static FORCEINLINE HRESULT IAMTimelineGroup_GetTimeline(IAMTimelineGroup* This,IAMTimeline **timeline) { + return This->lpVtbl->GetTimeline(This,timeline); +} +static FORCEINLINE HRESULT IAMTimelineGroup_GetPriority(IAMTimelineGroup* This,LONG *priority) { + return This->lpVtbl->GetPriority(This,priority); +} +static FORCEINLINE HRESULT IAMTimelineGroup_GetMediaType(IAMTimelineGroup* This,AM_MEDIA_TYPE *a) { + return This->lpVtbl->GetMediaType(This,a); +} +static FORCEINLINE HRESULT IAMTimelineGroup_SetMediaType(IAMTimelineGroup* This,AM_MEDIA_TYPE *a) { + return This->lpVtbl->SetMediaType(This,a); +} +static FORCEINLINE HRESULT IAMTimelineGroup_SetOutputFPS(IAMTimelineGroup* This,double fps) { + return This->lpVtbl->SetOutputFPS(This,fps); +} +static FORCEINLINE HRESULT IAMTimelineGroup_GetOutputFPS(IAMTimelineGroup* This,double *fps) { + return This->lpVtbl->GetOutputFPS(This,fps); +} +static FORCEINLINE HRESULT IAMTimelineGroup_SetGroupName(IAMTimelineGroup* This,BSTR name) { + return This->lpVtbl->SetGroupName(This,name); +} +static FORCEINLINE HRESULT IAMTimelineGroup_GetGroupName(IAMTimelineGroup* This,BSTR *name) { + return This->lpVtbl->GetGroupName(This,name); +} +static FORCEINLINE HRESULT IAMTimelineGroup_SetPreviewMode(IAMTimelineGroup* This,WINBOOL preview) { + return This->lpVtbl->SetPreviewMode(This,preview); +} +static FORCEINLINE HRESULT IAMTimelineGroup_GetPreviewMode(IAMTimelineGroup* This,WINBOOL *preview) { + return This->lpVtbl->GetPreviewMode(This,preview); +} +static FORCEINLINE HRESULT IAMTimelineGroup_SetMediaTypeForVB(IAMTimelineGroup* This,LONG type) { + return This->lpVtbl->SetMediaTypeForVB(This,type); +} +static FORCEINLINE HRESULT IAMTimelineGroup_GetOutputBuffering(IAMTimelineGroup* This,int *buffer) { + return This->lpVtbl->GetOutputBuffering(This,buffer); +} +static FORCEINLINE HRESULT IAMTimelineGroup_SetOutputBuffering(IAMTimelineGroup* This,int buffer) { + return This->lpVtbl->SetOutputBuffering(This,buffer); +} +static FORCEINLINE HRESULT IAMTimelineGroup_SetSmartRecompressFormat(IAMTimelineGroup* This,LONG *format) { + return This->lpVtbl->SetSmartRecompressFormat(This,format); +} +static FORCEINLINE HRESULT IAMTimelineGroup_GetSmartRecompressFormat(IAMTimelineGroup* This,LONG **format) { + return This->lpVtbl->GetSmartRecompressFormat(This,format); +} +static FORCEINLINE HRESULT IAMTimelineGroup_IsSmartRecompressFormatSet(IAMTimelineGroup* This,WINBOOL *set) { + return This->lpVtbl->IsSmartRecompressFormatSet(This,set); +} +static FORCEINLINE HRESULT IAMTimelineGroup_IsRecompressFormatDirty(IAMTimelineGroup* This,WINBOOL *dirty) { + return This->lpVtbl->IsRecompressFormatDirty(This,dirty); +} +static FORCEINLINE HRESULT IAMTimelineGroup_ClearRecompressFormatDirty(IAMTimelineGroup* This) { + return This->lpVtbl->ClearRecompressFormatDirty(This); +} +static FORCEINLINE HRESULT IAMTimelineGroup_SetRecompFormatFromSource(IAMTimelineGroup* This,IAMTimelineSrc *source) { + return This->lpVtbl->SetRecompFormatFromSource(This,source); +} +#endif +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IAMTimelineGroup_SetTimeline_Proxy( + IAMTimelineGroup* This, + IAMTimeline *timeline); +void __RPC_STUB IAMTimelineGroup_SetTimeline_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineGroup_GetTimeline_Proxy( + IAMTimelineGroup* This, + IAMTimeline **timeline); +void __RPC_STUB IAMTimelineGroup_GetTimeline_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineGroup_GetPriority_Proxy( + IAMTimelineGroup* This, + LONG *priority); +void __RPC_STUB IAMTimelineGroup_GetPriority_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineGroup_GetMediaType_Proxy( + IAMTimelineGroup* This, + AM_MEDIA_TYPE *a); +void __RPC_STUB IAMTimelineGroup_GetMediaType_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineGroup_SetMediaType_Proxy( + IAMTimelineGroup* This, + AM_MEDIA_TYPE *a); +void __RPC_STUB IAMTimelineGroup_SetMediaType_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineGroup_SetOutputFPS_Proxy( + IAMTimelineGroup* This, + double fps); +void __RPC_STUB IAMTimelineGroup_SetOutputFPS_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineGroup_GetOutputFPS_Proxy( + IAMTimelineGroup* This, + double *fps); +void __RPC_STUB IAMTimelineGroup_GetOutputFPS_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineGroup_SetGroupName_Proxy( + IAMTimelineGroup* This, + BSTR name); +void __RPC_STUB IAMTimelineGroup_SetGroupName_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineGroup_GetGroupName_Proxy( + IAMTimelineGroup* This, + BSTR *name); +void __RPC_STUB IAMTimelineGroup_GetGroupName_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineGroup_SetPreviewMode_Proxy( + IAMTimelineGroup* This, + WINBOOL preview); +void __RPC_STUB IAMTimelineGroup_SetPreviewMode_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineGroup_GetPreviewMode_Proxy( + IAMTimelineGroup* This, + WINBOOL *preview); +void __RPC_STUB IAMTimelineGroup_GetPreviewMode_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineGroup_SetMediaTypeForVB_Proxy( + IAMTimelineGroup* This, + LONG type); +void __RPC_STUB IAMTimelineGroup_SetMediaTypeForVB_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineGroup_GetOutputBuffering_Proxy( + IAMTimelineGroup* This, + int *buffer); +void __RPC_STUB IAMTimelineGroup_GetOutputBuffering_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineGroup_SetOutputBuffering_Proxy( + IAMTimelineGroup* This, + int buffer); +void __RPC_STUB IAMTimelineGroup_SetOutputBuffering_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineGroup_SetSmartRecompressFormat_Proxy( + IAMTimelineGroup* This, + LONG *format); +void __RPC_STUB IAMTimelineGroup_SetSmartRecompressFormat_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineGroup_GetSmartRecompressFormat_Proxy( + IAMTimelineGroup* This, + LONG **format); +void __RPC_STUB IAMTimelineGroup_GetSmartRecompressFormat_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineGroup_IsSmartRecompressFormatSet_Proxy( + IAMTimelineGroup* This, + WINBOOL *set); +void __RPC_STUB IAMTimelineGroup_IsSmartRecompressFormatSet_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineGroup_IsRecompressFormatDirty_Proxy( + IAMTimelineGroup* This, + WINBOOL *dirty); +void __RPC_STUB IAMTimelineGroup_IsRecompressFormatDirty_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineGroup_ClearRecompressFormatDirty_Proxy( + IAMTimelineGroup* This); +void __RPC_STUB IAMTimelineGroup_ClearRecompressFormatDirty_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineGroup_SetRecompFormatFromSource_Proxy( + IAMTimelineGroup* This, + IAMTimelineSrc *source); +void __RPC_STUB IAMTimelineGroup_SetRecompFormatFromSource_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IAMTimelineGroup_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IAMTimelineObj interface + */ +#ifndef __IAMTimelineObj_INTERFACE_DEFINED__ +#define __IAMTimelineObj_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IAMTimelineObj, 0x78530b77, 0x61f9, 0x11d2, 0x8c,0xad, 0x00,0xa0,0x24,0x58,0x09,0x02); +#if defined(__cplusplus) && !defined(CINTERFACE) +MIDL_INTERFACE("78530b77-61f9-11d2-8cad-00a024580902") +IAMTimelineObj : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE GetStartStop( + REFERENCE_TIME *start, + REFERENCE_TIME *stop) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetStartStop2( + REFTIME *start, + REFTIME *stop) = 0; + + virtual HRESULT STDMETHODCALLTYPE FixTimes( + REFERENCE_TIME *start, + REFERENCE_TIME *stop) = 0; + + virtual HRESULT STDMETHODCALLTYPE FixTimes2( + REFTIME *start, + REFTIME *stop) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetStartStop( + REFERENCE_TIME start, + REFERENCE_TIME stop) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetStartStop2( + REFTIME start, + REFTIME stop) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetPropertySetter( + IPropertySetter **setter) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetPropertySetter( + IPropertySetter *setter) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetSubObject( + IUnknown **obj) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetSubObject( + IUnknown *obj) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetSubObjectGUID( + GUID guid) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetSubObjectGUIDB( + BSTR guidb) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetSubObjectGUID( + GUID *guid) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetSubObjectGUIDB( + BSTR *guidb) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetSubObjectLoaded( + WINBOOL *loaded) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetTimelineType( + TIMELINE_MAJOR_TYPE *type) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetTimelineType( + TIMELINE_MAJOR_TYPE type) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetUserID( + LONG *id) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetUserID( + LONG id) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetGenID( + LONG *id) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetUserName( + BSTR *name) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetUserName( + BSTR name) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetUserData( + BYTE *data, + LONG *size) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetUserData( + BYTE *data, + LONG size) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetMuted( + WINBOOL *muted) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetMuted( + WINBOOL muted) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetLocked( + WINBOOL *locked) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetLocked( + WINBOOL locked) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDirtyRange( + REFERENCE_TIME *start, + REFERENCE_TIME *stop) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDirtyRange2( + REFTIME *start, + REFTIME *stop) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetDirtyRange( + REFERENCE_TIME start, + REFERENCE_TIME stop) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetDirtyRange2( + REFTIME start, + REFTIME stop) = 0; + + virtual HRESULT STDMETHODCALLTYPE ClearDirty( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE Remove( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE RemoveAll( + ) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetTimelineNoRef( + IAMTimeline **timeline) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetGroupIBelongTo( + IAMTimelineGroup **group) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetEmbedDepth( + LONG *depth) = 0; + +}; +#ifdef __CRT_UUID_DECL +__CRT_UUID_DECL(IAMTimelineObj, 0x78530b77, 0x61f9, 0x11d2, 0x8c,0xad, 0x00,0xa0,0x24,0x58,0x09,0x02) +#endif +#else +typedef struct IAMTimelineObjVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IAMTimelineObj* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IAMTimelineObj* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IAMTimelineObj* This); + + /*** IAMTimelineObj methods ***/ + HRESULT (STDMETHODCALLTYPE *GetStartStop)( + IAMTimelineObj* This, + REFERENCE_TIME *start, + REFERENCE_TIME *stop); + + HRESULT (STDMETHODCALLTYPE *GetStartStop2)( + IAMTimelineObj* This, + REFTIME *start, + REFTIME *stop); + + HRESULT (STDMETHODCALLTYPE *FixTimes)( + IAMTimelineObj* This, + REFERENCE_TIME *start, + REFERENCE_TIME *stop); + + HRESULT (STDMETHODCALLTYPE *FixTimes2)( + IAMTimelineObj* This, + REFTIME *start, + REFTIME *stop); + + HRESULT (STDMETHODCALLTYPE *SetStartStop)( + IAMTimelineObj* This, + REFERENCE_TIME start, + REFERENCE_TIME stop); + + HRESULT (STDMETHODCALLTYPE *SetStartStop2)( + IAMTimelineObj* This, + REFTIME start, + REFTIME stop); + + HRESULT (STDMETHODCALLTYPE *GetPropertySetter)( + IAMTimelineObj* This, + IPropertySetter **setter); + + HRESULT (STDMETHODCALLTYPE *SetPropertySetter)( + IAMTimelineObj* This, + IPropertySetter *setter); + + HRESULT (STDMETHODCALLTYPE *GetSubObject)( + IAMTimelineObj* This, + IUnknown **obj); + + HRESULT (STDMETHODCALLTYPE *SetSubObject)( + IAMTimelineObj* This, + IUnknown *obj); + + HRESULT (STDMETHODCALLTYPE *SetSubObjectGUID)( + IAMTimelineObj* This, + GUID guid); + + HRESULT (STDMETHODCALLTYPE *SetSubObjectGUIDB)( + IAMTimelineObj* This, + BSTR guidb); + + HRESULT (STDMETHODCALLTYPE *GetSubObjectGUID)( + IAMTimelineObj* This, + GUID *guid); + + HRESULT (STDMETHODCALLTYPE *GetSubObjectGUIDB)( + IAMTimelineObj* This, + BSTR *guidb); + + HRESULT (STDMETHODCALLTYPE *GetSubObjectLoaded)( + IAMTimelineObj* This, + WINBOOL *loaded); + + HRESULT (STDMETHODCALLTYPE *GetTimelineType)( + IAMTimelineObj* This, + TIMELINE_MAJOR_TYPE *type); + + HRESULT (STDMETHODCALLTYPE *SetTimelineType)( + IAMTimelineObj* This, + TIMELINE_MAJOR_TYPE type); + + HRESULT (STDMETHODCALLTYPE *GetUserID)( + IAMTimelineObj* This, + LONG *id); + + HRESULT (STDMETHODCALLTYPE *SetUserID)( + IAMTimelineObj* This, + LONG id); + + HRESULT (STDMETHODCALLTYPE *GetGenID)( + IAMTimelineObj* This, + LONG *id); + + HRESULT (STDMETHODCALLTYPE *GetUserName)( + IAMTimelineObj* This, + BSTR *name); + + HRESULT (STDMETHODCALLTYPE *SetUserName)( + IAMTimelineObj* This, + BSTR name); + + HRESULT (STDMETHODCALLTYPE *GetUserData)( + IAMTimelineObj* This, + BYTE *data, + LONG *size); + + HRESULT (STDMETHODCALLTYPE *SetUserData)( + IAMTimelineObj* This, + BYTE *data, + LONG size); + + HRESULT (STDMETHODCALLTYPE *GetMuted)( + IAMTimelineObj* This, + WINBOOL *muted); + + HRESULT (STDMETHODCALLTYPE *SetMuted)( + IAMTimelineObj* This, + WINBOOL muted); + + HRESULT (STDMETHODCALLTYPE *GetLocked)( + IAMTimelineObj* This, + WINBOOL *locked); + + HRESULT (STDMETHODCALLTYPE *SetLocked)( + IAMTimelineObj* This, + WINBOOL locked); + + HRESULT (STDMETHODCALLTYPE *GetDirtyRange)( + IAMTimelineObj* This, + REFERENCE_TIME *start, + REFERENCE_TIME *stop); + + HRESULT (STDMETHODCALLTYPE *GetDirtyRange2)( + IAMTimelineObj* This, + REFTIME *start, + REFTIME *stop); + + HRESULT (STDMETHODCALLTYPE *SetDirtyRange)( + IAMTimelineObj* This, + REFERENCE_TIME start, + REFERENCE_TIME stop); + + HRESULT (STDMETHODCALLTYPE *SetDirtyRange2)( + IAMTimelineObj* This, + REFTIME start, + REFTIME stop); + + HRESULT (STDMETHODCALLTYPE *ClearDirty)( + IAMTimelineObj* This); + + HRESULT (STDMETHODCALLTYPE *Remove)( + IAMTimelineObj* This); + + HRESULT (STDMETHODCALLTYPE *RemoveAll)( + IAMTimelineObj* This); + + HRESULT (STDMETHODCALLTYPE *GetTimelineNoRef)( + IAMTimelineObj* This, + IAMTimeline **timeline); + + HRESULT (STDMETHODCALLTYPE *GetGroupIBelongTo)( + IAMTimelineObj* This, + IAMTimelineGroup **group); + + HRESULT (STDMETHODCALLTYPE *GetEmbedDepth)( + IAMTimelineObj* This, + LONG *depth); + + END_INTERFACE +} IAMTimelineObjVtbl; +interface IAMTimelineObj { + CONST_VTBL IAMTimelineObjVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +#ifndef WIDL_C_INLINE_WRAPPERS +/*** IUnknown methods ***/ +#define IAMTimelineObj_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IAMTimelineObj_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IAMTimelineObj_Release(This) (This)->lpVtbl->Release(This) +/*** IAMTimelineObj methods ***/ +#define IAMTimelineObj_GetStartStop(This,start,stop) (This)->lpVtbl->GetStartStop(This,start,stop) +#define IAMTimelineObj_GetStartStop2(This,start,stop) (This)->lpVtbl->GetStartStop2(This,start,stop) +#define IAMTimelineObj_FixTimes(This,start,stop) (This)->lpVtbl->FixTimes(This,start,stop) +#define IAMTimelineObj_FixTimes2(This,start,stop) (This)->lpVtbl->FixTimes2(This,start,stop) +#define IAMTimelineObj_SetStartStop(This,start,stop) (This)->lpVtbl->SetStartStop(This,start,stop) +#define IAMTimelineObj_SetStartStop2(This,start,stop) (This)->lpVtbl->SetStartStop2(This,start,stop) +#define IAMTimelineObj_GetPropertySetter(This,setter) (This)->lpVtbl->GetPropertySetter(This,setter) +#define IAMTimelineObj_SetPropertySetter(This,setter) (This)->lpVtbl->SetPropertySetter(This,setter) +#define IAMTimelineObj_GetSubObject(This,obj) (This)->lpVtbl->GetSubObject(This,obj) +#define IAMTimelineObj_SetSubObject(This,obj) (This)->lpVtbl->SetSubObject(This,obj) +#define IAMTimelineObj_SetSubObjectGUID(This,guid) (This)->lpVtbl->SetSubObjectGUID(This,guid) +#define IAMTimelineObj_SetSubObjectGUIDB(This,guidb) (This)->lpVtbl->SetSubObjectGUIDB(This,guidb) +#define IAMTimelineObj_GetSubObjectGUID(This,guid) (This)->lpVtbl->GetSubObjectGUID(This,guid) +#define IAMTimelineObj_GetSubObjectGUIDB(This,guidb) (This)->lpVtbl->GetSubObjectGUIDB(This,guidb) +#define IAMTimelineObj_GetSubObjectLoaded(This,loaded) (This)->lpVtbl->GetSubObjectLoaded(This,loaded) +#define IAMTimelineObj_GetTimelineType(This,type) (This)->lpVtbl->GetTimelineType(This,type) +#define IAMTimelineObj_SetTimelineType(This,type) (This)->lpVtbl->SetTimelineType(This,type) +#define IAMTimelineObj_GetUserID(This,id) (This)->lpVtbl->GetUserID(This,id) +#define IAMTimelineObj_SetUserID(This,id) (This)->lpVtbl->SetUserID(This,id) +#define IAMTimelineObj_GetGenID(This,id) (This)->lpVtbl->GetGenID(This,id) +#define IAMTimelineObj_GetUserName(This,name) (This)->lpVtbl->GetUserName(This,name) +#define IAMTimelineObj_SetUserName(This,name) (This)->lpVtbl->SetUserName(This,name) +#define IAMTimelineObj_GetUserData(This,data,size) (This)->lpVtbl->GetUserData(This,data,size) +#define IAMTimelineObj_SetUserData(This,data,size) (This)->lpVtbl->SetUserData(This,data,size) +#define IAMTimelineObj_GetMuted(This,muted) (This)->lpVtbl->GetMuted(This,muted) +#define IAMTimelineObj_SetMuted(This,muted) (This)->lpVtbl->SetMuted(This,muted) +#define IAMTimelineObj_GetLocked(This,locked) (This)->lpVtbl->GetLocked(This,locked) +#define IAMTimelineObj_SetLocked(This,locked) (This)->lpVtbl->SetLocked(This,locked) +#define IAMTimelineObj_GetDirtyRange(This,start,stop) (This)->lpVtbl->GetDirtyRange(This,start,stop) +#define IAMTimelineObj_GetDirtyRange2(This,start,stop) (This)->lpVtbl->GetDirtyRange2(This,start,stop) +#define IAMTimelineObj_SetDirtyRange(This,start,stop) (This)->lpVtbl->SetDirtyRange(This,start,stop) +#define IAMTimelineObj_SetDirtyRange2(This,start,stop) (This)->lpVtbl->SetDirtyRange2(This,start,stop) +#define IAMTimelineObj_ClearDirty(This) (This)->lpVtbl->ClearDirty(This) +#define IAMTimelineObj_Remove(This) (This)->lpVtbl->Remove(This) +#define IAMTimelineObj_RemoveAll(This) (This)->lpVtbl->RemoveAll(This) +#define IAMTimelineObj_GetTimelineNoRef(This,timeline) (This)->lpVtbl->GetTimelineNoRef(This,timeline) +#define IAMTimelineObj_GetGroupIBelongTo(This,group) (This)->lpVtbl->GetGroupIBelongTo(This,group) +#define IAMTimelineObj_GetEmbedDepth(This,depth) (This)->lpVtbl->GetEmbedDepth(This,depth) +#else +/*** IUnknown methods ***/ +static FORCEINLINE HRESULT IAMTimelineObj_QueryInterface(IAMTimelineObj* This,REFIID riid,void **ppvObject) { + return This->lpVtbl->QueryInterface(This,riid,ppvObject); +} +static FORCEINLINE ULONG IAMTimelineObj_AddRef(IAMTimelineObj* This) { + return This->lpVtbl->AddRef(This); +} +static FORCEINLINE ULONG IAMTimelineObj_Release(IAMTimelineObj* This) { + return This->lpVtbl->Release(This); +} +/*** IAMTimelineObj methods ***/ +static FORCEINLINE HRESULT IAMTimelineObj_GetStartStop(IAMTimelineObj* This,REFERENCE_TIME *start,REFERENCE_TIME *stop) { + return This->lpVtbl->GetStartStop(This,start,stop); +} +static FORCEINLINE HRESULT IAMTimelineObj_GetStartStop2(IAMTimelineObj* This,REFTIME *start,REFTIME *stop) { + return This->lpVtbl->GetStartStop2(This,start,stop); +} +static FORCEINLINE HRESULT IAMTimelineObj_FixTimes(IAMTimelineObj* This,REFERENCE_TIME *start,REFERENCE_TIME *stop) { + return This->lpVtbl->FixTimes(This,start,stop); +} +static FORCEINLINE HRESULT IAMTimelineObj_FixTimes2(IAMTimelineObj* This,REFTIME *start,REFTIME *stop) { + return This->lpVtbl->FixTimes2(This,start,stop); +} +static FORCEINLINE HRESULT IAMTimelineObj_SetStartStop(IAMTimelineObj* This,REFERENCE_TIME start,REFERENCE_TIME stop) { + return This->lpVtbl->SetStartStop(This,start,stop); +} +static FORCEINLINE HRESULT IAMTimelineObj_SetStartStop2(IAMTimelineObj* This,REFTIME start,REFTIME stop) { + return This->lpVtbl->SetStartStop2(This,start,stop); +} +static FORCEINLINE HRESULT IAMTimelineObj_GetPropertySetter(IAMTimelineObj* This,IPropertySetter **setter) { + return This->lpVtbl->GetPropertySetter(This,setter); +} +static FORCEINLINE HRESULT IAMTimelineObj_SetPropertySetter(IAMTimelineObj* This,IPropertySetter *setter) { + return This->lpVtbl->SetPropertySetter(This,setter); +} +static FORCEINLINE HRESULT IAMTimelineObj_GetSubObject(IAMTimelineObj* This,IUnknown **obj) { + return This->lpVtbl->GetSubObject(This,obj); +} +static FORCEINLINE HRESULT IAMTimelineObj_SetSubObject(IAMTimelineObj* This,IUnknown *obj) { + return This->lpVtbl->SetSubObject(This,obj); +} +static FORCEINLINE HRESULT IAMTimelineObj_SetSubObjectGUID(IAMTimelineObj* This,GUID guid) { + return This->lpVtbl->SetSubObjectGUID(This,guid); +} +static FORCEINLINE HRESULT IAMTimelineObj_SetSubObjectGUIDB(IAMTimelineObj* This,BSTR guidb) { + return This->lpVtbl->SetSubObjectGUIDB(This,guidb); +} +static FORCEINLINE HRESULT IAMTimelineObj_GetSubObjectGUID(IAMTimelineObj* This,GUID *guid) { + return This->lpVtbl->GetSubObjectGUID(This,guid); +} +static FORCEINLINE HRESULT IAMTimelineObj_GetSubObjectGUIDB(IAMTimelineObj* This,BSTR *guidb) { + return This->lpVtbl->GetSubObjectGUIDB(This,guidb); +} +static FORCEINLINE HRESULT IAMTimelineObj_GetSubObjectLoaded(IAMTimelineObj* This,WINBOOL *loaded) { + return This->lpVtbl->GetSubObjectLoaded(This,loaded); +} +static FORCEINLINE HRESULT IAMTimelineObj_GetTimelineType(IAMTimelineObj* This,TIMELINE_MAJOR_TYPE *type) { + return This->lpVtbl->GetTimelineType(This,type); +} +static FORCEINLINE HRESULT IAMTimelineObj_SetTimelineType(IAMTimelineObj* This,TIMELINE_MAJOR_TYPE type) { + return This->lpVtbl->SetTimelineType(This,type); +} +static FORCEINLINE HRESULT IAMTimelineObj_GetUserID(IAMTimelineObj* This,LONG *id) { + return This->lpVtbl->GetUserID(This,id); +} +static FORCEINLINE HRESULT IAMTimelineObj_SetUserID(IAMTimelineObj* This,LONG id) { + return This->lpVtbl->SetUserID(This,id); +} +static FORCEINLINE HRESULT IAMTimelineObj_GetGenID(IAMTimelineObj* This,LONG *id) { + return This->lpVtbl->GetGenID(This,id); +} +static FORCEINLINE HRESULT IAMTimelineObj_GetUserName(IAMTimelineObj* This,BSTR *name) { + return This->lpVtbl->GetUserName(This,name); +} +static FORCEINLINE HRESULT IAMTimelineObj_SetUserName(IAMTimelineObj* This,BSTR name) { + return This->lpVtbl->SetUserName(This,name); +} +static FORCEINLINE HRESULT IAMTimelineObj_GetUserData(IAMTimelineObj* This,BYTE *data,LONG *size) { + return This->lpVtbl->GetUserData(This,data,size); +} +static FORCEINLINE HRESULT IAMTimelineObj_SetUserData(IAMTimelineObj* This,BYTE *data,LONG size) { + return This->lpVtbl->SetUserData(This,data,size); +} +static FORCEINLINE HRESULT IAMTimelineObj_GetMuted(IAMTimelineObj* This,WINBOOL *muted) { + return This->lpVtbl->GetMuted(This,muted); +} +static FORCEINLINE HRESULT IAMTimelineObj_SetMuted(IAMTimelineObj* This,WINBOOL muted) { + return This->lpVtbl->SetMuted(This,muted); +} +static FORCEINLINE HRESULT IAMTimelineObj_GetLocked(IAMTimelineObj* This,WINBOOL *locked) { + return This->lpVtbl->GetLocked(This,locked); +} +static FORCEINLINE HRESULT IAMTimelineObj_SetLocked(IAMTimelineObj* This,WINBOOL locked) { + return This->lpVtbl->SetLocked(This,locked); +} +static FORCEINLINE HRESULT IAMTimelineObj_GetDirtyRange(IAMTimelineObj* This,REFERENCE_TIME *start,REFERENCE_TIME *stop) { + return This->lpVtbl->GetDirtyRange(This,start,stop); +} +static FORCEINLINE HRESULT IAMTimelineObj_GetDirtyRange2(IAMTimelineObj* This,REFTIME *start,REFTIME *stop) { + return This->lpVtbl->GetDirtyRange2(This,start,stop); +} +static FORCEINLINE HRESULT IAMTimelineObj_SetDirtyRange(IAMTimelineObj* This,REFERENCE_TIME start,REFERENCE_TIME stop) { + return This->lpVtbl->SetDirtyRange(This,start,stop); +} +static FORCEINLINE HRESULT IAMTimelineObj_SetDirtyRange2(IAMTimelineObj* This,REFTIME start,REFTIME stop) { + return This->lpVtbl->SetDirtyRange2(This,start,stop); +} +static FORCEINLINE HRESULT IAMTimelineObj_ClearDirty(IAMTimelineObj* This) { + return This->lpVtbl->ClearDirty(This); +} +static FORCEINLINE HRESULT IAMTimelineObj_Remove(IAMTimelineObj* This) { + return This->lpVtbl->Remove(This); +} +static FORCEINLINE HRESULT IAMTimelineObj_RemoveAll(IAMTimelineObj* This) { + return This->lpVtbl->RemoveAll(This); +} +static FORCEINLINE HRESULT IAMTimelineObj_GetTimelineNoRef(IAMTimelineObj* This,IAMTimeline **timeline) { + return This->lpVtbl->GetTimelineNoRef(This,timeline); +} +static FORCEINLINE HRESULT IAMTimelineObj_GetGroupIBelongTo(IAMTimelineObj* This,IAMTimelineGroup **group) { + return This->lpVtbl->GetGroupIBelongTo(This,group); +} +static FORCEINLINE HRESULT IAMTimelineObj_GetEmbedDepth(IAMTimelineObj* This,LONG *depth) { + return This->lpVtbl->GetEmbedDepth(This,depth); +} +#endif +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IAMTimelineObj_GetStartStop_Proxy( + IAMTimelineObj* This, + REFERENCE_TIME *start, + REFERENCE_TIME *stop); +void __RPC_STUB IAMTimelineObj_GetStartStop_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineObj_GetStartStop2_Proxy( + IAMTimelineObj* This, + REFTIME *start, + REFTIME *stop); +void __RPC_STUB IAMTimelineObj_GetStartStop2_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineObj_FixTimes_Proxy( + IAMTimelineObj* This, + REFERENCE_TIME *start, + REFERENCE_TIME *stop); +void __RPC_STUB IAMTimelineObj_FixTimes_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineObj_FixTimes2_Proxy( + IAMTimelineObj* This, + REFTIME *start, + REFTIME *stop); +void __RPC_STUB IAMTimelineObj_FixTimes2_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineObj_SetStartStop_Proxy( + IAMTimelineObj* This, + REFERENCE_TIME start, + REFERENCE_TIME stop); +void __RPC_STUB IAMTimelineObj_SetStartStop_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineObj_SetStartStop2_Proxy( + IAMTimelineObj* This, + REFTIME start, + REFTIME stop); +void __RPC_STUB IAMTimelineObj_SetStartStop2_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineObj_GetPropertySetter_Proxy( + IAMTimelineObj* This, + IPropertySetter **setter); +void __RPC_STUB IAMTimelineObj_GetPropertySetter_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineObj_SetPropertySetter_Proxy( + IAMTimelineObj* This, + IPropertySetter *setter); +void __RPC_STUB IAMTimelineObj_SetPropertySetter_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineObj_GetSubObject_Proxy( + IAMTimelineObj* This, + IUnknown **obj); +void __RPC_STUB IAMTimelineObj_GetSubObject_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineObj_SetSubObject_Proxy( + IAMTimelineObj* This, + IUnknown *obj); +void __RPC_STUB IAMTimelineObj_SetSubObject_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineObj_SetSubObjectGUID_Proxy( + IAMTimelineObj* This, + GUID guid); +void __RPC_STUB IAMTimelineObj_SetSubObjectGUID_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineObj_SetSubObjectGUIDB_Proxy( + IAMTimelineObj* This, + BSTR guidb); +void __RPC_STUB IAMTimelineObj_SetSubObjectGUIDB_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineObj_GetSubObjectGUID_Proxy( + IAMTimelineObj* This, + GUID *guid); +void __RPC_STUB IAMTimelineObj_GetSubObjectGUID_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineObj_GetSubObjectGUIDB_Proxy( + IAMTimelineObj* This, + BSTR *guidb); +void __RPC_STUB IAMTimelineObj_GetSubObjectGUIDB_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineObj_GetSubObjectLoaded_Proxy( + IAMTimelineObj* This, + WINBOOL *loaded); +void __RPC_STUB IAMTimelineObj_GetSubObjectLoaded_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineObj_GetTimelineType_Proxy( + IAMTimelineObj* This, + TIMELINE_MAJOR_TYPE *type); +void __RPC_STUB IAMTimelineObj_GetTimelineType_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineObj_SetTimelineType_Proxy( + IAMTimelineObj* This, + TIMELINE_MAJOR_TYPE type); +void __RPC_STUB IAMTimelineObj_SetTimelineType_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineObj_GetUserID_Proxy( + IAMTimelineObj* This, + LONG *id); +void __RPC_STUB IAMTimelineObj_GetUserID_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineObj_SetUserID_Proxy( + IAMTimelineObj* This, + LONG id); +void __RPC_STUB IAMTimelineObj_SetUserID_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineObj_GetGenID_Proxy( + IAMTimelineObj* This, + LONG *id); +void __RPC_STUB IAMTimelineObj_GetGenID_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineObj_GetUserName_Proxy( + IAMTimelineObj* This, + BSTR *name); +void __RPC_STUB IAMTimelineObj_GetUserName_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineObj_SetUserName_Proxy( + IAMTimelineObj* This, + BSTR name); +void __RPC_STUB IAMTimelineObj_SetUserName_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineObj_GetUserData_Proxy( + IAMTimelineObj* This, + BYTE *data, + LONG *size); +void __RPC_STUB IAMTimelineObj_GetUserData_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineObj_SetUserData_Proxy( + IAMTimelineObj* This, + BYTE *data, + LONG size); +void __RPC_STUB IAMTimelineObj_SetUserData_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineObj_GetMuted_Proxy( + IAMTimelineObj* This, + WINBOOL *muted); +void __RPC_STUB IAMTimelineObj_GetMuted_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineObj_SetMuted_Proxy( + IAMTimelineObj* This, + WINBOOL muted); +void __RPC_STUB IAMTimelineObj_SetMuted_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineObj_GetLocked_Proxy( + IAMTimelineObj* This, + WINBOOL *locked); +void __RPC_STUB IAMTimelineObj_GetLocked_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineObj_SetLocked_Proxy( + IAMTimelineObj* This, + WINBOOL locked); +void __RPC_STUB IAMTimelineObj_SetLocked_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineObj_GetDirtyRange_Proxy( + IAMTimelineObj* This, + REFERENCE_TIME *start, + REFERENCE_TIME *stop); +void __RPC_STUB IAMTimelineObj_GetDirtyRange_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineObj_GetDirtyRange2_Proxy( + IAMTimelineObj* This, + REFTIME *start, + REFTIME *stop); +void __RPC_STUB IAMTimelineObj_GetDirtyRange2_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineObj_SetDirtyRange_Proxy( + IAMTimelineObj* This, + REFERENCE_TIME start, + REFERENCE_TIME stop); +void __RPC_STUB IAMTimelineObj_SetDirtyRange_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineObj_SetDirtyRange2_Proxy( + IAMTimelineObj* This, + REFTIME start, + REFTIME stop); +void __RPC_STUB IAMTimelineObj_SetDirtyRange2_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineObj_ClearDirty_Proxy( + IAMTimelineObj* This); +void __RPC_STUB IAMTimelineObj_ClearDirty_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineObj_Remove_Proxy( + IAMTimelineObj* This); +void __RPC_STUB IAMTimelineObj_Remove_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineObj_RemoveAll_Proxy( + IAMTimelineObj* This); +void __RPC_STUB IAMTimelineObj_RemoveAll_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineObj_GetTimelineNoRef_Proxy( + IAMTimelineObj* This, + IAMTimeline **timeline); +void __RPC_STUB IAMTimelineObj_GetTimelineNoRef_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineObj_GetGroupIBelongTo_Proxy( + IAMTimelineObj* This, + IAMTimelineGroup **group); +void __RPC_STUB IAMTimelineObj_GetGroupIBelongTo_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineObj_GetEmbedDepth_Proxy( + IAMTimelineObj* This, + LONG *depth); +void __RPC_STUB IAMTimelineObj_GetEmbedDepth_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IAMTimelineObj_INTERFACE_DEFINED__ */ + +/***************************************************************************** + * IAMTimelineSrc interface + */ +#ifndef __IAMTimelineSrc_INTERFACE_DEFINED__ +#define __IAMTimelineSrc_INTERFACE_DEFINED__ + +DEFINE_GUID(IID_IAMTimelineSrc, 0x78530b79, 0x61f9, 0x11d2, 0x8c,0xad, 0x00,0xa0,0x24,0x58,0x09,0x02); +#if defined(__cplusplus) && !defined(CINTERFACE) +MIDL_INTERFACE("78530b79-61f9-11d2-8cad-00a024580902") +IAMTimelineSrc : public IUnknown +{ + virtual HRESULT STDMETHODCALLTYPE GetMediaTimes( + REFERENCE_TIME *start, + REFERENCE_TIME *stop) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetMediaTimes2( + REFTIME *start, + REFTIME *stop) = 0; + + virtual HRESULT STDMETHODCALLTYPE ModifyStopTime( + REFERENCE_TIME stop) = 0; + + virtual HRESULT STDMETHODCALLTYPE ModifyStopTime2( + REFTIME stop) = 0; + + virtual HRESULT STDMETHODCALLTYPE FixMediaTimes( + REFERENCE_TIME *start, + REFERENCE_TIME *stop) = 0; + + virtual HRESULT STDMETHODCALLTYPE FixMediaTimes2( + REFTIME *start, + REFTIME *stop) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetMediaTimes( + REFERENCE_TIME Start, + REFERENCE_TIME Stop) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetMediaTimes2( + REFTIME Start, + REFTIME Stop) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetMediaLength( + REFERENCE_TIME length) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetMediaLength2( + REFTIME length) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetMediaLength( + REFERENCE_TIME *length) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetMediaLength2( + REFTIME *length) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetMediaName( + BSTR *name) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetMediaName( + BSTR name) = 0; + + virtual HRESULT STDMETHODCALLTYPE SpliceWithNext( + IAMTimelineObj *next) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetStreamNumber( + LONG *num) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetStreamNumber( + LONG num) = 0; + + virtual HRESULT STDMETHODCALLTYPE IsNormalRate( + WINBOOL *normal) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDefaultFPS( + double *fps) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetDefaultFPS( + double fps) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetStretchMode( + int *mode) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetStretchMode( + int mode) = 0; + +}; +#ifdef __CRT_UUID_DECL +__CRT_UUID_DECL(IAMTimelineSrc, 0x78530b79, 0x61f9, 0x11d2, 0x8c,0xad, 0x00,0xa0,0x24,0x58,0x09,0x02) +#endif +#else +typedef struct IAMTimelineSrcVtbl { + BEGIN_INTERFACE + + /*** IUnknown methods ***/ + HRESULT (STDMETHODCALLTYPE *QueryInterface)( + IAMTimelineSrc* This, + REFIID riid, + void **ppvObject); + + ULONG (STDMETHODCALLTYPE *AddRef)( + IAMTimelineSrc* This); + + ULONG (STDMETHODCALLTYPE *Release)( + IAMTimelineSrc* This); + + /*** IAMTimelineSrc methods ***/ + HRESULT (STDMETHODCALLTYPE *GetMediaTimes)( + IAMTimelineSrc* This, + REFERENCE_TIME *start, + REFERENCE_TIME *stop); + + HRESULT (STDMETHODCALLTYPE *GetMediaTimes2)( + IAMTimelineSrc* This, + REFTIME *start, + REFTIME *stop); + + HRESULT (STDMETHODCALLTYPE *ModifyStopTime)( + IAMTimelineSrc* This, + REFERENCE_TIME stop); + + HRESULT (STDMETHODCALLTYPE *ModifyStopTime2)( + IAMTimelineSrc* This, + REFTIME stop); + + HRESULT (STDMETHODCALLTYPE *FixMediaTimes)( + IAMTimelineSrc* This, + REFERENCE_TIME *start, + REFERENCE_TIME *stop); + + HRESULT (STDMETHODCALLTYPE *FixMediaTimes2)( + IAMTimelineSrc* This, + REFTIME *start, + REFTIME *stop); + + HRESULT (STDMETHODCALLTYPE *SetMediaTimes)( + IAMTimelineSrc* This, + REFERENCE_TIME Start, + REFERENCE_TIME Stop); + + HRESULT (STDMETHODCALLTYPE *SetMediaTimes2)( + IAMTimelineSrc* This, + REFTIME Start, + REFTIME Stop); + + HRESULT (STDMETHODCALLTYPE *SetMediaLength)( + IAMTimelineSrc* This, + REFERENCE_TIME length); + + HRESULT (STDMETHODCALLTYPE *SetMediaLength2)( + IAMTimelineSrc* This, + REFTIME length); + + HRESULT (STDMETHODCALLTYPE *GetMediaLength)( + IAMTimelineSrc* This, + REFERENCE_TIME *length); + + HRESULT (STDMETHODCALLTYPE *GetMediaLength2)( + IAMTimelineSrc* This, + REFTIME *length); + + HRESULT (STDMETHODCALLTYPE *GetMediaName)( + IAMTimelineSrc* This, + BSTR *name); + + HRESULT (STDMETHODCALLTYPE *SetMediaName)( + IAMTimelineSrc* This, + BSTR name); + + HRESULT (STDMETHODCALLTYPE *SpliceWithNext)( + IAMTimelineSrc* This, + IAMTimelineObj *next); + + HRESULT (STDMETHODCALLTYPE *GetStreamNumber)( + IAMTimelineSrc* This, + LONG *num); + + HRESULT (STDMETHODCALLTYPE *SetStreamNumber)( + IAMTimelineSrc* This, + LONG num); + + HRESULT (STDMETHODCALLTYPE *IsNormalRate)( + IAMTimelineSrc* This, + WINBOOL *normal); + + HRESULT (STDMETHODCALLTYPE *GetDefaultFPS)( + IAMTimelineSrc* This, + double *fps); + + HRESULT (STDMETHODCALLTYPE *SetDefaultFPS)( + IAMTimelineSrc* This, + double fps); + + HRESULT (STDMETHODCALLTYPE *GetStretchMode)( + IAMTimelineSrc* This, + int *mode); + + HRESULT (STDMETHODCALLTYPE *SetStretchMode)( + IAMTimelineSrc* This, + int mode); + + END_INTERFACE +} IAMTimelineSrcVtbl; +interface IAMTimelineSrc { + CONST_VTBL IAMTimelineSrcVtbl* lpVtbl; +}; + +#ifdef COBJMACROS +#ifndef WIDL_C_INLINE_WRAPPERS +/*** IUnknown methods ***/ +#define IAMTimelineSrc_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject) +#define IAMTimelineSrc_AddRef(This) (This)->lpVtbl->AddRef(This) +#define IAMTimelineSrc_Release(This) (This)->lpVtbl->Release(This) +/*** IAMTimelineSrc methods ***/ +#define IAMTimelineSrc_GetMediaTimes(This,start,stop) (This)->lpVtbl->GetMediaTimes(This,start,stop) +#define IAMTimelineSrc_GetMediaTimes2(This,start,stop) (This)->lpVtbl->GetMediaTimes2(This,start,stop) +#define IAMTimelineSrc_ModifyStopTime(This,stop) (This)->lpVtbl->ModifyStopTime(This,stop) +#define IAMTimelineSrc_ModifyStopTime2(This,stop) (This)->lpVtbl->ModifyStopTime2(This,stop) +#define IAMTimelineSrc_FixMediaTimes(This,start,stop) (This)->lpVtbl->FixMediaTimes(This,start,stop) +#define IAMTimelineSrc_FixMediaTimes2(This,start,stop) (This)->lpVtbl->FixMediaTimes2(This,start,stop) +#define IAMTimelineSrc_SetMediaTimes(This,Start,Stop) (This)->lpVtbl->SetMediaTimes(This,Start,Stop) +#define IAMTimelineSrc_SetMediaTimes2(This,Start,Stop) (This)->lpVtbl->SetMediaTimes2(This,Start,Stop) +#define IAMTimelineSrc_SetMediaLength(This,length) (This)->lpVtbl->SetMediaLength(This,length) +#define IAMTimelineSrc_SetMediaLength2(This,length) (This)->lpVtbl->SetMediaLength2(This,length) +#define IAMTimelineSrc_GetMediaLength(This,length) (This)->lpVtbl->GetMediaLength(This,length) +#define IAMTimelineSrc_GetMediaLength2(This,length) (This)->lpVtbl->GetMediaLength2(This,length) +#define IAMTimelineSrc_GetMediaName(This,name) (This)->lpVtbl->GetMediaName(This,name) +#define IAMTimelineSrc_SetMediaName(This,name) (This)->lpVtbl->SetMediaName(This,name) +#define IAMTimelineSrc_SpliceWithNext(This,next) (This)->lpVtbl->SpliceWithNext(This,next) +#define IAMTimelineSrc_GetStreamNumber(This,num) (This)->lpVtbl->GetStreamNumber(This,num) +#define IAMTimelineSrc_SetStreamNumber(This,num) (This)->lpVtbl->SetStreamNumber(This,num) +#define IAMTimelineSrc_IsNormalRate(This,normal) (This)->lpVtbl->IsNormalRate(This,normal) +#define IAMTimelineSrc_GetDefaultFPS(This,fps) (This)->lpVtbl->GetDefaultFPS(This,fps) +#define IAMTimelineSrc_SetDefaultFPS(This,fps) (This)->lpVtbl->SetDefaultFPS(This,fps) +#define IAMTimelineSrc_GetStretchMode(This,mode) (This)->lpVtbl->GetStretchMode(This,mode) +#define IAMTimelineSrc_SetStretchMode(This,mode) (This)->lpVtbl->SetStretchMode(This,mode) +#else +/*** IUnknown methods ***/ +static FORCEINLINE HRESULT IAMTimelineSrc_QueryInterface(IAMTimelineSrc* This,REFIID riid,void **ppvObject) { + return This->lpVtbl->QueryInterface(This,riid,ppvObject); +} +static FORCEINLINE ULONG IAMTimelineSrc_AddRef(IAMTimelineSrc* This) { + return This->lpVtbl->AddRef(This); +} +static FORCEINLINE ULONG IAMTimelineSrc_Release(IAMTimelineSrc* This) { + return This->lpVtbl->Release(This); +} +/*** IAMTimelineSrc methods ***/ +static FORCEINLINE HRESULT IAMTimelineSrc_GetMediaTimes(IAMTimelineSrc* This,REFERENCE_TIME *start,REFERENCE_TIME *stop) { + return This->lpVtbl->GetMediaTimes(This,start,stop); +} +static FORCEINLINE HRESULT IAMTimelineSrc_GetMediaTimes2(IAMTimelineSrc* This,REFTIME *start,REFTIME *stop) { + return This->lpVtbl->GetMediaTimes2(This,start,stop); +} +static FORCEINLINE HRESULT IAMTimelineSrc_ModifyStopTime(IAMTimelineSrc* This,REFERENCE_TIME stop) { + return This->lpVtbl->ModifyStopTime(This,stop); +} +static FORCEINLINE HRESULT IAMTimelineSrc_ModifyStopTime2(IAMTimelineSrc* This,REFTIME stop) { + return This->lpVtbl->ModifyStopTime2(This,stop); +} +static FORCEINLINE HRESULT IAMTimelineSrc_FixMediaTimes(IAMTimelineSrc* This,REFERENCE_TIME *start,REFERENCE_TIME *stop) { + return This->lpVtbl->FixMediaTimes(This,start,stop); +} +static FORCEINLINE HRESULT IAMTimelineSrc_FixMediaTimes2(IAMTimelineSrc* This,REFTIME *start,REFTIME *stop) { + return This->lpVtbl->FixMediaTimes2(This,start,stop); +} +static FORCEINLINE HRESULT IAMTimelineSrc_SetMediaTimes(IAMTimelineSrc* This,REFERENCE_TIME Start,REFERENCE_TIME Stop) { + return This->lpVtbl->SetMediaTimes(This,Start,Stop); +} +static FORCEINLINE HRESULT IAMTimelineSrc_SetMediaTimes2(IAMTimelineSrc* This,REFTIME Start,REFTIME Stop) { + return This->lpVtbl->SetMediaTimes2(This,Start,Stop); +} +static FORCEINLINE HRESULT IAMTimelineSrc_SetMediaLength(IAMTimelineSrc* This,REFERENCE_TIME length) { + return This->lpVtbl->SetMediaLength(This,length); +} +static FORCEINLINE HRESULT IAMTimelineSrc_SetMediaLength2(IAMTimelineSrc* This,REFTIME length) { + return This->lpVtbl->SetMediaLength2(This,length); +} +static FORCEINLINE HRESULT IAMTimelineSrc_GetMediaLength(IAMTimelineSrc* This,REFERENCE_TIME *length) { + return This->lpVtbl->GetMediaLength(This,length); +} +static FORCEINLINE HRESULT IAMTimelineSrc_GetMediaLength2(IAMTimelineSrc* This,REFTIME *length) { + return This->lpVtbl->GetMediaLength2(This,length); +} +static FORCEINLINE HRESULT IAMTimelineSrc_GetMediaName(IAMTimelineSrc* This,BSTR *name) { + return This->lpVtbl->GetMediaName(This,name); +} +static FORCEINLINE HRESULT IAMTimelineSrc_SetMediaName(IAMTimelineSrc* This,BSTR name) { + return This->lpVtbl->SetMediaName(This,name); +} +static FORCEINLINE HRESULT IAMTimelineSrc_SpliceWithNext(IAMTimelineSrc* This,IAMTimelineObj *next) { + return This->lpVtbl->SpliceWithNext(This,next); +} +static FORCEINLINE HRESULT IAMTimelineSrc_GetStreamNumber(IAMTimelineSrc* This,LONG *num) { + return This->lpVtbl->GetStreamNumber(This,num); +} +static FORCEINLINE HRESULT IAMTimelineSrc_SetStreamNumber(IAMTimelineSrc* This,LONG num) { + return This->lpVtbl->SetStreamNumber(This,num); +} +static FORCEINLINE HRESULT IAMTimelineSrc_IsNormalRate(IAMTimelineSrc* This,WINBOOL *normal) { + return This->lpVtbl->IsNormalRate(This,normal); +} +static FORCEINLINE HRESULT IAMTimelineSrc_GetDefaultFPS(IAMTimelineSrc* This,double *fps) { + return This->lpVtbl->GetDefaultFPS(This,fps); +} +static FORCEINLINE HRESULT IAMTimelineSrc_SetDefaultFPS(IAMTimelineSrc* This,double fps) { + return This->lpVtbl->SetDefaultFPS(This,fps); +} +static FORCEINLINE HRESULT IAMTimelineSrc_GetStretchMode(IAMTimelineSrc* This,int *mode) { + return This->lpVtbl->GetStretchMode(This,mode); +} +static FORCEINLINE HRESULT IAMTimelineSrc_SetStretchMode(IAMTimelineSrc* This,int mode) { + return This->lpVtbl->SetStretchMode(This,mode); +} +#endif +#endif + +#endif + +HRESULT STDMETHODCALLTYPE IAMTimelineSrc_GetMediaTimes_Proxy( + IAMTimelineSrc* This, + REFERENCE_TIME *start, + REFERENCE_TIME *stop); +void __RPC_STUB IAMTimelineSrc_GetMediaTimes_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineSrc_GetMediaTimes2_Proxy( + IAMTimelineSrc* This, + REFTIME *start, + REFTIME *stop); +void __RPC_STUB IAMTimelineSrc_GetMediaTimes2_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineSrc_ModifyStopTime_Proxy( + IAMTimelineSrc* This, + REFERENCE_TIME stop); +void __RPC_STUB IAMTimelineSrc_ModifyStopTime_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineSrc_ModifyStopTime2_Proxy( + IAMTimelineSrc* This, + REFTIME stop); +void __RPC_STUB IAMTimelineSrc_ModifyStopTime2_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineSrc_FixMediaTimes_Proxy( + IAMTimelineSrc* This, + REFERENCE_TIME *start, + REFERENCE_TIME *stop); +void __RPC_STUB IAMTimelineSrc_FixMediaTimes_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineSrc_FixMediaTimes2_Proxy( + IAMTimelineSrc* This, + REFTIME *start, + REFTIME *stop); +void __RPC_STUB IAMTimelineSrc_FixMediaTimes2_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineSrc_SetMediaTimes_Proxy( + IAMTimelineSrc* This, + REFERENCE_TIME Start, + REFERENCE_TIME Stop); +void __RPC_STUB IAMTimelineSrc_SetMediaTimes_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineSrc_SetMediaTimes2_Proxy( + IAMTimelineSrc* This, + REFTIME Start, + REFTIME Stop); +void __RPC_STUB IAMTimelineSrc_SetMediaTimes2_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineSrc_SetMediaLength_Proxy( + IAMTimelineSrc* This, + REFERENCE_TIME length); +void __RPC_STUB IAMTimelineSrc_SetMediaLength_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineSrc_SetMediaLength2_Proxy( + IAMTimelineSrc* This, + REFTIME length); +void __RPC_STUB IAMTimelineSrc_SetMediaLength2_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineSrc_GetMediaLength_Proxy( + IAMTimelineSrc* This, + REFERENCE_TIME *length); +void __RPC_STUB IAMTimelineSrc_GetMediaLength_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineSrc_GetMediaLength2_Proxy( + IAMTimelineSrc* This, + REFTIME *length); +void __RPC_STUB IAMTimelineSrc_GetMediaLength2_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineSrc_GetMediaName_Proxy( + IAMTimelineSrc* This, + BSTR *name); +void __RPC_STUB IAMTimelineSrc_GetMediaName_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineSrc_SetMediaName_Proxy( + IAMTimelineSrc* This, + BSTR name); +void __RPC_STUB IAMTimelineSrc_SetMediaName_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineSrc_SpliceWithNext_Proxy( + IAMTimelineSrc* This, + IAMTimelineObj *next); +void __RPC_STUB IAMTimelineSrc_SpliceWithNext_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineSrc_GetStreamNumber_Proxy( + IAMTimelineSrc* This, + LONG *num); +void __RPC_STUB IAMTimelineSrc_GetStreamNumber_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineSrc_SetStreamNumber_Proxy( + IAMTimelineSrc* This, + LONG num); +void __RPC_STUB IAMTimelineSrc_SetStreamNumber_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineSrc_IsNormalRate_Proxy( + IAMTimelineSrc* This, + WINBOOL *normal); +void __RPC_STUB IAMTimelineSrc_IsNormalRate_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineSrc_GetDefaultFPS_Proxy( + IAMTimelineSrc* This, + double *fps); +void __RPC_STUB IAMTimelineSrc_GetDefaultFPS_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineSrc_SetDefaultFPS_Proxy( + IAMTimelineSrc* This, + double fps); +void __RPC_STUB IAMTimelineSrc_SetDefaultFPS_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineSrc_GetStretchMode_Proxy( + IAMTimelineSrc* This, + int *mode); +void __RPC_STUB IAMTimelineSrc_GetStretchMode_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); +HRESULT STDMETHODCALLTYPE IAMTimelineSrc_SetStretchMode_Proxy( + IAMTimelineSrc* This, + int mode); +void __RPC_STUB IAMTimelineSrc_SetStretchMode_Stub( + IRpcStubBuffer* This, + IRpcChannelBuffer* pRpcChannelBuffer, + PRPC_MESSAGE pRpcMessage, + DWORD* pdwStubPhase); + +#endif /* __IAMTimelineSrc_INTERFACE_DEFINED__ */ + enum { E_NOTINTREE = 0x80040400, E_RENDER_ENGINE_IS_BROKEN = 0x80040401, @@ -786,6 +3891,10 @@ 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 VARIANT_UserSize (ULONG *, ULONG, VARIANT *); +unsigned char * __RPC_USER VARIANT_UserMarshal (ULONG *, unsigned char *, VARIANT *); +unsigned char * __RPC_USER VARIANT_UserUnmarshal(ULONG *, unsigned char *, VARIANT *); +void __RPC_USER VARIANT_UserFree (ULONG *, VARIANT *); /* End additional prototypes */ diff --git a/mingw-w64-headers/direct-x/include/qedit.idl b/mingw-w64-headers/direct-x/include/qedit.idl index 1cf0996..d42e691 100644 --- a/mingw-w64-headers/direct-x/include/qedit.idl +++ b/mingw-w64-headers/direct-x/include/qedit.idl @@ -167,6 +167,645 @@ coclass MediaDet [default] interface IMediaDet; }; +[ + object, + uuid(288581E0-66CE-11d2-918F-00C0DF10D434), + odl, + pointer_default(unique) +] +interface IMediaLocator : IUnknown +{ + HRESULT FindMediaFile( + BSTR input, + BSTR filter, + BSTR * output, + long flags + ); + + HRESULT AddFoundLocation( + BSTR dir + ); +}; + +typedef struct +{ + BSTR name; + DISPID dispID; + LONG nValues; +} DEXTER_PARAM; + +typedef struct +{ + VARIANT v; + REFERENCE_TIME rt; + DWORD dwInterp; +} DEXTER_VALUE; + +[ + object, + uuid(AE9472BD-B0C3-11D2-8D24-00A0C9441E20), + pointer_default(unique) +] +interface IPropertySetter : IUnknown +{ + HRESULT LoadXML( + [in] IUnknown * pxml + ); + + HRESULT PrintXML( + [out] char * xml, + [in] int size, + [out] int * printed, + [in] int indent + ); + + HRESULT CloneProps( + [out] IPropertySetter ** setter, + [in] REFERENCE_TIME start, + [in] REFERENCE_TIME stop + ); + + HRESULT AddProp( + [in] DEXTER_PARAM param, + [in] DEXTER_VALUE * value + ); + + HRESULT GetProps( + [out] LONG * params, + [out] DEXTER_PARAM ** param, + [out] DEXTER_VALUE ** value + ); + + HRESULT FreeProps( + [in] LONG params, + [in] DEXTER_PARAM * param, + [in] DEXTER_VALUE * value + ); + + HRESULT ClearProps(); + + HRESULT SaveToBlob( + [out] LONG * size, + [out] BYTE ** blob + ); + + HRESULT LoadFromBlob( + [in] LONG size, + [in] BYTE * blob + ); + + HRESULT SetProps( + [in] IUnknown * target, + [in] REFERENCE_TIME now + ); +}; + +[ + object, + uuid(E43E73A2-0EFA-11d3-9601-00A0C9441E20), + odl, + pointer_default(unique) +] +interface IAMErrorLog : IUnknown +{ + HRESULT LogError( + long severity, + BSTR error_str, + long error_code, + long hresult, + [in] VARIANT * extra + ); +}; + +[ + object, + uuid(963566DA-BE21-4eaf-88E9-35704F8F52A1), + odl, + pointer_default(unique) +] +interface IAMSetErrorLog : IUnknown +{ + [propget] HRESULT ErrorLog( + [out, retval] IAMErrorLog ** log + ); + + [propput] HRESULT ErrorLog( + [in] IAMErrorLog * log + ); +}; + +interface IAMTimeline; +interface IAMTimelineGroup; +interface IAMTimelineObj; +interface IAMTimelineSrc; + +typedef enum +{ + TIMELINE_MAJOR_TYPE_COMPOSITE = 1, + TIMELINE_MAJOR_TYPE_TRACK = 2, + TIMELINE_MAJOR_TYPE_SOURCE = 4, + TIMELINE_MAJOR_TYPE_TRANSITION = 8, + TIMELINE_MAJOR_TYPE_EFFECT = 16, + TIMELINE_MAJOR_TYPE_GROUP = 128 +} TIMELINE_MAJOR_TYPE; + +[ + object, + uuid(78530B74-61F9-11D2-8CAD-00A024580902), + odl, + pointer_default(unique) +] +interface IAMTimeline : IUnknown +{ + HRESULT CreateEmptyNode( + [out] IAMTimelineObj ** obj, + TIMELINE_MAJOR_TYPE type + ); + + HRESULT AddGroup( + IAMTimelineObj * group + ); + + HRESULT RemGroupFromList( + IAMTimelineObj * group + ); + + HRESULT GetGroup( + [out] IAMTimelineObj ** group, + long index + ); + + HRESULT GetGroupCount( + long * count + ); + + HRESULT ClearAllGroups(); + + HRESULT GetInsertMode( + long * mode + ); + + HRESULT SetInsertMode( + long mode + ); + + HRESULT EnableTransitions( + BOOL enabled + ); + + HRESULT TransitionsEnabled( + BOOL * enabled + ); + + HRESULT EnableEffects( + BOOL enabled + ); + + HRESULT EffectsEnabled( + BOOL * enabled + ); + + HRESULT SetInterestRange( + REFERENCE_TIME start, + REFERENCE_TIME stop + ); + + HRESULT GetDuration( + REFERENCE_TIME * duration + ); + + HRESULT GetDuration2( + double * duration + ); + + HRESULT SetDefaultFPS( + double fps + ); + + HRESULT GetDefaultFPS( + double * fps + ); + + HRESULT IsDirty( + BOOL * dirty + ); + + HRESULT GetDirtyRange( + REFERENCE_TIME * start, + REFERENCE_TIME * stop + ); + + HRESULT GetCountOfType( + long group, + long * value, + long * value_with_comps, + TIMELINE_MAJOR_TYPE type + ); + + HRESULT ValidateSourceNames( + long flags, + IMediaLocator * override, + LONG_PTR notify_event + ); + + HRESULT SetDefaultTransition( + GUID * guid + ); + + HRESULT GetDefaultTransition( + GUID * guid + ); + + HRESULT SetDefaultEffect( + GUID * guid + ); + + HRESULT GetDefaultEffect( + GUID * guid + ); + + HRESULT SetDefaultTransitionB( + BSTR guidb + ); + + HRESULT GetDefaultTransitionB( + [out,retval] BSTR * guidb + ); + + HRESULT SetDefaultEffectB( + BSTR guidb + ); + + HRESULT GetDefaultEffectB( + [out,retval] BSTR * guidb + ); +}; + +[ + uuid(78530B75-61F9-11D2-8CAD-00A024580902) +] +coclass AMTimeline +{ + [default] interface IAMTimeline; + interface IPersistStream; + interface IAMSetErrorLog; +}; + +[ + object, + uuid(9EED4F00-B8A6-11d2-8023-00C0DF10D434), + odl, + pointer_default(unique) +] +interface IAMTimelineGroup : IUnknown +{ + HRESULT SetTimeline( + IAMTimeline * timeline + ); + + HRESULT GetTimeline( + [out] IAMTimeline ** timeline + ); + + HRESULT GetPriority( + long * priority + ); + + HRESULT GetMediaType( + [out] AM_MEDIA_TYPE * + ); + + HRESULT SetMediaType( + [in] AM_MEDIA_TYPE * + ); + + HRESULT SetOutputFPS( + double fps + ); + + HRESULT GetOutputFPS( + double * fps + ); + + HRESULT SetGroupName( + BSTR name + ); + + HRESULT GetGroupName( + [out,retval] BSTR * name + ); + + HRESULT SetPreviewMode( + BOOL preview + ); + + HRESULT GetPreviewMode( + BOOL * preview + ); + + HRESULT SetMediaTypeForVB( + [in] long type + ); + + HRESULT GetOutputBuffering( + [out] int * buffer + ); + + HRESULT SetOutputBuffering( + [in] int buffer + ); + + HRESULT SetSmartRecompressFormat( + long * format + ); + + HRESULT GetSmartRecompressFormat( + long ** format + ); + + HRESULT IsSmartRecompressFormatSet( + BOOL * set + ); + + HRESULT IsRecompressFormatDirty( + BOOL * dirty + ); + + HRESULT ClearRecompressFormatDirty(); + + HRESULT SetRecompFormatFromSource( + IAMTimelineSrc * source + ); +}; + +[ + object, + local, + uuid(78530B77-61F9-11D2-8CAD-00A024580902), + odl, + pointer_default(unique) +] +interface IAMTimelineObj : IUnknown +{ + HRESULT GetStartStop( + REFERENCE_TIME * start, + REFERENCE_TIME * stop + ); + + HRESULT GetStartStop2( + REFTIME * start, REFTIME * stop + ); + + HRESULT FixTimes( + REFERENCE_TIME * start, REFERENCE_TIME * stop + ); + + HRESULT FixTimes2( + REFTIME * start, REFTIME * stop + ); + + HRESULT SetStartStop( + REFERENCE_TIME start, + REFERENCE_TIME stop + ); + + HRESULT SetStartStop2( + REFTIME start, + REFTIME stop + ); + + HRESULT GetPropertySetter( + [out,retval] IPropertySetter ** setter + ); + + HRESULT SetPropertySetter( + IPropertySetter * setter + ); + + HRESULT GetSubObject( + [out,retval] IUnknown ** obj + ); + + HRESULT SetSubObject( + IUnknown * obj + ); + + HRESULT SetSubObjectGUID( + GUID guid + ); + + HRESULT SetSubObjectGUIDB( + BSTR guidb + ); + + HRESULT GetSubObjectGUID( + GUID * guid + ); + + HRESULT GetSubObjectGUIDB( + [out,retval] BSTR * guidb + ); + + HRESULT GetSubObjectLoaded( + BOOL * loaded + ); + + HRESULT GetTimelineType( + TIMELINE_MAJOR_TYPE * type + ); + + HRESULT SetTimelineType( + TIMELINE_MAJOR_TYPE type + ); + + HRESULT GetUserID( + long * id + ); + + HRESULT SetUserID( + long id + ); + + HRESULT GetGenID( + long * id + ); + + HRESULT GetUserName( + [out,retval] BSTR * name + ); + + HRESULT SetUserName( + BSTR name + ); + + HRESULT GetUserData( + BYTE * data, + long * size + ); + + HRESULT SetUserData( + BYTE * data, + long size + ); + + HRESULT GetMuted( + BOOL * muted + ); + + HRESULT SetMuted( + BOOL muted + ); + + HRESULT GetLocked( + BOOL * locked + ); + + HRESULT SetLocked( + BOOL locked + ); + + HRESULT GetDirtyRange( + REFERENCE_TIME * start, + REFERENCE_TIME * stop + ); + + HRESULT GetDirtyRange2( + REFTIME * start, + REFTIME * stop + ); + + HRESULT SetDirtyRange( + REFERENCE_TIME start, + REFERENCE_TIME stop + ); + + HRESULT SetDirtyRange2( + REFTIME start, + REFTIME stop + ); + + HRESULT ClearDirty(); + + HRESULT Remove(); + + HRESULT RemoveAll(); + + HRESULT GetTimelineNoRef( + IAMTimeline ** timeline + ); + + HRESULT GetGroupIBelongTo( + [out] IAMTimelineGroup ** group + ); + + HRESULT GetEmbedDepth( + long * depth + ); +}; + +[ + object, + uuid(78530B79-61F9-11D2-8CAD-00A024580902), + odl, + pointer_default(unique) +] +interface IAMTimelineSrc : IUnknown +{ + HRESULT GetMediaTimes( + REFERENCE_TIME * start, + REFERENCE_TIME * stop + ); + + HRESULT GetMediaTimes2( + REFTIME * start, + REFTIME * stop + ); + + HRESULT ModifyStopTime( + REFERENCE_TIME stop + ); + + HRESULT ModifyStopTime2( + REFTIME stop + ); + + HRESULT FixMediaTimes( + REFERENCE_TIME * start, + REFERENCE_TIME * stop + ); + + HRESULT FixMediaTimes2( + REFTIME * start, + REFTIME * stop + ); + + HRESULT SetMediaTimes( + REFERENCE_TIME Start, + REFERENCE_TIME Stop + ); + + HRESULT SetMediaTimes2( + REFTIME Start, + REFTIME Stop + ); + + HRESULT SetMediaLength( + REFERENCE_TIME length + ); + + HRESULT SetMediaLength2( + REFTIME length + ); + + HRESULT GetMediaLength( + REFERENCE_TIME * length + ); + + HRESULT GetMediaLength2( + REFTIME * length + ); + + HRESULT GetMediaName( + [out,retval] BSTR * name + ); + + HRESULT SetMediaName( + BSTR name + ); + + HRESULT SpliceWithNext( + IAMTimelineObj * next + ); + + HRESULT GetStreamNumber( + long * num + ); + + HRESULT SetStreamNumber( + long num + ); + + HRESULT IsNormalRate( + BOOL * normal + ); + + HRESULT GetDefaultFPS( + double * fps + ); + + HRESULT SetDefaultFPS( + double fps + ); + + HRESULT GetStretchMode( + int * mode + ); + + HRESULT SetStretchMode( + int mode + ); +}; + enum { E_NOTINTREE = 0x80040400,