Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-08-03 21:05:43 +00:00
Code Issues Projects Releases Packages Wiki Activity

sync dxsdk idl files with wine

Browse source 
svn path=/trunk/; revision=36106
This commit is contained in:
Christoph von Wittich 2008-09-10 07:41:27 +00:00
parent a7467a03c8
commit 929b9dfa89
12 changed files with 692 additions and 501 deletions
Download patch file Download diff file Expand all files Collapse all files

2
reactos/include/dxsdk/Videoacc.idl
View file

@ -2,8 +2,6 @@ import "unknwn.idl";
cpp_quote("#if 0") cpp_quote("#if 0")
typedef void* LPVOID;
typedef void* LPGUID;
typedef void* LPDIRECTDRAWSURFACE; typedef void* LPDIRECTDRAWSURFACE;
typedef void* LPDDPIXELFORMAT; typedef void* LPDDPIXELFORMAT;
typedef void* LPAMVAInternalMemInfo; typedef void* LPAMVAInternalMemInfo;

327
reactos/include/dxsdk/amstream.idl
View file

@ -1,3 +1,20 @@
/*
* Copyright 2004 Christian Costa
*
* 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
*/
import "unknwn.idl"; import "unknwn.idl";
import "mmstream.idl"; import "mmstream.idl";
@ -9,61 +26,62 @@ cpp_quote("#include <mmstream.h>")
cpp_quote("#include <ddstream.h>") cpp_quote("#include <ddstream.h>")
cpp_quote("#include <austream.h>") cpp_quote("#include <austream.h>")
cpp_quote("#if 0")
interface IDirectDraw;
interface IDirectDrawSurface;
cpp_quote("#endif")
interface IAMMultiMediaStream; interface IAMMultiMediaStream;
interface IAMMediaStream; interface IAMMediaStream;
interface IMediaStreamFilter; interface IMediaStreamFilter;
interface IDirectDraw;
interface IDirectDrawSurface;
interface IAMMediaTypeStream; interface IAMMediaTypeStream;
interface IAMMediaTypeSample; interface IAMMediaTypeSample;
enum enum {
{ AMMSF_NOGRAPHTHREAD = 0x00000001
AMMSF_NOGRAPHTHREAD = 0x00000001
}; };
enum enum {
{ AMMSF_ADDDEFAULTRENDERER = 0x00000001,
AMMSF_ADDDEFAULTRENDERER = 0x00000001, AMMSF_CREATEPEER = 0x00000002,
AMMSF_CREATEPEER = 0x00000002, AMMSF_STOPIFNOSAMPLES = 0x00000004,
AMMSF_STOPIFNOSAMPLES = 0x00000004, AMMSF_NOSTALL = 0x00000008
AMMSF_NOSTALL = 0x00000008
}; };
enum enum {
{ AMMSF_RENDERTYPEMASK = 0x00000003,
AMMSF_RENDERTYPEMASK = 0x00000003, AMMSF_RENDERTOEXISTING = 0x00000000,
AMMSF_RENDERTOEXISTING = 0x00000000, AMMSF_RENDERALLSTREAMS = 0x00000001,
AMMSF_RENDERALLSTREAMS = 0x00000001, AMMSF_NORENDER = 0x00000002,
AMMSF_NORENDER = 0x00000002, AMMSF_NOCLOCK = 0x00000004,
AMMSF_RUN = 0x00000008
AMMSF_NOCLOCK = 0x00000004,
AMMSF_RUN = 0x00000008
}; };
typedef [v1_enum] enum
{ typedef [v1_enum] enum {
Disabled = 0, Disabled = 0,
ReadData = 1, ReadData = 1,
RenderData = 2 RenderData = 2
} OUTPUT_STATE; } OUTPUT_STATE;
/*
[ [
object, object,
uuid(7DB01C96-C0C3-11d0-8FF1-00C04FD9189D), uuid(7DB01C96-C0C3-11d0-8FF1-00C04FD9189D),
dual, dual,
helpstring("IDirectShowStream Interface"),
pointer_default(unique) pointer_default(unique)
] ]
interface IDirectShowStream : IDispatch interface IDirectShowStream : IDispatch
{ {
[propget, id(1)] HRESULT FileName([out, retval] BSTR *pVal); [propget, id(1), helpstring("property FileName")] HRESULT FileName([out, retval] BSTR *pVal);
[propput, id(1)] HRESULT FileName([in] BSTR newVal); [propput, id(1), helpstring("property FileName")] HRESULT FileName([in] BSTR newVal);
[propget, id(2)] HRESULT Video([out, retval] OUTPUT_STATE *pVal); [propget, id(2), helpstring("property Video")] HRESULT Video([out, retval] OUTPUT_STATE *pVal);
[propput, id(2)] HRESULT Video([in] OUTPUT_STATE newVal); [propput, id(2), helpstring("propetry Video")] HRESULT Video([in] OUTPUT_STATE newVal);
[propget, id(3)] HRESULT Audio([out, retval] OUTPUT_STATE *pVal); [propget, id(3), helpstring("property Audio")] HRESULT Audio([out, retval] OUTPUT_STATE *pVal);
[propput, id(3)] HRESULT Audio([in] OUTPUT_STATE newVal); [propput, id(3), helpstring("propetry Audio")] HRESULT Audio([in] OUTPUT_STATE newVal);
}; };
*/
[ [
object, object,
@ -72,15 +90,37 @@ pointer_default(unique)
] ]
interface IAMMultiMediaStream : IMultiMediaStream interface IAMMultiMediaStream : IMultiMediaStream
{ {
HRESULT Initialize([in] STREAM_TYPE StreamType, [in] DWORD dwFlags, [in] IGraphBuilder *pFilterGraph); HRESULT Initialize(
HRESULT GetFilterGraph([out] IGraphBuilder **ppGraphBuilder); [in] STREAM_TYPE StreamType,
HRESULT GetFilter([out] IMediaStreamFilter **ppFilter); [in] DWORD dwFlags,
HRESULT AddMediaStream([in] IUnknown *pStreamObject, [in] const MSPID *PurposeId, [in] DWORD dwFlags, [out] IMediaStream **ppNewStream); [in, optional] IGraphBuilder *pFilterGraph);
HRESULT OpenFile([in] LPCWSTR pszFileName, [in] DWORD dwFlags);
HRESULT OpenMoniker([in] IBindCtx *pCtx, [in] IMoniker *pMoniker, [in] DWORD dwFlags); HRESULT GetFilterGraph(
HRESULT Render([in] DWORD dwFlags); [out] IGraphBuilder **ppGraphBuilder);
HRESULT GetFilter(
[out] IMediaStreamFilter **ppFilter);
HRESULT AddMediaStream(
[in, optional] IUnknown *pStreamObject,
[in, optional] const MSPID *PurposeId,
[in] DWORD dwFlags,
[out, optional] IMediaStream **ppNewStream);
HRESULT OpenFile(
[in] LPCWSTR pszFileName,
[in] DWORD dwFlags);
HRESULT OpenMoniker(
[in] IBindCtx *pCtx,
[in] IMoniker *pMoniker,
[in] DWORD dwFlags);
HRESULT Render(
[in] DWORD dwFlags);
} }
[ [
object, object,
uuid(BEBE595D-9A6F-11d0-8FDE-00C04FD9189D), uuid(BEBE595D-9A6F-11d0-8FDE-00C04FD9189D),
@ -88,12 +128,25 @@ pointer_default(unique)
] ]
interface IAMMediaStream : IMediaStream interface IAMMediaStream : IMediaStream
{ {
HRESULT Initialize([in] IUnknown *pSourceObject, [in] DWORD dwFlags, [in] REFMSPID PurposeId, [in] const STREAM_TYPE StreamType); HRESULT Initialize(
HRESULT SetState([in] FILTER_STATE State); [in, optional] IUnknown *pSourceObject,
HRESULT JoinAMMultiMediaStream([in] IAMMultiMediaStream *pAMMultiMediaStream); [in] DWORD dwFlags,
HRESULT JoinFilter([in] IMediaStreamFilter *pMediaStreamFilter); [in] REFMSPID PurposeId,
HRESULT JoinFilterGraph([in] IFilterGraph *pFilterGraph); [in] const STREAM_TYPE StreamType);
};
HRESULT SetState(
[in] FILTER_STATE State);
HRESULT JoinAMMultiMediaStream(
[in] IAMMultiMediaStream *pAMMultiMediaStream);
HRESULT JoinFilter(
[in] IMediaStreamFilter *pMediaStreamFilter);
HRESULT JoinFilterGraph(
[in] IFilterGraph *pFilterGraph);
}
[ [
object, object,
@ -103,16 +156,35 @@ pointer_default(unique)
] ]
interface IMediaStreamFilter : IBaseFilter interface IMediaStreamFilter : IBaseFilter
{ {
HRESULT AddMediaStream([in] IAMMediaStream *pAMMediaStream); HRESULT AddMediaStream(
HRESULT GetMediaStream([in] REFMSPID idPurpose, [out] IMediaStream **ppMediaStream); [in] IAMMediaStream *pAMMediaStream);
HRESULT EnumMediaStreams([in] long Index, [out] IMediaStream **ppMediaStream);
HRESULT SupportSeeking([in] BOOL bRenderer); HRESULT GetMediaStream(
HRESULT ReferenceTimeToStreamTime([in] [out] REFERENCE_TIME *pTime); [in] REFMSPID idPurpose,
HRESULT GetCurrentStreamTime([out] REFERENCE_TIME *pCurrentStreamTime); [out] IMediaStream **ppMediaStream);
HRESULT WaitUntil([in] REFERENCE_TIME WaitStreamTime);
HRESULT Flush([in] BOOL bCancelEOS); HRESULT EnumMediaStreams(
HRESULT EndOfStream(); [in] long Index,
}; [out] IMediaStream **ppMediaStream);
HRESULT SupportSeeking(
[in] BOOL bRenderer);
HRESULT ReferenceTimeToStreamTime(
[in] [out] REFERENCE_TIME *pTime);
HRESULT GetCurrentStreamTime(
[out] REFERENCE_TIME *pCurrentStreamTime);
HRESULT WaitUntil(
[in] REFERENCE_TIME WaitStreamTime);
HRESULT Flush(
[in] BOOL bCancelEOS);
HRESULT EndOfStream();
}
[ [
object, object,
@ -122,8 +194,9 @@ pointer_default(unique)
] ]
interface IDirectDrawMediaSampleAllocator : IUnknown interface IDirectDrawMediaSampleAllocator : IUnknown
{ {
HRESULT GetDirectDraw(IDirectDraw **ppDirectDraw); HRESULT GetDirectDraw(IDirectDraw **ppDirectDraw);
}; }
[ [
object, object,
@ -133,9 +206,13 @@ pointer_default(unique)
] ]
interface IDirectDrawMediaSample : IUnknown interface IDirectDrawMediaSample : IUnknown
{ {
HRESULT GetSurfaceAndReleaseLock([out] IDirectDrawSurface **ppDirectDrawSurface, [out] RECT * pRect); HRESULT GetSurfaceAndReleaseLock(
HRESULT LockMediaSamplePointer(void); [out] IDirectDrawSurface **ppDirectDrawSurface,
}; [out] RECT * pRect);
HRESULT LockMediaSamplePointer(void);
}
[ [
object, object,
@ -146,19 +223,30 @@ pointer_default(unique)
interface IAMMediaTypeStream : IMediaStream interface IAMMediaTypeStream : IMediaStream
{ {
HRESULT GetFormat([out] AM_MEDIA_TYPE * pMediaType, [in] DWORD dwFlags); HRESULT GetFormat(
HRESULT SetFormat([in] AM_MEDIA_TYPE * pMediaType, [in] DWORD dwFlags); [out] AM_MEDIA_TYPE * pMediaType,
HRESULT CreateSample([in] long lSampleSize, [in] BYTE * pbBuffer, [in] DWORD dwFlags, [in] IUnknown *pUnkOuter, [out] IAMMediaTypeSample ** ppAMMediaTypeSample); [in] DWORD dwFlags);
HRESULT GetStreamAllocatorRequirements([out] ALLOCATOR_PROPERTIES *pProps);
HRESULT SetStreamAllocatorRequirements([in] ALLOCATOR_PROPERTIES *pProps); HRESULT SetFormat(
}; [in] AM_MEDIA_TYPE * pMediaType,
[in] DWORD dwFlags);
HRESULT CreateSample(
[in] long lSampleSize,
[in, optional] BYTE * pbBuffer,
[in] DWORD dwFlags,
[in, optional] IUnknown *pUnkOuter,
[out] IAMMediaTypeSample ** ppAMMediaTypeSample);
HRESULT GetStreamAllocatorRequirements(
[out] ALLOCATOR_PROPERTIES *pProps);
HRESULT SetStreamAllocatorRequirements(
[in] ALLOCATOR_PROPERTIES *pProps);
}
[
[
object, object,
local, local,
uuid(AB6B4AFB-F6E4-11d0-900D-00C04FD9189D), uuid(AB6B4AFB-F6E4-11d0-900D-00C04FD9189D),
@ -166,47 +254,66 @@ pointer_default(unique)
] ]
interface IAMMediaTypeSample : IStreamSample interface IAMMediaTypeSample : IStreamSample
{ {
HRESULT SetPointer([in] BYTE *pBuffer, [in] long lSize); HRESULT SetPointer(
HRESULT GetPointer([out] BYTE ** ppBuffer); [in] BYTE *pBuffer,
long GetSize(void); [in] long lSize);
HRESULT GetTime([out] REFERENCE_TIME * pTimeStart, [out] REFERENCE_TIME * pTimeEnd);
HRESULT SetTime([in] REFERENCE_TIME * pTimeStart, [in] REFERENCE_TIME * pTimeEnd); HRESULT GetPointer(
HRESULT IsSyncPoint(void); [out] BYTE ** ppBuffer);
HRESULT SetSyncPoint(BOOL bIsSyncPoint);
HRESULT IsPreroll(void); long GetSize(void);
HRESULT SetPreroll(BOOL bIsPreroll);
long GetActualDataLength(void); HRESULT GetTime(
HRESULT SetActualDataLength(long Len); [out] REFERENCE_TIME * pTimeStart,
HRESULT GetMediaType(AM_MEDIA_TYPE **ppMediaType); [out] REFERENCE_TIME * pTimeEnd);
HRESULT SetMediaType(AM_MEDIA_TYPE *pMediaType);
HRESULT IsDiscontinuity(void); HRESULT SetTime(
HRESULT SetDiscontinuity(BOOL bDiscontinuity); [in] REFERENCE_TIME * pTimeStart,
HRESULT GetMediaTime([out] LONGLONG * pTimeStart, [out] LONGLONG * pTimeEnd); [in] REFERENCE_TIME * pTimeEnd);
HRESULT SetMediaTime([in] LONGLONG * pTimeStart, [in] LONGLONG * pTimeEnd);
}; HRESULT IsSyncPoint(void);
HRESULT SetSyncPoint(
BOOL bIsSyncPoint);
HRESULT IsPreroll(void);
HRESULT SetPreroll(
BOOL bIsPreroll);
long GetActualDataLength(void);
HRESULT SetActualDataLength(long Len);
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);
}
[ [
uuid(4E6CDE29-C0C4-11d0-8FF1-00C04FD9189D) uuid(49C47CE5-9BA4-11d0-8212-00C04FC32C45)
] ]
coclass AMMultiMediaStream
library DirectShowStreamLib
{ {
importlib("stdole2.tlb"); [default] dispinterface IDirectShowStream;
[ }
uuid(49c47ce5-9ba4-11d0-8212-00c04fc32c45)
]
coclass AMMultiMediaStream
{
[default] dispinterface IDirectShowStream;
};
};
cpp_quote("#ifndef __cplusplus")
cpp_quote("EXTERN_C const CLSID CLSID_AMMultiMediaStream;")
cpp_quote("#endif")
cpp_quote("DEFINE_GUID(CLSID_AMDirectDrawStream, 0x49c47ce4, 0x9ba4, 0x11d0, 0x82, 0x12, 0x00, 0xc0, 0x4f, 0xc3, 0x2c, 0x45);")
cpp_quote("DEFINE_GUID(CLSID_AMAudioStream, 0x8496e040, 0xaf4c, 0x11d0, 0x82, 0x12, 0x00, 0xc0, 0x4f, 0xc3, 0x2c, 0x45);")
cpp_quote("DEFINE_GUID(CLSID_AMAudioData, 0xf2468580, 0xaf8a, 0x11d0, 0x82, 0x12, 0x00, 0xc0, 0x4f, 0xc3, 0x2c, 0x45);")
cpp_quote("DEFINE_GUID(CLSID_AMMediaTypeStream, 0xcf0f2f7c, 0xf7bf, 0x11d0, 0x90, 0xd, 0x0, 0xc0, 0x4f, 0xd9, 0x18, 0x9d);")
cpp_quote("DEFINE_GUID(CLSID_AMDirectDrawStream, 0x49c47ce4, 0x9ba4, 0x11d0, 0x82, 0x12, 0x00, 0xc0, 0x4f, 0xc3, 0x2c, 0x45);")
cpp_quote("DEFINE_GUID(CLSID_AMAudioStream, 0x8496e040, 0xaf4c, 0x11d0, 0x82, 0x12, 0x00, 0xc0, 0x4f, 0xc3, 0x2c, 0x45);")
cpp_quote("DEFINE_GUID(CLSID_AMAudioData, 0xf2468580, 0xaf8a, 0x11d0, 0x82, 0x12, 0x00, 0xc0, 0x4f, 0xc3, 0x2c, 0x45);")
cpp_quote("DEFINE_GUID(CLSID_AMMediaTypeStream, 0xcf0f2f7c, 0xf7bf, 0x11d0, 0x90, 0x0d, 0x00, 0xc0, 0x4f, 0xd9, 0x18, 0x9d);")

106
reactos/include/dxsdk/austream.idl
View file

@ -1,8 +1,24 @@
/*
* Copyright 2004 Christian Costa
*
* 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
*/
import "unknwn.idl"; import "unknwn.idl";
import "mmstream.idl"; import "mmstream.idl";
// hack
cpp_quote("#if 0") cpp_quote("#if 0")
typedef struct tWAVEFORMATEX WAVEFORMATEX; typedef struct tWAVEFORMATEX WAVEFORMATEX;
cpp_quote ("#endif") cpp_quote ("#endif")
@ -18,39 +34,22 @@ local,
uuid(f7537560-a3be-11d0-8212-00c04fc32c45), uuid(f7537560-a3be-11d0-8212-00c04fc32c45),
pointer_default(unique) pointer_default(unique)
] ]
interface IAudioMediaStream : IMediaStream interface IAudioMediaStream : IMediaStream
{ {
HRESULT GetFormat([out] WAVEFORMATEX *pWaveFormatCurrent); HRESULT GetFormat(
HRESULT SetFormat([in] const WAVEFORMATEX *lpWaveFormat); [out] /*[optional]*/ WAVEFORMATEX *pWaveFormatCurrent
HRESULT CreateSample([in] IAudioData *pAudioData, [in] DWORD dwFlags, [out] IAudioStreamSample **ppSample); );
HRESULT SetFormat(
[in] const WAVEFORMATEX *lpWaveFormat);
HRESULT CreateSample(
[in] IAudioData *pAudioData,
[in] DWORD dwFlags,
[out] IAudioStreamSample **ppSample
);
} }
[
object,
local,
uuid(54c719c0-af60-11d0-8212-00c04fc32c45),
pointer_default(unique)
]
interface IAudioData : IMemoryData
{
HRESULT GetFormat([out] WAVEFORMATEX *pWaveFormatCurrent);
HRESULT SetFormat([in] const WAVEFORMATEX *lpWaveFormat);
}
[
object,
local,
uuid(327fc560-af60-11d0-8212-00c04fc32c45),
pointer_default(unique)
]
interface IMemoryData : IUnknown
{
HRESULT SetBuffer([in] DWORD cbSize, [in] BYTE *pbData, [in] DWORD dwFlags);
HRESULT GetInfo([out] DWORD *pdwLength, [out] BYTE **ppbData, [out] DWORD *pcbActualData);
HRESULT SetActual([in] DWORD cbDataValid);
}
[ [
object, object,
@ -60,5 +59,50 @@ pointer_default(unique)
] ]
interface IAudioStreamSample : IStreamSample interface IAudioStreamSample : IStreamSample
{ {
HRESULT GetAudioData([out] IAudioData **ppAudio); HRESULT GetAudioData(
[out] IAudioData **ppAudio
);
}
[
object,
local,
uuid(327fc560-af60-11d0-8212-00c04fc32c45),
pointer_default(unique)
]
interface IMemoryData : IUnknown
{
HRESULT SetBuffer(
[in] DWORD cbSize,
[in] BYTE *pbData,
[in] DWORD dwFlags
);
HRESULT GetInfo(
[out] DWORD *pdwLength,
[out] BYTE **ppbData,
[out] DWORD *pcbActualData
);
HRESULT SetActual(
[in] DWORD cbDataValid
);
}
[
object,
local,
uuid(54c719c0-af60-11d0-8212-00c04fc32c45),
pointer_default(unique)
]
interface IAudioData : IMemoryData
{
HRESULT GetFormat(
[out] /*[optional]*/ WAVEFORMATEX *pWaveFormatCurrent
);
HRESULT SetFormat(
[in] const WAVEFORMATEX *lpWaveFormat
);
} }

