Sweden-Number/include/axcore.idl

697 lines
15 KiB
Plaintext
Raw Normal View History

/*
* Copyright (C) 2002 Robert Shearman
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#define CHARS_IN_GUID 39
cpp_quote("#define CHARS_IN_GUID 39")
/* GetTimeFormat is defined in winnls.h as
* either the W or A suffixed version */
cpp_quote("#ifdef WINE_NO_UNICODE_MACROS")
cpp_quote("#undef GetTimeFormat")
cpp_quote("#endif")
typedef struct _AMMediaType
{
GUID majortype;
GUID subtype;
BOOL bFixedSizeSamples;
BOOL bTemporalCompression;
ULONG lSampleSize;
GUID formattype;
IUnknown * pUnk;
ULONG cbFormat;
[size_is(cbFormat)] BYTE * pbFormat;
} AM_MEDIA_TYPE;
typedef enum _PinDirection
{
PINDIR_INPUT,
PINDIR_OUTPUT
} PIN_DIRECTION;
#define MAX_PIN_NAME 128
#define MAX_FILTER_NAME 128
cpp_quote("#define MAX_PIN_NAME 128")
cpp_quote("#define MAX_FILTER_NAME 128")
cpp_quote("#ifndef REFERENCE_TIME_DEFINED")
cpp_quote("#define REFERENCE_TIME_DEFINED")
typedef LONGLONG REFERENCE_TIME;
cpp_quote("#endif")
cpp_quote("#ifndef REFTIME_DEFINED")
cpp_quote("#define REFTIME_DEFINED")
typedef DOUBLE REFTIME;
cpp_quote("#endif")
typedef DWORD_PTR HSEMAPHORE;
typedef DWORD_PTR HEVENT;
typedef struct _AllocatorProperties
{
long cBuffers;
long cbBuffer;
long cbAlign;
long cbPrefix;
} ALLOCATOR_PROPERTIES;
interface IAMovieSetup;
interface IEnumFilters;
interface IEnumMediaTypes;
interface IEnumPins;
interface IBaseFilter;
interface IFilterGraph;
interface IMediaFilter;
interface IMediaSample;
interface IMemAllocator;
interface IMemAllocatorCallbackTemp;
interface IMemAllocatorNotifyCallbackTemp;
interface IMemInputPin;
interface IPin;
interface IReferenceClock;
[
object,
uuid(56a86891-0ad4-11ce-b03a-0020af0ba770),
pointer_default(unique)
]
interface IPin : IUnknown
{
typedef struct _PinInfo
{
IBaseFilter *pFilter;
PIN_DIRECTION dir;
WCHAR achName[MAX_PIN_NAME];
} PIN_INFO;
HRESULT Connect(
[in] IPin * pReceivePin,
[in] const AM_MEDIA_TYPE * pmt);
HRESULT ReceiveConnection(
[in] IPin * pConnector,
[in] const AM_MEDIA_TYPE *pmt);
HRESULT Disconnect(void);
HRESULT ConnectedTo(
[out] IPin **pPin);
HRESULT ConnectionMediaType(
[out] AM_MEDIA_TYPE *pmt);
HRESULT QueryPinInfo(
[out] PIN_INFO * pInfo);
HRESULT QueryDirection(
[out] PIN_DIRECTION *pPinDir);
HRESULT QueryId(
[out] LPWSTR * Id);
HRESULT QueryAccept(
[in] const AM_MEDIA_TYPE *pmt);
HRESULT EnumMediaTypes(
[out] IEnumMediaTypes **ppEnum);
HRESULT QueryInternalConnections(
[out] IPin* *apPin,
[in, out] ULONG *nPin);
HRESULT EndOfStream(void);
HRESULT BeginFlush(void);
HRESULT EndFlush(void);
HRESULT NewSegment(
[in] REFERENCE_TIME tStart,
[in] REFERENCE_TIME tStop,
[in] double dRate);
}
typedef IPin *PPIN;
[
object,
uuid(56a86892-0ad4-11ce-b03a-0020af0ba770),
pointer_default(unique)
]
interface IEnumPins : IUnknown
{
HRESULT Next(
[in] ULONG cPins,
[out, size_is(cPins)] IPin ** ppPins,
[out] ULONG * pcFetched);
HRESULT Skip(
[in] ULONG cPins);
HRESULT Reset(void);
HRESULT Clone(
[out] IEnumPins **ppEnum);
}
typedef IEnumPins *PENUMPINS;
[
object,
uuid(89c31040-846b-11ce-97d3-00aa0055595a),
pointer_default(unique)
]
interface IEnumMediaTypes : IUnknown
{
HRESULT Next(
[in] ULONG cMediaTypes,
[out, size_is(cMediaTypes)]
AM_MEDIA_TYPE ** ppMediaTypes,
[out] ULONG * pcFetched
);
HRESULT Skip(
[in] ULONG cMediaTypes);
HRESULT Reset(void);
HRESULT Clone(
[out] IEnumMediaTypes **ppEnum
);
}
typedef IEnumMediaTypes *PENUMMEDIATYPES;
[
object,
uuid(56a8689f-0ad4-11ce-b03a-0020af0ba770),
pointer_default(unique)
]
interface IFilterGraph : IUnknown
{
HRESULT AddFilter(
[in] IBaseFilter * pFilter,
[in, string] LPCWSTR pName);
HRESULT RemoveFilter(
[in] IBaseFilter * pFilter);
HRESULT EnumFilters(
[out] IEnumFilters **ppEnum);
HRESULT FindFilterByName(
[in, string] LPCWSTR pName,
[out] IBaseFilter ** ppFilter);
HRESULT ConnectDirect(
[in] IPin * ppinOut,
[in] IPin * ppinIn,
[in, unique] const AM_MEDIA_TYPE* pmt);
HRESULT Reconnect(
[in] IPin * ppin);
HRESULT Disconnect(
[in] IPin * ppin);
HRESULT SetDefaultSyncSource(void);
}
typedef IFilterGraph *PFILTERGRAPH;
[
object,
uuid(56a86893-0ad4-11ce-b03a-0020af0ba770),
pointer_default(unique)
]
interface IEnumFilters : IUnknown
{
HRESULT Next(
[in] ULONG cFilters,
[out] IBaseFilter ** ppFilter,
[out] ULONG * pcFetched);
HRESULT Skip(
[in] ULONG cFilters);
HRESULT Reset(void);
HRESULT Clone(
[out] IEnumFilters **ppEnum);
}
typedef IEnumFilters *PENUMFILTERS;
[
object,
uuid(56a86899-0ad4-11ce-b03a-0020af0ba770),
pointer_default(unique)
]
interface IMediaFilter : IPersist
{
typedef enum _FilterState
{
State_Stopped,
State_Paused,
State_Running
} FILTER_STATE;
HRESULT Stop(void);
HRESULT Pause(void);
HRESULT Run(REFERENCE_TIME tStart);
HRESULT GetState(
[in] DWORD dwMilliSecsTimeout,
[out] FILTER_STATE *State);
HRESULT SetSyncSource(
[in] IReferenceClock * pClock);
HRESULT GetSyncSource(
[out] IReferenceClock ** pClock);
}
typedef IMediaFilter *PMEDIAFILTER;
[
object,
uuid(56a86895-0ad4-11ce-b03a-0020af0ba770),
pointer_default(unique)
]
interface IBaseFilter : IMediaFilter
{
typedef struct _FilterInfo
{
WCHAR achName[MAX_FILTER_NAME];
IFilterGraph * pGraph;
} FILTER_INFO;
HRESULT EnumPins(
[out] IEnumPins ** ppEnum);
HRESULT FindPin(
[in, string] LPCWSTR Id,
[out] IPin ** ppPin);
HRESULT QueryFilterInfo(
[out] FILTER_INFO * pInfo);
HRESULT JoinFilterGraph(
[in] IFilterGraph * pGraph,
[in, string] LPCWSTR pName);
HRESULT QueryVendorInfo(
[out, string] LPWSTR* pVendorInfo);
}
typedef IBaseFilter *PFILTER;
[
object,
uuid(56a86897-0ad4-11ce-b03a-0020af0ba770),
pointer_default(unique)
]
interface IReferenceClock : IUnknown
{
HRESULT GetTime(
[out] REFERENCE_TIME *pTime);
HRESULT AdviseTime(
[in] REFERENCE_TIME baseTime,
[in] REFERENCE_TIME streamTime,
[in] HEVENT hEvent,
[out] DWORD_PTR * pdwAdviseCookie);
HRESULT AdvisePeriodic(
[in] REFERENCE_TIME startTime,
[in] REFERENCE_TIME periodTime,
[in] HSEMAPHORE hSemaphore,
[out] DWORD_PTR * pdwAdviseCookie);
HRESULT Unadvise(
[in] DWORD_PTR dwAdviseCookie);
}
typedef IReferenceClock *PREFERENCECLOCK;
/*
[
object,
uuid(36b73885-c2c8-11cf-8b46-00805f6cef60),
pointer_default(unique)
]
interface IReferenceClock2 : IReferenceClock
{
}
typedef IReferenceClock2 *PREFERENCECLOCK2;
*/
[
local,
object,
uuid(56a8689a-0ad4-11ce-b03a-0020af0ba770),
pointer_default(unique)
]
interface IMediaSample : IUnknown
{
HRESULT GetPointer([out] BYTE ** ppBuffer);
long GetSize(void);
HRESULT GetTime(
[out] REFERENCE_TIME * pTimeStart,
[out] REFERENCE_TIME * pTimeEnd);
HRESULT SetTime(
[in] REFERENCE_TIME * pTimeStart,
[in] REFERENCE_TIME * pTimeEnd);
HRESULT IsSyncPoint(void);
HRESULT SetSyncPoint(BOOL bIsSyncPoint);
HRESULT IsPreroll(void);
HRESULT SetPreroll(BOOL bIsPreroll);
2004-10-19 00:39:21 +02:00
LONG GetActualDataLength(void);
2004-10-19 00:39:21 +02:00
HRESULT SetActualDataLength(LONG length);
HRESULT GetMediaType(AM_MEDIA_TYPE **ppMediaType);
HRESULT SetMediaType(AM_MEDIA_TYPE *pMediaType);
HRESULT IsDiscontinuity(void);
HRESULT SetDiscontinuity(BOOL bDiscontinuity);
HRESULT GetMediaTime(
[out] LONGLONG * pTimeStart,
[out] LONGLONG * pTimeEnd);
HRESULT SetMediaTime(
[in] LONGLONG * pTimeStart,
[in] LONGLONG * pTimeEnd);
}
typedef IMediaSample *PMEDIASAMPLE;
enum tagAM_SAMPLE_PROPERTY_FLAGS
{
AM_SAMPLE_SPLICEPOINT = 0x01,
AM_SAMPLE_PREROLL = 0x02,
AM_SAMPLE_DATADISCONTINUITY = 0x04,
AM_SAMPLE_TYPECHANGED = 0x08,
AM_SAMPLE_TIMEVALID = 0x10,
AM_SAMPLE_TIMEDISCONTINUITY = 0x40,
AM_SAMPLE_FLUSH_ON_PAUSE = 0x80,
AM_SAMPLE_STOPVALID = 0x100,
AM_SAMPLE_ENDOFSTREAM = 0x200,
AM_STREAM_MEDIA = 0,
AM_STREAM_CONTROL = 1
};
typedef struct tagAM_SAMPLE2_PROPERTIES
{
DWORD cbData;
DWORD dwTypeSpecificFlags;
DWORD dwSampleFlags;
LONG lActual;
REFERENCE_TIME tStart;
REFERENCE_TIME tStop;
DWORD dwStreamId;
AM_MEDIA_TYPE *pMediaType;
BYTE *pbBuffer;
LONG cbBuffer;
} AM_SAMPLE2_PROPERTIES;
[
local,
object,
uuid(36b73884-c2c8-11cf-8b46-00805f6cef60),
pointer_default(unique)
]
interface IMediaSample2 : IMediaSample
{
HRESULT GetProperties(
[in] DWORD cbProperties,
[out, size_is(cbProperties)] BYTE * pbProperties
);
HRESULT SetProperties(
[in] DWORD cbProperties,
[in, size_is(cbProperties)] const BYTE * pbProperties
);
}
typedef IMediaSample2 *PMEDIASAMPLE2;
#define AM_GBF_PREVFRAMESKIPPED 1
#define AM_GBF_NOTASYNCPOINT 2
cpp_quote("#define AM_GBF_PREVFRAMESKIPPED 1")
cpp_quote("#define AM_GBF_NOTASYNCPOINT 2")
cpp_quote("#define AM_GBF_NOWAIT 4")
cpp_quote("#define AM_GBF_NODDSURFACELOCK 8")
[
object,
uuid(56a8689c-0ad4-11ce-b03a-0020af0ba770),
pointer_default(unique)
]
interface IMemAllocator : IUnknown
{
HRESULT SetProperties(
[in] ALLOCATOR_PROPERTIES* pRequest,
[out] ALLOCATOR_PROPERTIES* pActual);
HRESULT GetProperties(
[out] ALLOCATOR_PROPERTIES* pProps);
HRESULT Commit(void);
HRESULT Decommit(void);
HRESULT GetBuffer(
[out] IMediaSample **ppBuffer,
[in] REFERENCE_TIME * pStartTime,
[in] REFERENCE_TIME * pEndTime,
[in] DWORD dwFlags);
HRESULT ReleaseBuffer(
[in] IMediaSample *pBuffer);
}
typedef IMemAllocator *PMEMALLOCATOR;
[
object,
uuid(379a0cf0-c1de-11d2-abf5-00a0c905f375),
pointer_default(unique)
]
interface IMemAllocatorCallbackTemp : IMemAllocator
{
HRESULT SetNotify(
[in] IMemAllocatorNotifyCallbackTemp *pNotify);
HRESULT GetFreeCount(
[out] LONG *plBuffersFree);
}
[
object,
uuid(92980b30-c1de-11d2-abf5-00a0c905f375),
pointer_default(unique)
]
interface IMemAllocatorNotifyCallbackTemp : IUnknown
{
HRESULT NotifyRelease();
}
[
object,
uuid(56a8689d-0ad4-11ce-b03a-0020af0ba770),
pointer_default(unique)
]
interface IMemInputPin : IUnknown
{
HRESULT GetAllocator(
[out] IMemAllocator ** ppAllocator);
HRESULT NotifyAllocator(
[in] IMemAllocator * pAllocator,
[in] BOOL bReadOnly);
HRESULT GetAllocatorRequirements( [out] ALLOCATOR_PROPERTIES*pProps );
HRESULT Receive(
[in] IMediaSample * pSample);
HRESULT ReceiveMultiple(
[in, size_is(nSamples)] IMediaSample **pSamples,
[in] long nSamples,
[out] long *nSamplesProcessed);
HRESULT ReceiveCanBlock();
}
typedef IMemInputPin *PMEMINPUTPIN;
[
object,
uuid(a3d8cec0-7e5a-11cf-bbc5-00805f6cef20),
pointer_default(unique)
]
interface IAMovieSetup : IUnknown
{
HRESULT Register( );
HRESULT Unregister( );
}
typedef IAMovieSetup *PAMOVIESETUP;
typedef enum AM_SEEKING_SeekingFlags
{
AM_SEEKING_NoPositioning = 0x00,
AM_SEEKING_AbsolutePositioning = 0x01,
AM_SEEKING_RelativePositioning = 0x02,
AM_SEEKING_IncrementalPositioning = 0x03,
AM_SEEKING_PositioningBitsMask = 0x03,
AM_SEEKING_SeekToKeyFrame = 0x04,
AM_SEEKING_ReturnTime = 0x08,
AM_SEEKING_Segment = 0x10,
AM_SEEKING_NoFlush = 0x20
} AM_SEEKING_SEEKING_FLAGS;
typedef enum AM_SEEKING_SeekingCapabilities
{
AM_SEEKING_CanSeekAbsolute = 0x001,
AM_SEEKING_CanSeekForwards = 0x002,
AM_SEEKING_CanSeekBackwards = 0x004,
AM_SEEKING_CanGetCurrentPos = 0x008,
AM_SEEKING_CanGetStopPos = 0x010,
AM_SEEKING_CanGetDuration = 0x020,
AM_SEEKING_CanPlayBackwards = 0x040,
AM_SEEKING_CanDoSegments = 0x080,
AM_SEEKING_Source = 0x100
} AM_SEEKING_SEEKING_CAPABILITIES;
[
object,
uuid(36b73880-c2c8-11cf-8b46-00805f6cef60),
pointer_default(unique)
]
interface IMediaSeeking : IUnknown
{
HRESULT GetCapabilities( [out] DWORD * pCapabilities );
HRESULT CheckCapabilities( [in,out] DWORD * pCapabilities );
HRESULT IsFormatSupported([in] const GUID * pFormat);
HRESULT QueryPreferredFormat([out] GUID * pFormat);
HRESULT GetTimeFormat([out] GUID *pFormat);
HRESULT IsUsingTimeFormat([in] const GUID * pFormat);
HRESULT SetTimeFormat([in] const GUID * pFormat);
HRESULT GetDuration([out] LONGLONG *pDuration);
HRESULT GetStopPosition([out] LONGLONG *pStop);
HRESULT GetCurrentPosition([out] LONGLONG *pCurrent);
HRESULT ConvertTimeFormat([out] LONGLONG * pTarget, [in] const GUID * pTargetFormat,
[in] LONGLONG Source, [in] const GUID * pSourceFormat );
HRESULT SetPositions(
[in,out] LONGLONG * pCurrent,
[in] DWORD dwCurrentFlags,
[in,out] LONGLONG * pStop,
[in] DWORD dwStopFlags);
HRESULT GetPositions(
[out] LONGLONG * pCurrent,
[out] LONGLONG * pStop);
HRESULT GetAvailable(
[out] LONGLONG * pEarliest,
[out] LONGLONG * pLatest);
HRESULT SetRate([in] double dRate);
HRESULT GetRate([out] double * pdRate);
HRESULT GetPreroll([out] LONGLONG * pllPreroll);
}
typedef IMediaSeeking *PMEDIASEEKING;
enum tagAM_MEDIAEVENT_FLAGS
{
AM_MEDIAEVENT_NONOTIFY = 0x01
};
enum _AMSTREAMSELECTINFOFLAGS
{
AMSTREAMSELECTINFO_ENABLED = 0x1,
AMSTREAMSELECTINFO_EXCLUSIVE = 0x2
};
enum _AMSTREAMSELECTENABLEFLAGS
{
AMSTREAMSELECTENABLE_ENABLE = 0x1,
AMSTREAMSELECTENABLE_ENABLEALL = 0x2
};
[
object,
uuid(c1960960-17f5-11d1-abe1-00a0c905f375),
pointer_default(unique)
]
interface IAMStreamSelect : IUnknown
{
HRESULT Count(
[out] DWORD *streams);
HRESULT Info(
[in] long index,
[out] AM_MEDIA_TYPE **media_type,
[out] DWORD *flags,
[out] LCID *lcid,
[out] DWORD *group,
[out] WCHAR **name,
[out] IUnknown **object,
[out] IUnknown **unknown);
HRESULT Enable(
[in] long index,
[in] DWORD flags);
}
typedef IAMStreamSelect *PAMSTREAMSELECT;