94
reactos/include/dxsdk/ddstream.idl
View file

@ -1,36 +1,40 @@
/*
* Copyright 2004 Christian Costa
*
* 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
*/
import "unknwn.idl"; import "unknwn.idl";
import "mmstream.idl"; import "mmstream.idl";
cpp_quote("#if 0") cpp_quote("#ifndef __WINE_DDRAW_H")
typedef void * LPDDSURFACEDESC; typedef void * LPDDSURFACEDESC;
typedef struct tDDSURFACEDESC DDSURFACEDESC; typedef struct tDDSURFACEDESC DDSURFACEDESC;
cpp_quote("#endif")
cpp_quote("#include <ddraw.h>")
enum
{
DDSFF_PROGRESSIVERENDER = 0x00000001
};
interface IDirectDraw; interface IDirectDraw;
interface IDirectDrawSurface; interface IDirectDrawSurface;
interface IDirectDrawPalette; interface IDirectDrawPalette;
cpp_quote("#endif")
cpp_quote("#include <ddraw.h>")
enum {
DDSFF_PROGRESSIVERENDER = 0x00000001
};
interface IDirectDrawMediaStream; interface IDirectDrawMediaStream;
interface IDirectDrawStreamSample; interface IDirectDrawStreamSample;
[
object,
local,
uuid(F4104FCF-9A70-11d0-8FDE-00C04FD9189D),
pointer_default(unique)
]
interface IDirectDrawStreamSample : IStreamSample
{
HRESULT GetSurface([out] IDirectDrawSurface ** ppDirectDrawSurface, [out] RECT * pRect);
HRESULT SetRect([in] const RECT * pRect);
};
[ [
object, object,
local, local,
@ -39,12 +43,46 @@ pointer_default(unique)
] ]
interface IDirectDrawMediaStream : IMediaStream interface IDirectDrawMediaStream : IMediaStream
{ {
HRESULT GetFormat([out] DDSURFACEDESC *pDDSDCurrent, [out] IDirectDrawPalette **ppDirectDrawPalette, [out] DDSURFACEDESC *pDDSDDesired, [out] DWORD *pdwFlags); HRESULT GetFormat(
HRESULT SetFormat([in] const DDSURFACEDESC *pDDSurfaceDesc, [in] IDirectDrawPalette *pDirectDrawPalette); [out, optional] DDSURFACEDESC *pDDSDCurrent,
HRESULT GetDirectDraw([out] IDirectDraw **ppDirectDraw); [out, optional] IDirectDrawPalette **ppDirectDrawPalette,
HRESULT SetDirectDraw([in] IDirectDraw *pDirectDraw); [out, optional] DDSURFACEDESC *pDDSDDesired,
HRESULT CreateSample([in] IDirectDrawSurface *pSurface, [in] const RECT *pRect, [in] DWORD dwFlags, [out]IDirectDrawStreamSample **ppSample); [out, optional] DWORD *pdwFlags);
HRESULT GetTimePerFrame([out] STREAM_TIME *pFrameTime);
}; HRESULT SetFormat(
[in] const DDSURFACEDESC *pDDSurfaceDesc,
[in, optional] IDirectDrawPalette *pDirectDrawPalette);
HRESULT GetDirectDraw(
[out] IDirectDraw **ppDirectDraw);
HRESULT SetDirectDraw(
[in] IDirectDraw *pDirectDraw);
HRESULT CreateSample(
[in, optional] IDirectDrawSurface *pSurface,
[in, optional] const RECT *pRect,
[in] DWORD dwFlags,
[out] IDirectDrawStreamSample **ppSample);
HRESULT GetTimePerFrame(
[out] STREAM_TIME *pFrameTime);
}
[
object,
local,
uuid(F4104FCF-9A70-11d0-8FDE-00C04FD9189D),
pointer_default(unique)
]
interface IDirectDrawStreamSample : IStreamSample
{
HRESULT GetSurface(
[out, optional] IDirectDrawSurface ** ppDirectDrawSurface,
[out, optional] RECT * pRect);
HRESULT SetRect(
[in] const RECT * pRect);
}

28
reactos/include/dxsdk/devenum.idl
View file

@ -1,3 +1,22 @@
/*
* 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
*/
import "oaidl.idl";
cpp_quote("#define CDEF_CLASS_DEFAULT 0x0001") cpp_quote("#define CDEF_CLASS_DEFAULT 0x0001")
cpp_quote("#define CDEF_BYPASS_CLASS_MANAGER 0x0002") cpp_quote("#define CDEF_BYPASS_CLASS_MANAGER 0x0002")
@ -11,9 +30,8 @@ cpp_quote("#define CDEF_MERIT_ABOVE_DO_NOT_USE 0x0008")
] ]
interface ICreateDevEnum : IUnknown interface ICreateDevEnum : IUnknown
{ {
import "oaidl.idl"; HRESULT CreateClassEnumerator(
[in] REFCLSID clsidDeviceClass,
HRESULT CreateClassEnumerator( [in] REFCLSID clsidDeviceClass, [out] IEnumMoniker ** ppEnumMoniker,
[out] IEnumMoniker ** ppEnumMoniker, [in] DWORD dwFlags);
[in] DWORD dwFlags);
} }

6
reactos/include/dxsdk/dvdif.idl
View file

@ -1,6 +0,0 @@
import "unknwn.idl";
import "objidl.idl";
cpp_quote("#include <ddraw.h>")
// fixme it is not completed

3
reactos/include/dxsdk/dxsdk.rbuild
View file

@ -5,7 +5,6 @@
<file>austream.idl</file> <file>austream.idl</file>
<file>ddstream.idl</file> <file>ddstream.idl</file>
<file>dmodshow.idl</file> <file>dmodshow.idl</file>
<file>dyngraph.idl</file>
<file>mixerocx.idl</file> <file>mixerocx.idl</file>
<file>mediaobj.idl</file> <file>mediaobj.idl</file>
<file>medparam.idl</file> <file>medparam.idl</file>
@ -14,8 +13,6 @@
<file>tvratings.idl</file> <file>tvratings.idl</file>
<file>vidcap.idl</file> <file>vidcap.idl</file>
<file>Videoacc.idl</file> <file>Videoacc.idl</file>
<file>Vmrender.idl</file>
<file>strmif.idl</file> <file>strmif.idl</file>
<file>dvdif.idl</file>
<file>devenum.idl</file> <file>devenum.idl</file>
</module> </module>

156
reactos/include/dxsdk/dyngraph.idl
View file

@ -1,25 +1,59 @@
/*
* Copyright (C) 2002 Robert Shearman
cpp_quote("#if 0") *
import "unknwn.idl"; * This library is free software; you can redistribute it and/or
typedef int IBaseFilter ; * modify it under the terms of the GNU Lesser General Public
typedef int IEnumFilters; * License as published by the Free Software Foundation; either
typedef int IPin; * version 2.1 of the License, or (at your option) any later version.
typedef int REFERENCE_TIME; *
typedef int AM_MEDIA_TYPE; * This library is distributed in the hope that it will be useful,
cpp_quote("#endif") * 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
*/
interface IPinConnection; interface IPinConnection;
interface IPinFlowControl; interface IPinFlowControl;
interface IGraphConfig; interface IGraphConfig;
interface IGraphConfigCallback; interface IGraphConfigCallback;
[
local,
object,
uuid(4a9a62d3-27d4-403d-91e9-89f540e55534),
pointer_default(unique)
]
interface IPinConnection : IUnknown
{
HRESULT DynamicQueryAccept([in] const AM_MEDIA_TYPE *pmt);
HRESULT NotifyEndOfStream([in] HANDLE hNotifyEvent);
HRESULT IsEndPin();
HRESULT DynamicDisconnect();
}
[
local,
object,
uuid(c56e9858-dbf3-4f6b-8119-384af2060deb),
pointer_default(unique)
]
interface IPinFlowControl : IUnknown
{
HRESULT Block([in] DWORD dwBlockFlags, [in] HANDLE hEvent);
}
enum _AM_PIN_FLOW_CONTROL_BLOCK_FLAGS enum _AM_PIN_FLOW_CONTROL_BLOCK_FLAGS
{ {
AM_PIN_FLOW_CONTROL_BLOCK = 0x00000001, AM_PIN_FLOW_CONTROL_BLOCK = 0x00000001,
}; };
typedef enum _AM_GRAPH_CONFIG_RECONNECT_FLAGS typedef enum _AM_GRAPH_CONFIG_RECONNECT_FLAGS
{ {
AM_GRAPH_CONFIG_RECONNECT_DIRECTCONNECT = 0x00000001, AM_GRAPH_CONFIG_RECONNECT_DIRECTCONNECT = 0x00000001,
@ -27,7 +61,6 @@ typedef enum _AM_GRAPH_CONFIG_RECONNECT_FLAGS
AM_GRAPH_CONFIG_RECONNECT_USE_ONLY_CACHED_FILTERS = 0x00000004 AM_GRAPH_CONFIG_RECONNECT_USE_ONLY_CACHED_FILTERS = 0x00000004
} AM_GRAPH_CONFIG_RECONNECT_FLAGS; } AM_GRAPH_CONFIG_RECONNECT_FLAGS;
enum _REM_FILTER_FLAGS enum _REM_FILTER_FLAGS
{ {
REMFILTERF_LEAVECONNECTED = 0x00000001 REMFILTERF_LEAVECONNECTED = 0x00000001
@ -36,61 +69,55 @@ enum _REM_FILTER_FLAGS
typedef enum _AM_FILTER_FLAGS typedef enum _AM_FILTER_FLAGS
{ {
AM_FILTER_FLAGS_REMOVABLE = 0x00000001 AM_FILTER_FLAGS_REMOVABLE = 0x00000001
} AM_FILTER_FLAGS; } AM_FILTER_FLAGS;
[ [
local, local,
object, object,
uuid(4a9a62d3-27d4-403d-91e9-89f540e55534), uuid(03A1EB8E-32BF-4245-8502-114D08A9CB88),
pointer_default(unique) pointer_default(unique)
]
interface IPinConnection : IUnknown
{
HRESULT DynamicQueryAccept([in] const AM_MEDIA_TYPE *pmt);
HRESULT NotifyEndOfStream([in] HANDLE hNotifyEvent);
HRESULT IsEndPin();
HRESULT DynamicDisconnect();
};
[
local,
object,
uuid(c56e9858-dbf3-4f6b-8119-384af2060deb),
pointer_default(unique)
]
interface IPinFlowControl : IUnknown
{
HRESULT Block([in] DWORD dwBlockFlags, [in] HANDLE hEvent);
}
[
local,
object,
uuid(03A1EB8E-32BF-4245-8502-114D08A9CB88),
pointer_default(unique)
] ]
interface IGraphConfig : IUnknown interface IGraphConfig : IUnknown
{ {
HRESULT Reconnect([in] IPin *pOutputPin, [in] IPin *pInputPin, [in] const AM_MEDIA_TYPE *pmtFirstConnection, IBaseFilter *pUsingFilter, [in] HANDLE hAbortEvent, [in] DWORD dwFlags); HRESULT Reconnect(
HRESULT Reconfigure([in] IGraphConfigCallback *pCallback, [in] PVOID pvContext, [in] DWORD dwFlags, [in] HANDLE hAbortEvent); [in] IPin *pOutputPin,
[in] IPin *pInputPin,
[in] const AM_MEDIA_TYPE *pmtFirstConnection,
[in] IBaseFilter *pUsingFilter,
[in] HANDLE hAbortEvent,
[in] DWORD dwFlags);
HRESULT Reconfigure(
[in] IGraphConfigCallback *pCallback,
[in] PVOID pvContext,
[in] DWORD dwFlags,
[in] HANDLE hAbortEvent);
HRESULT AddFilterToCache([in] IBaseFilter *pFilter); HRESULT AddFilterToCache([in] IBaseFilter *pFilter);
HRESULT EnumCacheFilter([out] IEnumFilters **pEnum); HRESULT EnumCacheFilter([out] IEnumFilters **pEnum);
HRESULT RemoveFilterFromCache([in]IBaseFilter *pFilter); HRESULT RemoveFilterFromCache([in]IBaseFilter *pFilter);
HRESULT GetStartTime([out] REFERENCE_TIME *prtStart); HRESULT GetStartTime([out] REFERENCE_TIME *prtStart);
HRESULT PushThroughData([in] IPin *pOutputPin, [in] IPinConnection *pConnection, [in] HANDLE hEventAbort);
HRESULT PushThroughData(
[in] IPin *pOutputPin,
[in] IPinConnection *pConnection,
[in] HANDLE hEventAbort);
HRESULT SetFilterFlags([in] IBaseFilter *pFilter, [in] DWORD dwFlags); HRESULT SetFilterFlags([in] IBaseFilter *pFilter, [in] DWORD dwFlags);
HRESULT GetFilterFlags([in] IBaseFilter *pFilter, [out] DWORD *pdwFlags); HRESULT GetFilterFlags([in] IBaseFilter *pFilter, [out] DWORD *pdwFlags);
HRESULT RemoveFilterEx( [in] IBaseFilter *pFilter, DWORD Flags );
HRESULT RemoveFilterEx([in] IBaseFilter *pFilter, DWORD Flags);
} }
[ [
local, local,
object, object,
uuid(ade0fd60-d19d-11d2-abf6-00a0c905f375), uuid(ade0fd60-d19d-11d2-abf6-00a0c905f375),
pointer_default(unique) pointer_default(unique)
] ]
interface IGraphConfigCallback : IUnknown interface IGraphConfigCallback : IUnknown
{ {
@ -105,12 +132,19 @@ interface IGraphConfigCallback : IUnknown
] ]
interface IFilterChain : IUnknown interface IFilterChain : IUnknown
{ {
HRESULT StartChain( [in] IBaseFilter *pStartFilter, [in] IBaseFilter *pEndFilter ); HRESULT StartChain(
HRESULT PauseChain( [in] IBaseFilter *pStartFilter, [in] IBaseFilter *pEndFilter ); [in] IBaseFilter *pStartFilter,
HRESULT StopChain( [in] IBaseFilter *pStartFilter, [in] IBaseFilter *pEndFilter ); [in] IBaseFilter *pEndFilter);
HRESULT RemoveChain( [in] IBaseFilter *pStartFilter, [in] IBaseFilter *pEndFilter );
HRESULT PauseChain(
[in] IBaseFilter *pStartFilter,
[in] IBaseFilter *pEndFilter);
HRESULT StopChain(
[in] IBaseFilter *pStartFilter,
[in] IBaseFilter *pEndFilter);
HRESULT RemoveChain(
[in] IBaseFilter *pStartFilter,
[in] IBaseFilter *pEndFilter);
} }

223
reactos/include/dxsdk/mediaobj.idl
View file

@ -1,189 +1,74 @@
/*
* Copyright (C) 2002 Alexandre Julliard
* Copyright (C) 2004 Vincent Béron
*
* 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
*/
cpp_quote("#if !defined(COM_NO_WINDOWS_H) && !defined(__WINESRC__)")
cpp_quote("#include <windows.h>")
cpp_quote("#include <ole2.h>")
cpp_quote("#endif")
import "unknwn.idl"; import "unknwn.idl";
import "objidl.idl"; import "objidl.idl";
interface IDMOQualityControl;
interface IDMOVideoOutputOptimizations;
interface IMediaBuffer;
interface IMediaObject;
interface IMediaObjectInPlace;
cpp_quote("#ifdef __strmif_h__")
cpp_quote("typedef AM_MEDIA_TYPE DMO_MEDIA_TYPE;")
cpp_quote("#else")
typedef struct _DMOMediaType typedef struct _DMOMediaType
{ {
GUID majortype; GUID majortype;
GUID subtype; GUID subtype;
BOOL bFixedSizeSamples; BOOL bFixedSizeSamples;
BOOL bTemporalCompression; BOOL bTemporalCompression;
ULONG lSampleSize; ULONG lSampleSize;
GUID formattype; GUID formattype;
IUnknown *pUnk; IUnknown *pUnk;
ULONG cbFormat; ULONG cbFormat;
[size_is(cbFormat)] BYTE * pbFormat; BYTE *pbFormat;
} DMO_MEDIA_TYPE; } DMO_MEDIA_TYPE;
typedef LONGLONG REFERENCE_TIME;
cpp_quote("#endif")
enum _DMO_INPUT_DATA_BUFFER_FLAGS
{
DMO_INPUT_DATA_BUFFERF_SYNCPOINT = 0x00000001,
DMO_INPUT_DATA_BUFFERF_TIME = 0x00000002,
DMO_INPUT_DATA_BUFFERF_TIMELENGTH = 0x00000004
};
enum _DMO_OUTPUT_DATA_BUFFER_FLAGS
{
DMO_OUTPUT_DATA_BUFFERF_SYNCPOINT = 0x00000001,
DMO_OUTPUT_DATA_BUFFERF_TIME = 0x00000002,
DMO_OUTPUT_DATA_BUFFERF_TIMELENGTH = 0x00000004,
DMO_OUTPUT_DATA_BUFFERF_INCOMPLETE = 0x01000000
};
enum _DMO_INPUT_STATUS_FLAGS
{
DMO_INPUT_STATUSF_ACCEPT_DATA = 0x00000001
};
enum _DMO_INPUT_STREAM_INFO_FLAGS
{
DMO_INPUT_STREAMF_WHOLE_SAMPLES = 0x00000001,
DMO_INPUT_STREAMF_SINGLE_SAMPLE_PER_BUFFER = 0x00000002,
DMO_INPUT_STREAMF_FIXED_SAMPLE_SIZE = 0x00000004,
DMO_INPUT_STREAMF_HOLDS_BUFFERS = 0x00000008
};
enum _DMO_OUTPUT_STREAM_INFO_FLAGS
{
DMO_OUTPUT_STREAMF_WHOLE_SAMPLES = 0x00000001,
DMO_OUTPUT_STREAMF_SINGLE_SAMPLE_PER_BUFFER = 0x00000002,
DMO_OUTPUT_STREAMF_FIXED_SAMPLE_SIZE = 0x00000004,
DMO_OUTPUT_STREAMF_DISCARDABLE = 0x00000008,
DMO_OUTPUT_STREAMF_OPTIONAL = 0x00000010
};
enum _DMO_SET_TYPE_FLAGS
{
DMO_SET_TYPEF_TEST_ONLY = 0x00000001,
DMO_SET_TYPEF_CLEAR = 0x00000002
};
enum _DMO_PROCESS_OUTPUT_FLAGS
{
DMO_PROCESS_OUTPUT_DISCARD_WHEN_NO_BUFFER = 0x00000001
};
enum _DMO_INPLACE_PROCESS_FLAGS
{
DMO_INPLACE_NORMAL = 0x00000000,
DMO_INPLACE_ZERO = 0x00000001
};
enum _DMO_QUALITY_STATUS_FLAGS
{
DMO_QUALITY_STATUS_ENABLED = 0x00000001
};
enum _DMO_VIDEO_OUTPUT_STREAM_FLAGS
{
DMO_VOSF_NEEDS_PREVIOUS_SAMPLE = 0x00000001
};
/*****************************************************************************
* IEnumDMO interface
*/
[ [
object, object,
uuid(59eff8b9-938c-4a26-82f2-95cb84cdc837) uuid(2C3CD98A-2BFA-4A53-9C27-5249BA64BA0F),
] pointer_default(unique)
interface IMediaBuffer : IUnknown
{
HRESULT SetLength(DWORD cbLength);
HRESULT GetMaxLength([out] DWORD *pcbMaxLength);
HRESULT GetBufferAndLength([out] BYTE **ppBuffer, [out] DWORD *pcbLength);
}
typedef struct _DMO_OUTPUT_DATA_BUFFER
{
IMediaBuffer *pBuffer;
DWORD dwStatus;
REFERENCE_TIME rtTimestamp;
REFERENCE_TIME rtTimelength;
} DMO_OUTPUT_DATA_BUFFER, *PDMO_OUTPUT_DATA_BUFFER;
[
object,
uuid(d8ad0f58-5494-4102-97c5-ec798e59bcf4)
]
interface IMediaObject : IUnknown
{
HRESULT GetStreamCount([out] DWORD *pcInputStreams, [out] DWORD *pcOutputStreams);
HRESULT GetInputStreamInfo(DWORD dwInputStreamIndex, [out] DWORD *pdwFlags);
HRESULT GetOutputStreamInfo(DWORD dwOutputStreamIndex, [out] DWORD *pdwFlags);
HRESULT GetInputType(DWORD dwInputStreamIndex, DWORD dwTypeIndex, [out] DMO_MEDIA_TYPE *pmt);
HRESULT GetOutputType(DWORD dwOutputStreamIndex, DWORD dwTypeIndex, [out] DMO_MEDIA_TYPE *pmt);
HRESULT SetInputType(DWORD dwInputStreamIndex, [in] const DMO_MEDIA_TYPE *pmt, DWORD dwFlags);
HRESULT SetOutputType(DWORD dwOutputStreamIndex, [in] const DMO_MEDIA_TYPE *pmt, DWORD dwFlags);
HRESULT GetInputCurrentType(DWORD dwInputStreamIndex, [out] DMO_MEDIA_TYPE *pmt);
HRESULT GetOutputCurrentType(DWORD dwOutputStreamIndex, [out] DMO_MEDIA_TYPE *pmt);
HRESULT GetInputSizeInfo(DWORD dwInputStreamIndex, [out] DWORD *pcbSize, [out] DWORD *pcbMaxLookahead, [out] DWORD *pcbAlignment);
HRESULT GetOutputSizeInfo(DWORD dwOutputStreamIndex, [out] DWORD *pcbSize, [out] DWORD *pcbAlignment);
HRESULT GetInputMaxLatency(DWORD dwInputStreamIndex, [out] REFERENCE_TIME *prtMaxLatency);
HRESULT SetInputMaxLatency(DWORD dwInputStreamIndex, REFERENCE_TIME rtMaxLatency);
HRESULT Flush();
HRESULT Discontinuity(DWORD dwInputStreamIndex);
HRESULT AllocateStreamingResources();
HRESULT FreeStreamingResources();
HRESULT GetInputStatus(DWORD dwInputStreamIndex, [out] DWORD *dwFlags);
HRESULT ProcessInput(DWORD dwInputStreamIndex, IMediaBuffer *pBuffer, DWORD dwFlags, REFERENCE_TIME rtTimestamp, REFERENCE_TIME rtTimelength);
HRESULT ProcessOutput(DWORD dwFlags,DWORD cOutputBufferCount, [in,out,size_is(cOutputBufferCount)]
DMO_OUTPUT_DATA_BUFFER *pOutputBuffers, [out] DWORD *pdwStatus);
HRESULT Lock(LONG bLock);
};
[
object,
uuid(2c3cd98a-2bfa-4a53-9c27-5249ba64ba0f)
] ]
interface IEnumDMO : IUnknown interface IEnumDMO : IUnknown
{ {
HRESULT Next(DWORD cItemsToFetch, [out, size_is(cItemsToFetch), length_is(*pcItemsFetched)] CLSID *pCLSID, [out, size_is(cItemsToFetch), length_is(*pcItemsFetched), string] WCHAR **Names, [out] DWORD *pcItemsFetched); [local]
HRESULT Skip(DWORD cItemsToSkip); HRESULT Next(
HRESULT Reset(void); [in] DWORD cItemsToFetch,
HRESULT Clone([out] IEnumDMO **ppEnum); [out] CLSID *pCLSID,
} [out] WCHAR **Names,
[out] DWORD *pcItemsFetched
);
[ HRESULT Skip(
object, [in] DWORD cItemsToSkip
uuid(651b9ad0-0fc7-4aa9-9538-d89931010741) );
]
interface IMediaObjectInPlace : IUnknown
{
HRESULT Process([in] ULONG ulSize, [in,out,size_is(ulSize)] BYTE* pData, [in] REFERENCE_TIME refTimeStart, [in] DWORD dwFlags);
HRESULT Clone([out] IMediaObjectInPlace **ppMediaObject);
HRESULT GetLatency([out] REFERENCE_TIME *pLatencyTime);
}
[ HRESULT Reset();
object,
uuid(65abea96-cf36-453f-af8a-705e98f16260)
]
interface IDMOQualityControl : IUnknown
{
HRESULT SetNow([in] REFERENCE_TIME rtNow);
HRESULT SetStatus([in] DWORD dwFlags);
HRESULT GetStatus([out] DWORD *pdwFlags);
}
[ HRESULT Clone(
object, [out] IEnumDMO **ppEnum
uuid(be8f4f4e-5b16-4d29-b350-7f6b5d9298ac)
]
interface IDMOVideoOutputOptimizations : IUnknown
{
HRESULT QueryOperationModePreferences (ULONG ulOutputStreamIndex, DWORD *pdwRequestedCapabilities);
HRESULT SetOperationMode (ULONG ulOutputStreamIndex, DWORD dwEnabledFeatures);
HRESULT GetCurrentOperationMode (ULONG ulOutputStreamIndex, DWORD *pdwEnabledFeatures);
HRESULT GetCurrentSampleRequirements (ULONG ulOutputStreamIndex, DWORD *pdwRequestedFeatures
); );
} }

1
reactos/include/dxsdk/medparam.idl
View file

@ -48,7 +48,6 @@ typedef struct _MP_PARAMINFO
WCHAR szLabel[32]; WCHAR szLabel[32];
} MP_PARAMINFO; } MP_PARAMINFO;
typedef DWORD DWORD;
const DWORD DWORD_ALLPARAMS = -1; const DWORD DWORD_ALLPARAMS = -1;
typedef DWORD MP_TIMEDATA; typedef DWORD MP_TIMEDATA;

220
reactos/include/dxsdk/mmstream.idl
View file

@ -1,35 +1,45 @@
/*
* Copyright 2004 Christian Costa
*
* 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
*/
import "unknwn.idl"; import "unknwn.idl";
cpp_quote("DEFINE_GUID(MSPID_PrimaryVideo, 0xA35FF56A, 0x9FDA, 0x11D0, 0x8F, 0xDF, 0x00, 0xC0, 0x4F, 0xD9, 0x18, 0x9D);") cpp_quote("#define MS_ERROR_CODE(x) MAKE_HRESULT(1, FACILITY_ITF, (x) + 0x400)")
cpp_quote("DEFINE_GUID(MSPID_PrimaryAudio, 0xA35FF56B, 0x9FDA, 0x11D0, 0x8F, 0xDF, 0x00, 0xC0, 0x4F, 0xD9, 0x18, 0x9D);") cpp_quote("#define MS_SUCCESS_CODE(x) MAKE_HRESULT(0, FACILITY_ITF, x)")
cpp_quote("#define MS_S_PENDING MS_SUCCESS_CODE(1)")
cpp_quote("#define MS_S_NOUPDATE MS_SUCCESS_CODE(2)")
cpp_quote("#define MS_S_ENDOFSTREAM MS_SUCCESS_CODE(3)")
cpp_quote("#define MS_ERROR_CODE(x) MAKE_HRESULT(1, FACILITY_ITF, (x) + 0x400)") cpp_quote("#define MS_E_SAMPLEALLOC MS_ERROR_CODE(1)")
cpp_quote("#define MS_SUCCESS_CODE(x) MAKE_HRESULT(0, FACILITY_ITF, x)") cpp_quote("#define MS_E_PURPOSEID MS_ERROR_CODE(2)")
cpp_quote("#define MS_S_PENDING MS_SUCCESS_CODE(1)") cpp_quote("#define MS_E_NOSTREAM MS_ERROR_CODE(3)")
cpp_quote("#define MS_S_NOUPDATE MS_SUCCESS_CODE(2)") cpp_quote("#define MS_E_NOSEEKING MS_ERROR_CODE(4)")
cpp_quote("#define MS_S_ENDOFSTREAM MS_SUCCESS_CODE(3)") cpp_quote("#define MS_E_INCOMPATIBLE MS_ERROR_CODE(5)")
cpp_quote("#define MS_E_SAMPLEALLOC MS_ERROR_CODE(1)") cpp_quote("#define MS_E_BUSY MS_ERROR_CODE(6)")
cpp_quote("#define MS_E_PURPOSEID MS_ERROR_CODE(2)") cpp_quote("#define MS_E_NOTINIT MS_ERROR_CODE(7)")
cpp_quote("#define MS_E_NOSTREAM MS_ERROR_CODE(3)") cpp_quote("#define MS_E_SOURCEALREADYDEFINED MS_ERROR_CODE(8)")
cpp_quote("#define MS_E_NOSEEKING MS_ERROR_CODE(4)") cpp_quote("#define MS_E_INVALIDSTREAMTYPE MS_ERROR_CODE(9)")
cpp_quote("#define MS_E_INCOMPATIBLE MS_ERROR_CODE(5)") cpp_quote("#define MS_E_NOTRUNNING MS_ERROR_CODE(10)")
cpp_quote("#define MS_E_BUSY MS_ERROR_CODE(6)")
cpp_quote("#define MS_E_NOTINIT MS_ERROR_CODE(7)")
cpp_quote("#define MS_E_SOURCEALREADYDEFINED MS_ERROR_CODE(8)")
cpp_quote("#define MS_E_INVALIDSTREAMTYPE MS_ERROR_CODE(9)")
cpp_quote("#define MS_E_NOTRUNNING MS_ERROR_CODE(10)")
cpp_quote("DEFINE_GUID(MSPID_PrimaryVideo, 0xa35ff56a, 0x9fda, 0x11d0, 0x8f, 0xdf, 0x0, 0xc0, 0x4f, 0xd9, 0x18, 0x9d);")
cpp_quote("DEFINE_GUID(MSPID_PrimaryAudio, 0xa35ff56b, 0x9fda, 0x11d0, 0x8f, 0xdf, 0x0, 0xc0, 0x4f, 0xd9, 0x18, 0x9d);")
cpp_quote("#if 0")
// FIXME HACK remove the // for two cpp_quote typedef void* PAPCFUNC;
cpp_quote("#if 0");
typedef LPVOID PAPCFUNC;
cpp_quote("#endif");
cpp_quote("#if(_WIN32_WINNT < 0x0400)")
cpp_quote("typedef void (__stdcall * PAPCFUNC)(DWORD_PTR dwParam);")
cpp_quote("#endif") cpp_quote("#endif")
typedef LONGLONG STREAM_TIME; typedef LONGLONG STREAM_TIME;
@ -37,62 +47,78 @@ typedef LONGLONG STREAM_TIME;
typedef GUID MSPID; typedef GUID MSPID;
typedef REFGUID REFMSPID; typedef REFGUID REFMSPID;
enum typedef enum {
{ STREAMTYPE_READ = 0,
MMSSF_HASCLOCK = 0x00000001, STREAMTYPE_WRITE = 1,
MMSSF_SUPPORTSEEK = 0x00000002, STREAMTYPE_TRANSFORM = 2
MMSSF_ASYNCHRONOUS = 0x00000004
};
typedef enum
{
STREAMTYPE_READ = 0,
STREAMTYPE_WRITE = 1,
STREAMTYPE_TRANSFORM= 2
} STREAM_TYPE; } STREAM_TYPE;
enum typedef enum {
{ STREAMSTATE_STOP = 0,
SSUPDATE_ASYNC = 0x00000001, STREAMSTATE_RUN = 1
SSUPDATE_CONTINUOUS = 0x00000002 } STREAM_STATE;
};
typedef enum
{ typedef enum {
COMPSTAT_NOUPDATEOK = 0x00000001, COMPSTAT_NOUPDATEOK = 0x00000001,
COMPSTAT_WAIT = 0x00000002, COMPSTAT_WAIT = 0x00000002,
COMPSTAT_ABORT = 0x00000004 COMPSTAT_ABORT = 0x00000004
} COMPLETION_STATUS_FLAGS; } COMPLETION_STATUS_FLAGS;
enum {
MMSSF_HASCLOCK = 0x00000001,
MMSSF_SUPPORTSEEK = 0x00000002,
MMSSF_ASYNCHRONOUS = 0x00000004
};
typedef enum enum {
{ SSUPDATE_ASYNC = 0x00000001,
STREAMSTATE_STOP = 0, SSUPDATE_CONTINUOUS = 0x00000002
STREAMSTATE_RUN = 1 };
} STREAM_STATE;
interface IMultiMediaStream; interface IMultiMediaStream;
interface IMediaStream; interface IMediaStream;
interface IStreamSample; interface IStreamSample;
[ [
object, object,
local, local,
uuid(B502D1BC-9A57-11d0-8FDE-00C04FD9189D), uuid(B502D1BC-9A57-11d0-8FDE-00C04FD9189D),
pointer_default(unique) pointer_default(unique)
] ]
interface IMultiMediaStream : IUnknown interface IMultiMediaStream : IUnknown {
{
HRESULT GetInformation([out] DWORD *pdwFlags, [out] STREAM_TYPE *pStreamType); HRESULT GetInformation(
HRESULT GetMediaStream([in] REFMSPID idPurpose, [out] IMediaStream **ppMediaStream); [out, optional] DWORD *pdwFlags,
HRESULT EnumMediaStreams([in] long Index, [out] IMediaStream **ppMediaStream); [out, optional] STREAM_TYPE *pStreamType);
HRESULT GetState([out] STREAM_STATE *pCurrentState);
HRESULT SetState([in] STREAM_STATE NewState); HRESULT GetMediaStream(
HRESULT GetTime([out] STREAM_TIME *pCurrentTime); [in] REFMSPID idPurpose,
HRESULT GetDuration([out] STREAM_TIME *pDuration); [out] IMediaStream **ppMediaStream);
HRESULT Seek([in] STREAM_TIME SeekTime);
HRESULT GetEndOfStreamEventHandle([out] HANDLE *phEOS); HRESULT EnumMediaStreams(
}; [in] long Index,
[out] IMediaStream **ppMediaStream);
HRESULT GetState(
[out] STREAM_STATE *pCurrentState);
HRESULT SetState(
[in] STREAM_STATE NewState);
HRESULT GetTime(
[out] STREAM_TIME *pCurrentTime);
HRESULT GetDuration(
[out] STREAM_TIME *pDuration);
HRESULT Seek(
[in] STREAM_TIME SeekTime);
HRESULT GetEndOfStreamEventHandle(
[out] HANDLE *phEOS);
}
[ [
@ -100,15 +126,31 @@ object,
uuid(B502D1BD-9A57-11d0-8FDE-00C04FD9189D), uuid(B502D1BD-9A57-11d0-8FDE-00C04FD9189D),
pointer_default(unique) pointer_default(unique)
] ]
interface IMediaStream : IUnknown interface IMediaStream : IUnknown {
{
HRESULT GetMultiMediaStream([out] IMultiMediaStream **ppMultiMediaStream); HRESULT GetMultiMediaStream(
HRESULT GetInformation([out] MSPID *pPurposeId, [out] STREAM_TYPE *pType); [out] IMultiMediaStream **ppMultiMediaStream);
HRESULT SetSameFormat([in] IMediaStream *pStreamThatHasDesiredFormat, [in] DWORD dwFlags);
HRESULT AllocateSample([in] DWORD dwFlags, [out] IStreamSample **ppSample); HRESULT GetInformation(
HRESULT CreateSharedSample([in] IStreamSample *pExistingSample, [in] DWORD dwFlags, [out] IStreamSample **ppNewSample); [out, optional] MSPID *pPurposeId,
HRESULT SendEndOfStream(DWORD dwFlags); [out, optional] STREAM_TYPE *pType);
};
HRESULT SetSameFormat(
[in] IMediaStream *pStreamThatHasDesiredFormat,
[in] DWORD dwFlags);
HRESULT AllocateSample(
[in] DWORD dwFlags,
[out] IStreamSample **ppSample);
HRESULT CreateSharedSample(
[in] IStreamSample *pExistingSample,
[in] DWORD dwFlags,
[out] IStreamSample **ppNewSample);
HRESULT SendEndOfStream(DWORD dwFlags);
}
[ [
object, object,
@ -116,13 +158,27 @@ local,
uuid(B502D1BE-9A57-11d0-8FDE-00C04FD9189D), uuid(B502D1BE-9A57-11d0-8FDE-00C04FD9189D),
pointer_default(unique) pointer_default(unique)
] ]
interface IStreamSample : IUnknown {
HRESULT GetMediaStream(
[in] IMediaStream **ppMediaStream);
interface IStreamSample : IUnknown HRESULT GetSampleTimes(
{ [out, optional] STREAM_TIME * pStartTime,
HRESULT GetMediaStream([in] IMediaStream **ppMediaStream); [out, optional] STREAM_TIME * pEndTime,
HRESULT GetSampleTimes([out] STREAM_TIME * pStartTime, [out] STREAM_TIME * pEndTime, [out] STREAM_TIME * pCurrentTime); [out, optional] STREAM_TIME * pCurrentTime);
HRESULT SetSampleTimes([in] const STREAM_TIME *pStartTime, [in] const STREAM_TIME *pEndTime);
HRESULT Update([in] DWORD dwFlags, [in] HANDLE hEvent, [in] PAPCFUNC pfnAPC, [in] DWORD_PTR dwAPCData);
HRESULT CompletionStatus( [in] DWORD dwFlags, [in] DWORD dwMilliseconds);
};
HRESULT SetSampleTimes(
[in, optional] const STREAM_TIME *pStartTime,
[in, optional] const STREAM_TIME *pEndTime);
HRESULT Update(
[in] DWORD dwFlags,
[in, optional] HANDLE hEvent,
[in, optional] PAPCFUNC pfnAPC,
[in, optional] DWORD dwAPCData);
HRESULT CompletionStatus(
[in] DWORD dwFlags,
[in, optional] DWORD dwMilliseconds);
}

27
reactos/include/dxsdk/strmif.idl
View file

@ -1,9 +1,30 @@
/*
* 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
*/
import "unknwn.idl";
import "objidl.idl"; import "objidl.idl";
#include <devenum.idl> #include <devenum.idl>
#include <axcore.idl> #include <axcore.idl>
#include <axextend.idl> #include <axextend.idl>
#include <dvdif.idl>
#include <dyngraph.idl> #include <dyngraph.idl>
#include "Vmrender.idl"
/* TODO: #include <dvdif.h> */
#include <vmrender.idl>