From 65ddad359ed3b9b739215ec89a7645455ae10dce Mon Sep 17 00:00:00 2001 From: brunzelchen Date: Tue, 5 Oct 2010 18:28:42 +0000 Subject: - added webcam support - faster program start - faster sorting (mergesort) - sync lyrics to music - some new backgrounds and credits graphics (thx to MezzoX) - own thread for video decoding - finished 6-Player-on-one-screen-mode - changqed player-colors - fixed some bugs... git-svn-id: svn://svn.code.sf.net/p/ultrastardx/svn/branches/1.0.1 Challenge MOD@2637 b956fd51-792f-4845-bead-9b4dfca2ff2c --- Game/Code/lib/DSPack/DirectX9/DirectShow9.pas | 31887 ++++++++++++++++++++++++ 1 file changed, 31887 insertions(+) create mode 100644 Game/Code/lib/DSPack/DirectX9/DirectShow9.pas (limited to 'Game/Code/lib/DSPack/DirectX9/DirectShow9.pas') diff --git a/Game/Code/lib/DSPack/DirectX9/DirectShow9.pas b/Game/Code/lib/DSPack/DirectX9/DirectShow9.pas new file mode 100644 index 00000000..738835b0 --- /dev/null +++ b/Game/Code/lib/DSPack/DirectX9/DirectShow9.pas @@ -0,0 +1,31887 @@ + + {###### #### ############################################################## + ## ### ### ## ,###### ## ## ###### ### ### ## ## + ## ### #### ## ## ## ## ## ## # ## ## ## + ## ## ### ###### ####### ## ## \## ### ##/ ########## + ## ## ##### ##### ####### ## ## ######### ## + ## ## ## ### ,## ## ## ## ## ### ### ### + ###### ### #### ####### ## ## ###### ## ## ########### + | | + | Borland Delphi 4,5,6,7 API for Direct Show | + | DirectX 9.0 Win 98, Me, 2000, XP | + | | + | Portions created by Microsoft are | + | Copyright (C) 1995-2002 Microsoft Corporation. | + | All Rights Reserved. | + | | + | The original files are: | + | comlite.h, errors.h, dv.h, strmif.h, mmstream.h, amstream.h, | + | ddstream.h, austream.h, mpconfig.h, control.h, qnetwork.h, | + | playlist.h, il21dec.h, amvideo.h, amaudio.h, vptype.h, | + | vpconfig.h, vpnotify.h, mpegtype.h, dvdevcod.h, dvdmedia.h, | + | bdatypes.h, activecf.h, vfwmsgs.h,(edevdefs.h, XPrtDefs.h), | + | aviriff.h, evcode.h, uuids.h, ksuuids.h, DXVA.h,AMVA.h, | + | videoacc.h, regbag.h, tuner.h, DXTrans.h, QEdit.h, mpeguids.h, | + | dshowasf.h, amparse.h, audevcod.h, atsmedia.h, MediaErr, | + | MedParam.h, mediaobj.h, dmodshow.h, dmoreg.h, DMORt.h, | + | dmoimpl.h, ks.h, ksproxy.h, ksmedia.h, dmksctrl.h, bdamedia.h, | + | BDATIF.idl, AMVPE.idl, Mixerocx.idl, Mpeg2Data.idl, | + | Mpeg2Structs.idl, Mpeg2Bits.h, Mpeg2Error.h, EDevCtrl.h, | + | sbe.idl, vmr9.idl, iwstdec.h | + | | + | The original Pascal code is: DirectShow9.pas, | + | released 01 Nov 2003. | + | | + | The initial developer of the Pascal code is Henri GOURVEST | + | Email : hgourvest@progdigy.com | + | WebSite : http://www.progdigy.com | + | | + | Portions created by Henri GOURVEST are | + | Copyright (C) 2002 Henri GOURVEST. | + | | + | Contributors: Ivo Steinmann | + | Peter NEUMANN | + | Alexey Barkovoy | + | Wayne Sherman | + | Peter J. Haas | + | Andriy Nevhasymyy | + | Milenko Mitrovic | + | Michael Andersen | + | Martin Offenwanger _di_IPin;'} + {$EXTERNALSYM IPin} + IPin = interface(IUnknown) + ['{56A86891-0AD4-11CE-B03A-0020AF0BA770}'] + (*** IPin methods ***) + function Connect(pReceivePin: IPin; const pmt: PAMMediaType): HResult; stdcall; + function ReceiveConnection(pConnector: IPin; const pmt: TAMMediaType): HResult; stdcall; + function Disconnect: HResult; stdcall; + function ConnectedTo(out pPin: IPin): HResult; stdcall; + function ConnectionMediaType(out pmt: TAMMediaType): HResult; stdcall; + function QueryPinInfo(out pInfo: TPinInfo): HResult; stdcall; + function QueryDirection(out pPinDir: TPinDirection): HResult; stdcall; + function QueryId(out Id: LPWSTR): HResult; stdcall; + function QueryAccept(const pmt: TAMMediaType): HResult; stdcall; + function EnumMediaTypes(out ppEnum: IEnumMediaTypes): HResult; stdcall; + function QueryInternalConnections(out apPin: IPin; var nPin: ULONG): HResult; stdcall; + function EndOfStream: HResult; stdcall; + function BeginFlush: HResult; stdcall; + function EndFlush: HResult; stdcall; + function NewSegment(tStart, tStop: TReferenceTime; dRate: double): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IEnumPins;'} + {$EXTERNALSYM IEnumPins} + IEnumPins = interface(IUnknown) + ['{56A86892-0AD4-11CE-B03A-0020AF0BA770}'] + (*** IEnumPins methods ***) + function Next(cPins: ULONG; out ppPins: IPin; pcFetched: PULONG): HResult; stdcall; + function Skip(cPins: ULONG): HResult; stdcall; + function Reset: HResult; stdcall; + function Clone(out ppEnum: IEnumPins): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IEnumMediaTypes;'} + {$EXTERNALSYM IEnumMediaTypes} + IEnumMediaTypes = interface(IUnknown) + ['{89C31040-846B-11CE-97D3-00AA0055595A}'] + (*** IEnumMediaTypes methods ***) + function Next(cMediaTypes: ULONG; out ppMediaTypes: PAMMediaType; + pcFetched: PULONG): HResult; stdcall; + function Skip(cMediaTypes: ULONG): HResult; stdcall; + function Reset: HResult; stdcall; + function Clone(out ppEnum: IEnumMediaTypes): HResult; stdcall; + end; + + IEnumFilters = interface; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IFilterGraph;'} + {$EXTERNALSYM IFilterGraph} + IFilterGraph = interface(IUnknown) + ['{56A8689F-0AD4-11CE-B03A-0020AF0BA770}'] + (*** IFilterGraph methods ***) + function AddFilter(pFilter: IBaseFilter; pName: PWideChar): HResult; stdcall; + function RemoveFilter(pFilter: IBaseFilter): HResult; stdcall; + function EnumFilters(out ppEnum: IEnumFilters): HResult; stdcall; + function FindFilterByName(pName: PWideChar; out ppFilter: IBaseFilter): HResult; stdcall; + function ConnectDirect(ppinOut, ppinIn: IPin; pmt: PAMMediaType): HResult; stdcall; + function Reconnect(ppin: IPin): HResult; stdcall; + function Disconnect(ppin: IPin): HResult; stdcall; + function SetDefaultSyncSource: HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IEnumFilters;'} + {$EXTERNALSYM IEnumFilters} + IEnumFilters = interface(IUnknown) + ['{56A86893-0AD4-11CE-B03A-0020AF0BA770}'] + (*** IEnumFilters methods ***) + function Next(cFilters: ULONG; out ppFilter: IBaseFilter; + pcFetched: PULONG): HResult; stdcall; + function Skip(cFilters: ULONG): HResult; stdcall; + function Reset: HResult; stdcall; + function Clone(out ppEnum: IEnumFilters): HResult; stdcall; + end; + + _FilterState = ( + State_Stopped, + State_Paused, + State_Running + ); + {$EXTERNALSYM _FilterState} + FILTER_STATE = _FilterState; + {$EXTERNALSYM FILTER_STATE} + TFilterState = FILTER_STATE; + + {$NODEFINE IReferenceClock} + IReferenceClock = DirectSound.IReferenceClock; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IMediaFilter;'} + {$EXTERNALSYM IMediaFilter} + IMediaFilter = interface(IPersist) + ['{56A86899-0AD4-11CE-B03A-0020AF0BA770}'] + (*** IMediaFilter methods ***) + function Stop: HResult; stdcall; + function Pause: HResult; stdcall; + function Run(tStart: TReferenceTime): HResult; stdcall; + function GetState(dwMilliSecsTimeout: DWORD; out State: TFilterState): HResult; stdcall; + function SetSyncSource(pClock: IReferenceClock): HResult; stdcall; + function GetSyncSource(out pClock: IReferenceClock): HResult; stdcall; + end; + + _FilterInfo = record + achName : array[0..127] of WCHAR; + pGraph : IFilterGraph; + end; + {$EXTERNALSYM _FilterInfo} + FILTER_INFO = _FilterInfo; + {$EXTERNALSYM FILTER_INFO} + TFilterInfo = _FilterInfo; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IBaseFilter;'} + {$EXTERNALSYM IBaseFilter} + IBaseFilter = interface(IMediaFilter) + ['{56A86895-0AD4-11CE-B03A-0020AF0BA770}'] + (*** IBaseFilter methods ***) + function EnumPins(out ppEnum: IEnumPins): HResult; stdcall; + function FindPin(Id: PWideChar; out ppPin: IPin): HResult; stdcall; + function QueryFilterInfo(out pInfo: TFilterInfo): HResult; stdcall; + function JoinFilterGraph(pGraph: IFilterGraph; pName: PWideChar): HResult; stdcall; + function QueryVendorInfo(out pVendorInfo: PWideChar): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IReferenceClock2;'} + {$EXTERNALSYM IReferenceClock2} + IReferenceClock2 = interface(IReferenceClock) + ['{36B73885-C2C8-11CF-8B46-00805F6CEF60}'] + (*** IReferenceClock2 methods ***) + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IMediaSample;'} + {$EXTERNALSYM IMediaSample} + IMediaSample = interface(IUnknown) + ['{56A8689A-0AD4-11CE-B03A-0020AF0BA770}'] + (*** IMediaSample methods ***) + function GetPointer(out ppBuffer: PBYTE): HResult; stdcall; + function GetSize: Longint; stdcall; + function GetTime(out pTimeStart, pTimeEnd: TReferenceTime): HResult; stdcall; + function SetTime(pTimeStart, pTimeEnd: PReferenceTime): HResult; stdcall; + function IsSyncPoint: HResult; stdcall; + function SetSyncPoint(bIsSyncPoint: BOOL): HResult; stdcall; + function IsPreroll: HResult; stdcall; + function SetPreroll(bIsPreroll: BOOL): HResult; stdcall; + function GetActualDataLength: Longint; stdcall; + function SetActualDataLength(lLen: Longint): HResult; stdcall; + function GetMediaType(out ppMediaType: PAMMediaType): HResult; stdcall; + function SetMediaType(var pMediaType: TAMMediaType): HResult; stdcall; + function IsDiscontinuity: HResult; stdcall; + function SetDiscontinuity(bDiscontinuity: BOOL): HResult; stdcall; + function GetMediaTime(out pTimeStart, pTimeEnd: int64): HResult; stdcall; + function SetMediaTime(pTimeStart, pTimeEnd: Pint64): HResult; stdcall; + end; + +const + AM_SAMPLE_SPLICEPOINT = $1; + {$EXTERNALSYM AM_SAMPLE_SPLICEPOINT} + AM_SAMPLE_PREROLL = $2; + {$EXTERNALSYM AM_SAMPLE_PREROLL} + AM_SAMPLE_DATADISCONTINUITY = $4; + {$EXTERNALSYM AM_SAMPLE_DATADISCONTINUITY} + AM_SAMPLE_TYPECHANGED = $8; + {$EXTERNALSYM AM_SAMPLE_TYPECHANGED} + AM_SAMPLE_TIMEVALID = $10; + {$EXTERNALSYM AM_SAMPLE_TIMEVALID} + AM_SAMPLE_TIMEDISCONTINUITY = $40; + {$EXTERNALSYM AM_SAMPLE_TIMEDISCONTINUITY} + AM_SAMPLE_FLUSH_ON_PAUSE = $80; + {$EXTERNALSYM AM_SAMPLE_FLUSH_ON_PAUSE} + AM_SAMPLE_STOPVALID = $100; + {$EXTERNALSYM AM_SAMPLE_STOPVALID} + AM_SAMPLE_ENDOFSTREAM = $200; + {$EXTERNALSYM AM_SAMPLE_ENDOFSTREAM} + AM_STREAM_MEDIA = 0; + {$EXTERNALSYM AM_STREAM_MEDIA} + AM_STREAM_CONTROL = 1; + {$EXTERNALSYM AM_STREAM_CONTROL} + +type + PAMSample2Properties = ^TAMSample2Properties; + tagAM_SAMPLE2_PROPERTIES = record + cbData: DWORD; + dwTypeSpecificFlags : DWORD; + dwSampleFlags : DWORD; + lActual : Longint; + tStart : Reference_Time; + tStop : Reference_Time; + dwStreamId : DWORD; + pMediaType : PAMMediaType; + pbBuffer : Pointer; + cbBuffer : Longint; + end; + {$EXTERNALSYM tagAM_SAMPLE2_PROPERTIES} + AM_SAMPLE2_PROPERTIES = tagAM_SAMPLE2_PROPERTIES; + {$EXTERNALSYM AM_SAMPLE2_PROPERTIES} + TAMSample2Properties = tagAM_SAMPLE2_PROPERTIES; + +type + {$HPPEMIT 'typedef System::DelphiInterface _di_IMediaSample2;'} + {$EXTERNALSYM IMediaSample2} + IMediaSample2 = interface(IMediaSample) + ['{36B73884-C2C8-11CF-8B46-00805F6CEF60}'] + (*** IMediaSample2 methods ***) + function GetProperties(cbProperties: DWORD; out pbProperties): HResult; stdcall; + function SetProperties(cbProperties: DWORD; const pbProperties): HResult; stdcall; + end; + +const + AM_GBF_PREVFRAMESKIPPED = 1; + {$EXTERNALSYM AM_GBF_PREVFRAMESKIPPED} + AM_GBF_NOTASYNCPOINT = 2; + {$EXTERNALSYM AM_GBF_NOTASYNCPOINT} + AM_GBF_NOWAIT = 4; + {$EXTERNALSYM AM_GBF_NOWAIT} + AM_GBF_NODDSURFACELOCK = 8; + {$EXTERNALSYM AM_GBF_NODDSURFACELOCK} + +type + + {$HPPEMIT 'typedef System::DelphiInterface _di_IMemAllocator;'} + {$EXTERNALSYM IMemAllocator} + IMemAllocator = interface(IUnknown) + ['{56A8689C-0AD4-11CE-B03A-0020AF0BA770}'] + (*** IMemAllocator methods ***) + function SetProperties(var pRequest: TAllocatorProperties; + out pActual: TAllocatorProperties): HResult; stdcall; + function GetProperties(out pProps: TAllocatorProperties): HResult; stdcall; + function Commit: HResult; stdcall; + function Decommit: HResult; stdcall; + function GetBuffer(out ppBuffer: IMediaSample; + pStartTime, pEndTime: PReferenceTime; dwFlags: DWORD): HResult; stdcall; + function ReleaseBuffer(pBuffer: IMediaSample): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IMemAllocatorNotifyCallbackTemp;'} + {$EXTERNALSYM IMemAllocatorNotifyCallbackTemp} + IMemAllocatorNotifyCallbackTemp = interface(IUnknown) + ['{92980b30-c1de-11d2-abf5-00a0c905f375}'] + (*** IMemAllocatorNotifyCallbackTemp methods ***) + function NotifyRelease: HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IMemAllocatorCallbackTemp;'} + {$EXTERNALSYM IMemAllocatorCallbackTemp} + IMemAllocatorCallbackTemp = interface(IMemAllocator) + ['{379a0cf0-c1de-11d2-abf5-00a0c905f375}'] + (*** IMemAllocatorCallbackTemp methods ***) + function SetNotify(pNotify: IMemAllocatorNotifyCallbackTemp): HResult; stdcall; + function GetFreeCount(out plBuffersFree: LongInt): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IMemInputPin;'} + {$EXTERNALSYM IMemInputPin} + IMemInputPin = interface(IUnknown) + ['{56A8689D-0AD4-11CE-B03A-0020AF0BA770}'] + (*** IMemInputPin methods ***) + function GetAllocator(out ppAllocator: IMemAllocator): HResult; stdcall; + function NotifyAllocator(pAllocator: IMemAllocator; bReadOnly: BOOL): HResult; stdcall; + function GetAllocatorRequirements(out pProps: TAllocatorProperties): HResult; stdcall; + function Receive(pSample: IMediaSample): HResult; stdcall; + function ReceiveMultiple(var pSamples: IMediaSample; nSamples: Longint; + out nSamplesProcessed: Longint): HResult; stdcall; + function ReceiveCanBlock: HResult; stdcall; + end; + + //Deprecated Interface + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMovieSetup;'} + {$EXTERNALSYM IAMovieSetup} + IAMovieSetup = interface(IUnknown) + ['{A3D8CEC0-7E5A-11CF-BBC5-00805F6CEF20}'] + (*** IAMovieSetup methods ***) + function Register: HResult; stdcall; + function Unregister: HResult; stdcall; + end; + +const + AM_SEEKING_NoPositioning = 0; + {$EXTERNALSYM AM_SEEKING_NoPositioning} + AM_SEEKING_AbsolutePositioning = $1; + {$EXTERNALSYM AM_SEEKING_AbsolutePositioning} + AM_SEEKING_RelativePositioning = $2; + {$EXTERNALSYM AM_SEEKING_RelativePositioning} + AM_SEEKING_IncrementalPositioning = $3; + {$EXTERNALSYM AM_SEEKING_IncrementalPositioning} + AM_SEEKING_PositioningBitsMask = $3; + {$EXTERNALSYM AM_SEEKING_PositioningBitsMask} + AM_SEEKING_SeekToKeyFrame = $4; + {$EXTERNALSYM AM_SEEKING_SeekToKeyFrame} + AM_SEEKING_ReturnTime = $8; + {$EXTERNALSYM AM_SEEKING_ReturnTime} + AM_SEEKING_Segment = $10; + {$EXTERNALSYM AM_SEEKING_Segment} + AM_SEEKING_NoFlush = $20; + {$EXTERNALSYM AM_SEEKING_NoFlush} + + AM_SEEKING_CanSeekAbsolute = $1; + {$EXTERNALSYM AM_SEEKING_CanSeekAbsolute} + AM_SEEKING_CanSeekForwards = $2; + {$EXTERNALSYM AM_SEEKING_CanSeekForwards} + AM_SEEKING_CanSeekBackwards = $4; + {$EXTERNALSYM AM_SEEKING_CanSeekBackwards} + AM_SEEKING_CanGetCurrentPos = $8; + {$EXTERNALSYM AM_SEEKING_CanGetCurrentPos} + AM_SEEKING_CanGetStopPos = $10; + {$EXTERNALSYM AM_SEEKING_CanGetStopPos} + AM_SEEKING_CanGetDuration = $20; + {$EXTERNALSYM AM_SEEKING_CanGetDuration} + AM_SEEKING_CanPlayBackwards = $40; + {$EXTERNALSYM AM_SEEKING_CanPlayBackwards} + AM_SEEKING_CanDoSegments = $80; + {$EXTERNALSYM AM_SEEKING_CanDoSegments} + AM_SEEKING_Source = $100; + {$EXTERNALSYM AM_SEEKING_Source} + +type + {$HPPEMIT 'typedef System::DelphiInterface _di_IMediaSeeking;'} + {$EXTERNALSYM IMediaSeeking} + IMediaSeeking = interface(IUnknown) + ['{36B73880-C2C8-11CF-8B46-00805F6CEF60}'] + (*** IMediaSeeking methods ***) + function GetCapabilities(out pCapabilities: DWORD): HResult; stdcall; + function CheckCapabilities(var pCapabilities: DWORD): HResult; stdcall; + function IsFormatSupported(const pFormat: TGUID): HResult; stdcall; + function QueryPreferredFormat(out pFormat: TGUID): HResult; stdcall; + function GetTimeFormat(out pFormat: TGUID): HResult; stdcall; + function IsUsingTimeFormat(const pFormat: TGUID): HResult; stdcall; + function SetTimeFormat(const pFormat: TGUID): HResult; stdcall; + function GetDuration(out pDuration: int64): HResult; stdcall; + function GetStopPosition(out pStop: int64): HResult; stdcall; + function GetCurrentPosition(out pCurrent: int64): HResult; stdcall; + function ConvertTimeFormat(out pTarget: int64; pTargetFormat: PGUID; + Source: int64; pSourceFormat: PGUID): HResult; stdcall; + function SetPositions(var pCurrent: int64; dwCurrentFlags: DWORD; + var pStop: int64; dwStopFlags: DWORD): HResult; stdcall; + function GetPositions(out pCurrent, pStop: int64): HResult; stdcall; + function GetAvailable(out pEarliest, pLatest: int64): HResult; stdcall; + function SetRate(dRate: double): HResult; stdcall; + function GetRate(out pdRate: double): HResult; stdcall; + function GetPreroll(out pllPreroll: int64): HResult; stdcall; + end; + +const + AM_MEDIAEVENT_NONOTIFY = $01; + {$EXTERNALSYM AM_MEDIAEVENT_NONOTIFY} + +type + PRegFilter = ^TRegFilter; + REGFILTER = record + Clsid: TGUID; + Name : LPWSTR; + end; + {$EXTERNALSYM REGFILTER} + TRegFilter = REGFILTER; + + //Deprecated Interface + {$HPPEMIT 'typedef System::DelphiInterface _di_IEnumRegFilters;'} + {$EXTERNALSYM IEnumRegFilters} + IEnumRegFilters = interface(IUnknown) + ['{56A868A4-0AD4-11CE-B03A-0020AF0BA770}'] + (*** IEnumRegFilters methods ***) + function Next(cFilters: ULONG; out apRegFilter: TRegFilter; + out pcFetched: ULONG): HResult; stdcall; + function Skip(cFilters: ULONG): HResult; stdcall; + function Reset: HResult; stdcall; + function Clone(out ppEnum: IEnumRegFilters): HResult; stdcall; + end; + +const + MERIT_PREFERRED = $800000; + {$EXTERNALSYM MERIT_PREFERRED} + MERIT_NORMAL = $600000; + {$EXTERNALSYM MERIT_NORMAL} + MERIT_UNLIKELY = $400000; + {$EXTERNALSYM MERIT_UNLIKELY} + MERIT_DO_NOT_USE = $200000; + {$EXTERNALSYM MERIT_DO_NOT_USE} + MERIT_SW_COMPRESSOR = $100000; + {$EXTERNALSYM MERIT_SW_COMPRESSOR} + MERIT_HW_COMPRESSOR = $100050; + {$EXTERNALSYM MERIT_HW_COMPRESSOR} + +type + + //Deprecated Interface + {$HPPEMIT 'typedef System::DelphiInterface _di_IFilterMapper;'} + {$EXTERNALSYM IFilterMapper} + IFilterMapper = interface(IUnknown) + ['{56A868A3-0AD4-11CE-B03A-0020AF0BA770}'] + (*** IFilterMapper methods ***) + function RegisterFilter(clsid: TGUID; Name: LPCWSTR; dwMerit: DWORD):HResult; stdcall; + function RegisterFilterInstance(clsid: TGUID; Name: LPCWSTR; out MRId: TGUID): HResult; stdcall; + function RegisterPin(Filter: TGUID; Name: LPCWSTR; + bRendered, bOutput, bZero, bMany: BOOL; ConnectsToFilter: TGUID; + ConnectsToPin: PWideChar): HResult; stdcall; + function RegisterPinType(clsFilter: TGUID; strName: LPCWSTR; + clsMajorType, clsSubType: TGUID): HResult; stdcall; + function UnregisterFilter(Filter: TGUID): HResult; stdcall; + function UnregisterFilterInstance(MRId: TGUID): HResult; stdcall; + function UnregisterPin(Filter: TGUID; Name: LPCWSTR): HResult; stdcall; + function EnumMatchingFilters(out ppEnum: IEnumRegFilters; dwMerit: DWORD; + bInputNeeded: BOOL; const clsInMaj, clsInSub: TGUID; + bRender, bOututNeeded: BOOL; const clsOutMaj, clsOutSub: TGUID): HResult; stdcall; + end; + + PRegPinTypes = ^TRegPinTypes; + REGPINTYPES = record + clsMajorType: PGUID; + clsMinorType: PGUID; + end; + {$EXTERNALSYM REGPINTYPES} + TRegPinTypes = REGPINTYPES; + + PRegFilterPins = ^TRegFilterPins; + REGFILTERPINS = record + strName : PWideChar; + bRendered : BOOL; + bOutput : BOOL; + bZero : BOOL; + bMany : BOOL; + oFilter : PGUID; + strConnectsToPin : PWideChar; + nMediaTypes : LongWord; + lpMediaType : PRegPinTypes; + end; + {$EXTERNALSYM REGFILTERPINS} + TRegFilterPins = REGFILTERPINS; + + PRegPinMedium = ^TRegPinMedium; + REGPINMEDIUM = record + clsMedium: TGUID; + dw1: DWORD; + dw2: DWORD; + end; + {$EXTERNALSYM REGPINMEDIUM} + TRegPinMedium = REGPINMEDIUM; + +const + REG_PINFLAG_B_ZERO = $1; + {$EXTERNALSYM REG_PINFLAG_B_ZERO} + REG_PINFLAG_B_RENDERER = $2; + {$EXTERNALSYM REG_PINFLAG_B_RENDERER} + REG_PINFLAG_B_MANY = $4; + {$EXTERNALSYM REG_PINFLAG_B_MANY} + REG_PINFLAG_B_OUTPUT = $8; + {$EXTERNALSYM REG_PINFLAG_B_OUTPUT} + +type + PRegFilterPins2 = ^TRegFilterPins2; + REGFILTERPINS2 = record + dwFlags : DWORD; + cInstances : UINT; + nMediaTypes : UINT; + lpMediaType : PRegPinTypes; + nMediums : UINT; + lpMedium : PRegPinMedium; + clsPinCategory : PGUID; + end; + {$EXTERNALSYM REGFILTERPINS2} + TRegFilterPins2 = REGFILTERPINS2; + + PRegFilter2 = ^TRegFilter2; + REGFILTER2 = record + dwVersion: DWORD; + dwMerit: DWORD; + case Integer of + 0: ( + cPins: ULONG; + rgPins: PRegFilterPins; + ); + 1: ( + cPins2: ULONG; + rgPins2: PRegFilterPins2; + ); + end; + {$EXTERNALSYM REGFILTER2} + TRegFilter2 = REGFILTER2; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IFilterMapper2;'} + {$EXTERNALSYM IFilterMapper2} + IFilterMapper2 = interface(IUnknown) + ['{B79BB0B0-33C1-11D1-ABE1-00A0C905F375}'] + (*** IFilterMapper2 methods ***) + function CreateCategory(const clsidCategory: TGUID; dwCategoryMerit: DWORD; + Description: PWideChar): HResult; stdcall; + function UnregisterFilter(const pclsidCategory: TGUID; + szInstance: PWideChar; const Filter: TGUID): HResult; stdcall; + function RegisterFilter(const clsidFilter: TGUID; Name: PWideChar; + ppMoniker: IMoniker; pclsidCategory: PGUID; + szInstance: PWideChar; const prf2: TRegFilter2): HResult; stdcall; + function EnumMatchingFilters(out ppEnum: IEnumMoniker; dwFlags: DWORD; bExactMatch: BOOL; + dwMerit: DWORD; bInputNeeded: BOOL; cInputTypes: DWORD; pInputTypes: PGUID; + pMedIn: PREGPINMEDIUM; pPinCategoryIn: PGUID; bRender, bOutputNeeded: BOOL; + cOutputTypes: DWORD; pOutputTypes: PGUID; pMedOut: PRegPinMedium; + pPinCategoryOut: PGUID): HResult; stdcall; + end; + + tagQualityMessageType = ( + Famine, + Flood + ); + {$EXTERNALSYM tagQualityMessageType} + QualityMessageType = tagQualityMessageType; + {$EXTERNALSYM QualityMessageType} + TQualityMessageType = QualityMessageType; + + PQuality = ^TQuality; + tagQuality = record + Typ : QualityMessageType; + Proportion : Longint; + Late : Reference_Time; + TimeStamp : Reference_Time; + end; + {$EXTERNALSYM tagQuality} + Quality = tagQuality; + {$EXTERNALSYM Quality} + TQuality = tagQuality; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IQualityControl;'} + {$EXTERNALSYM IQualityControl} + IQualityControl = interface(IUnknown) + ['{56A868A5-0AD4-11CE-B03A-0020AF0BA770}'] + (*** IQualityControl methods ***) + function Notify(pSelf: IBaseFilter; q: TQuality): HResult; stdcall; + function SetSink(piqc: IQualityControl): HResult; stdcall; + end; + +const + CK_NOCOLORKEY = $0; + {$EXTERNALSYM CK_NOCOLORKEY} + CK_INDEX = $1; + {$EXTERNALSYM CK_INDEX} + CK_RGB = $2; + {$EXTERNALSYM CK_RGB} + +type + PColorKey = ^TColorKey; + tagCOLORKEY = record + KeyType : DWORD; + PaletteIndex : DWORD; + LowColorValue : COLORREF; + HighColorValue : COLORREF; + end; + {$EXTERNALSYM tagCOLORKEY} + COLORKEY = tagCOLORKEY; + {$EXTERNALSYM COLORKEY} + TColorKey = tagCOLORKEY; + +const + ADVISE_NONE = 0; + {$EXTERNALSYM ADVISE_NONE} + ADVISE_CLIPPING = $1; + {$EXTERNALSYM ADVISE_CLIPPING} + ADVISE_PALETTE = $2; + {$EXTERNALSYM ADVISE_PALETTE} + ADVISE_COLORKEY = $4; + {$EXTERNALSYM ADVISE_COLORKEY} + ADVISE_POSITION = $8; + {$EXTERNALSYM ADVISE_POSITION} + + ADVISE_ALL = ADVISE_CLIPPING or ADVISE_PALETTE or ADVISE_COLORKEY or ADVISE_POSITION; + {$EXTERNALSYM ADVISE_ALL} + +type + {$HPPEMIT 'typedef System::DelphiInterface _di_IOverlayNotify;'} + {$EXTERNALSYM IOverlayNotify} + IOverlayNotify = interface(IUnknown) + ['{56A868A0-0AD4-11CE-B03A-0020AF0BA770}'] + (*** IOverlayNotify methods ***) + function OnPaletteChange(dwColors: DWORD; const pPalette: PPALETTEENTRY): HResult; stdcall; + function OnClipChange(const pSourceRect, pDestinationRect: TRect; + const pRgnData: TRgnData): HResult; stdcall; + function OnColorKeyChange(const pColorKey: TColorKey): HResult; stdcall; + function OnPositionChange(const pSourceRect, pDestinationRect: TRect): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IOverlayNotify2;'} + {$EXTERNALSYM IOverlayNotify2} + IOverlayNotify2 = interface(IOverlayNotify) + ['{680EFA10-D535-11D1-87C8-00A0C9223196}'] + (*** IOverlayNotify2 methods ***) + function OnDisplayChange(var hMonitor: HMONITOR ): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IOverlay;'} + {$EXTERNALSYM IOverlay} + IOverlay = interface(IUnknown) + ['{56A868A1-0AD4-11CE-B03A-0020AF0BA770}'] + (*** IOverlay methods ***) + function GetPalette(out pdwColors: DWORD; out ppPalette: PPALETTEENTRY): HResult; stdcall; + function SetPalette(dwColors: DWORD; var pPalette: PaletteEntry): HResult; stdcall; + function GetDefaultColorKey(out pColorKey: TColorKey): HResult; stdcall; + function GetColorKey(out pColorKey: TColorKey): HResult; stdcall; + function SetColorKey(var pColorKey: TColorKey): HResult; stdcall; + function GetWindowHandle(out pHwnd: HWND): HResult; stdcall; + function GetClipList(out pSourceRect, pDestinationRect: TRect; + out ppRgnData: PRgnData): HResult; stdcall; + function GetVideoPosition(out pSourceRect, pDestinationRect: TRect): HResult; stdcall; + function Advise(pOverlayNotify: IOverlayNotify; dwInterests: DWORD): HResult; stdcall; + function Unadvise: HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IMediaEventSink;'} + {$EXTERNALSYM IMediaEventSink} + IMediaEventSink = interface(IUnknown) + ['{56A868A2-0AD4-11CE-B03A-0020AF0BA770}'] + (*** IMediaEventSink methods ***) + function Notify(EventCode, EventParam1, EventParam2: Longint): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IFileSourceFilter;'} + {$EXTERNALSYM IFileSourceFilter} + IFileSourceFilter = interface(IUnknown) + ['{56A868A6-0AD4-11CE-B03A-0020AF0BA770}'] + (*** IFileSourceFilter methods ***) + function Load(pszFileName: PWCHAR; const pmt: PAMMediaType): HResult; stdcall; + function GetCurFile(out ppszFileName: PWideChar; pmt: PAMMediaType): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IFileSinkFilter;'} + {$EXTERNALSYM IFileSinkFilter} + IFileSinkFilter = interface(IUnknown) + ['{A2104830-7C70-11CF-8BCE-00AA00A3F1A6}'] + (*** IFileSinkFilter methods ***) + function SetFileName(pszFileName: PWideChar; pmt: PAMMediaType): HResult; stdcall; + function GetCurFile(out ppszFileName: PWideChar; pmt: PAMMediaType): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IFileSinkFilter2;'} + {$EXTERNALSYM IFileSinkFilter2} + IFileSinkFilter2 = interface(IFileSinkFilter) + ['{00855B90-CE1B-11D0-BD4F-00A0C911CE86}'] + (*** IFileSinkFilter2 methods ***) + function SetMode(dwFlags: DWORD): HResult; stdcall; + function GetMode(out pdwFlags: DWORD): HResult; stdcall; + end; + + AM_FILESINK_FLAGS = ( + {$IFNDEF COMPILER6_UP} + AM_FILE_INVALID_0 {= 0}, + AM_FILE_OVERWRITE {= 1} + {$ELSE} + AM_FILE_OVERWRITE = 1 + {$ENDIF} + ); + {$EXTERNALSYM AM_FILESINK_FLAGS} + TAMFileSinkFlags = AM_FILESINK_FLAGS; + + +// Very old !!!!! +// PAsyncIOReq = ^TAsyncIOReq; +// TAsyncIOReq = record +// engine: array[0..3] of DWORD; +// lpv: Pointer; +// cb: DWORD; +// dwError: DWORD; +// cbDone: DWORD; +// liPos: TLargeInteger; +// hEvent: DWORD; +// dwUser: DWORD; +// end; + +// IFileAsyncIO = interface(IUnknown) +// ['{56A868A7-0AD4-11CE-B03A-0020AF0BA770}'] +// function QueryAlignment(out pdwAlign: DWORD): HResult; stdcall; +// function Read(const pReq: TAsyncIOReq): HResult; stdcall; +// function Write(const pReq: TAsyncIOReq): HResult; stdcall; +// function WaitForNext(out ppReq: PAsyncIOReq; +// dwTimeout: DWORD): HResult; stdcall; +// function WaitForSpecific(out pReq: TAsyncIOReq; +// dwTimeout: DWORD): HResult; stdcall; +// function DiscardPending: HResult; stdcall; +// function Flush: HResult; stdcall; +// end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IGraphBuilder;'} + {$EXTERNALSYM IGraphBuilder} + IGraphBuilder = interface(IFilterGraph) + ['{56A868A9-0AD4-11CE-B03A-0020AF0BA770}'] + (*** IGraphBuilder methods ***) + function Connect(ppinOut, ppinIn: IPin): HResult; stdcall; + function Render(ppinOut: IPin): HResult; stdcall; + function RenderFile(lpcwstrFile, lpcwstrPlayList: PWideChar): HResult; stdcall; + function AddSourceFilter(lpcwstrFileName, lpcwstrFilterName: LPCWSTR; + out ppFilter: IBaseFilter): HResult; stdcall; + function SetLogFile(hFile: THandle): HResult; stdcall; + function Abort: HResult; stdcall; + function ShouldOperationContinue: HResult; stdcall; + end; + + IAMCopyCaptureFileProgress = interface; + + //Deprecated Interface + {$HPPEMIT 'typedef System::DelphiInterface _di_ICaptureGraphBuilder;'} + {$EXTERNALSYM ICaptureGraphBuilder} + ICaptureGraphBuilder = interface(IUnknown) + ['{BF87B6E0-8C27-11D0-B3F0-00AA003761C5}'] + (*** ICaptureGraphBuilder methods ***) + function SetFiltergraph(pfg: IGraphBuilder): HResult; stdcall; + function GetFiltergraph(out ppfg: IGraphBuilder): HResult; stdcall; + function SetOutputFileName(const pType: TGUID; lpstrFile: PWCHAR; + out ppf: IBaseFilter; out ppSink: IFileSinkFilter): HResult; stdcall; + function FindInterface(pCategory: PGUID; pf: IBaseFilter; + const riid: TGUID; out ppint): HResult; stdcall; + function RenderStream(pCategory: PGUID; pSource: IUnknown; + pfCompressor, pfRenderer: IBaseFilter): HResult; stdcall; + function ControlStream(pCategory: PGUID; pFilter: IBaseFilter; + pstart, pstop: PReferenceTime; wStartCookie, wStopCookie: WORD): HResult; stdcall; + function AllocCapFile(lpstr: PWCHAR; dwlSize: int64): HResult; stdcall; + function CopyCaptureFile(lpwstrOld, lpwstrNew: PWCHAR; fAllowEscAbort: Integer; + pCallback: IAMCopyCaptureFileProgress): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_ICaptureGraphBuilder2;'} + {$EXTERNALSYM ICaptureGraphBuilder2} + ICaptureGraphBuilder2 = interface(IUnknown) + ['{93E5A4E0-2D50-11d2-ABFA-00A0C9C6E38D}'] + (*** ICaptureGraphBuilder2 methods ***) + function SetFiltergraph(pfg: IGraphBuilder): HResult; stdcall; + function GetFiltergraph(out ppfg: IGraphBuilder): HResult; stdcall; + function SetOutputFileName(const pType: TGUID; lpstrFile: PWCHAR; out ppf: IBaseFilter; out ppSink: IFileSinkFilter): HResult; stdcall; + function FindInterface(pCategory, pType: PGUID; pf: IBaseFilter; const riid: TGUID; out ppint): HResult; stdcall; + function RenderStream(pCategory, pType: PGUID; pSource: IUnknown; pfCompressor, pfRenderer: IBaseFilter): HResult; stdcall; + function ControlStream(pCategory, pType: PGUID; pFilter: IBaseFilter; pstart, pstop: PReferenceTime; wStartCookie, wStopCookie: WORD ): HResult; stdcall; + function AllocCapFile(lpstr: PWCHAR; dwlSize: int64): HResult; stdcall; + function CopyCaptureFile(lpwstrOld, lpwstrNew: PWCHAR; fAllowEscAbort: Integer; pCallback: IAMCopyCaptureFileProgress): HResult; stdcall; + function FindPin(pSource: IUnknown; pindir: TPINDIRECTION; const pCategory, pType: PGUID; fUnconnected: BOOL; num: integer; out ppPin: IPin): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMCopyCaptureFileProgress;'} + {$EXTERNALSYM IAMCopyCaptureFileProgress} + IAMCopyCaptureFileProgress = interface(IUnknown) + ['{670D1D20-A068-11D0-B3F0-00AA003761C5}'] + (*** IAMCopyCaptureFileProgress methods ***) + function Progress(iProgress: Integer): HResult; stdcall; + end; + +const + AM_RENDEREX_RENDERTOEXISTINGRENDERERS = $01; + {$EXTERNALSYM AM_RENDEREX_RENDERTOEXISTINGRENDERERS} + +type + + {$HPPEMIT 'typedef System::DelphiInterface _di_IFilterGraph2;'} + {$EXTERNALSYM IFilterGraph2} + IFilterGraph2 = interface(IGraphBuilder) + ['{36B73882-C2C8-11CF-8B46-00805F6CEF60}'] + (*** IFilterGraph2 methods ***) + function AddSourceFilterForMoniker(pMoniker: IMoniker; pCtx: IBindCtx; + lpcwstrFilterName: LPCWSTR; out ppFilter: IBaseFilter): HResult; stdcall; + function ReconnectEx(ppin: IPin; pmt: PAMMediaType): HResult; stdcall; + // Render a pin without adding any new renderers (pvContext = nil) + // not in the documentation ?? + function RenderEx(pPinOut: IPin; dwFlags: DWORD; pvContext: PDWORD): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IStreamBuilder;'} + {$EXTERNALSYM IStreamBuilder} + IStreamBuilder = interface(IUnknown) + ['{56A868BF-0AD4-11CE-B03A-0020AF0BA770}'] + (*** IStreamBuilder methods ***) + function Render(ppinOut: IPin; pGraph: IGraphBuilder): HResult; stdcall; + function Backout(ppinOut: IPin; pGraph: IGraphBuilder): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAsyncReader;'} + {$EXTERNALSYM IAsyncReader} + IAsyncReader = interface(IUnknown) + ['{56A868AA-0AD4-11CE-B03A-0020AF0BA770}'] + (*** IAsyncReader methods ***) + {nev: start} + function RequestAllocator(pPreferred: IMemAllocator; + pProps: PAllocatorProperties; out ppActual: IMemAllocator): HResult; stdcall; + {nev: end} + function Request(pSample: IMediaSample; dwUser: DWORD): HResult; stdcall; + function WaitForNext(dwTimeout: DWORD; out ppSample: IMediaSample; + out pdwUser: DWORD): HResult; stdcall; + function SyncReadAligned(pSample: IMediaSample): HResult; stdcall; + function SyncRead(llPosition: int64; lLength: Longint; pBuffer: Pbyte): HResult; stdcall; + function Length(out pTotal, pAvailable: int64): HResult; stdcall; + function BeginFlush: HResult; stdcall; + function EndFlush: HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IGraphVersion;'} + {$EXTERNALSYM IGraphVersion} + IGraphVersion = interface(IUnknown) + ['{56A868AB-0AD4-11CE-B03A-0020AF0BA770}'] + (*** IGraphVersion methods ***) + function QueryVersion(var pVersion: Longint): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IResourceConsumer;'} + {$EXTERNALSYM IResourceConsumer} + IResourceConsumer = interface(IUnknown) + ['{56A868AD-0AD4-11CE-B03A-0020AF0BA770}'] + (*** IResourceConsumer methods ***) + function AcquireResource(idResource: Longint): HResult; stdcall; + function ReleaseResource(idResource: Longint): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IResourceManager;'} + {$EXTERNALSYM IResourceManager} + IResourceManager = interface(IUnknown) + ['{56A868AC-0AD4-11CE-B03A-0020AF0BA770}'] + (*** IResourceManager methods ***) + function Register(pName: LPCWSTR; cResource: Longint; + out plToken: Longint): HResult; stdcall; + function RegisterGroup(pName: LPCWSTR; cResource: Longint; + palTokens: PLongint; out plToken: Longint): HResult; stdcall; + function RequestResource(idResource: Longint; pFocusObject: IUnknown; + pConsumer: IResourceConsumer): HResult; stdcall; + function NotifyAcquire(idResource: Longint; pConsumer: IResourceConsumer; + hr: HResult): HResult; stdcall; + function NotifyRelease(idResource: Longint; pConsumer: IResourceConsumer; + bStillWant: BOOL): HResult; stdcall; + function CancelRequest(idResource: Longint; pConsumer: IResourceConsumer): HResult; stdcall; + function SetFocus(pFocusObject: IUnknown): HResult; stdcall; + function ReleaseFocus(pFocusObject: IUnknown): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IDistributorNotify;'} + {$EXTERNALSYM IDistributorNotify} + IDistributorNotify = interface(IUnknown) + ['{56A868AF-0AD4-11CE-B03A-0020AF0BA770}'] + (*** IDistributorNotify methods ***) + function Stop: HResult; stdcall; + function Pause: HResult; stdcall; + function Run(tStart: TReferenceTime): HResult; stdcall; + function SetSyncSource(pClock: IReferenceClock): HResult; stdcall; + function NotifyGraphChange: HResult; stdcall; + end; + + AM_STREAM_INFO_FLAGS = {$IFDEF TYPE_IDENTITY}type {$ENDIF}DWord; + {$EXTERNALSYM AM_STREAM_INFO_FLAGS} + const + AM_STREAM_INFO_START_DEFINED = $1; + {$EXTERNALSYM AM_STREAM_INFO_START_DEFINED} + AM_STREAM_INFO_STOP_DEFINED = $2; + {$EXTERNALSYM AM_STREAM_INFO_STOP_DEFINED} + AM_STREAM_INFO_DISCARDING = $4; + {$EXTERNALSYM AM_STREAM_INFO_DISCARDING} + AM_STREAM_INFO_STOP_SEND_EXTRA = $10; + {$EXTERNALSYM AM_STREAM_INFO_STOP_SEND_EXTRA} + +type + PAMStreamInfo = ^TAMStreamInfo; + AM_STREAM_INFO = record + tStart : Reference_Time; + tStop : Reference_Time; + dwStartCookie : DWORD; + dwStopCookie : DWORD; + dwFlags : DWORD; + end; + {$EXTERNALSYM AM_STREAM_INFO} + TAMStreamInfo = AM_STREAM_INFO; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMStreamControl;'} + {$EXTERNALSYM IAMStreamControl} + IAMStreamControl = interface(IUnknown) + ['{36b73881-c2c8-11cf-8b46-00805f6cef60}'] + (*** IAMStreamControl methods ***) + function StartAt(ptStart: PReferenceTime; dwCookie: DWORD): HResult; stdcall; + function StopAt(ptStop: PReferenceTime; bSendExtra: BOOL; + dwCookie: DWORD): HResult; stdcall; + function GetInfo(out pInfo: TAMStreamInfo): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_ISeekingPassThru;'} + {$EXTERNALSYM ISeekingPassThru} + ISeekingPassThru = interface(IUnknown) + ['{36B73883-C2C8-11CF-8B46-00805F6CEF60}'] + (*** ISeekingPassThru methods ***) + function Init(bSupportRendering: BOOL; pPin: IPin): HResult; stdcall; + end; + + PVideoStreamConfigCaps = ^TVideoStreamConfigCaps; + _VIDEO_STREAM_CONFIG_CAPS = record + guid: TGUID; + VideoStandard : ULONG; + InputSize : TSize; + MinCroppingSize : TSize; + MaxCroppingSize : TSize; + CropGranularityX : Integer; + CropGranularityY : Integer; + CropAlignX : Integer; + CropAlignY : Integer; + MinOutputSize : TSize; + MaxOutputSize : TSize; + OutputGranularityX : Integer; + OutputGranularityY : Integer; + StretchTapsX : Integer; + StretchTapsY : Integer; + ShrinkTapsX : Integer; + ShrinkTapsY : Integer; + MinFrameInterval : Int64; + MaxFrameInterval : Int64; + MinBitsPerSecond : Longint; + MaxBitsPerSecond : Longint; + end; + {$EXTERNALSYM _VIDEO_STREAM_CONFIG_CAPS} + VIDEO_STREAM_CONFIG_CAPS = _VIDEO_STREAM_CONFIG_CAPS; + {$EXTERNALSYM VIDEO_STREAM_CONFIG_CAPS} + TVideoStreamConfigCaps = _VIDEO_STREAM_CONFIG_CAPS; + + PAudioStreamConfigCaps = ^TAudioStreamConfigCaps; + _AUDIO_STREAM_CONFIG_CAPS = record + guid: TGUID; + MinimumChannels : ULONG; + MaximumChannels : ULONG; + ChannelsGranularity : ULONG; + MinimumBitsPerSample : ULONG; + MaximumBitsPerSample : ULONG; + BitsPerSampleGranularity : ULONG; + MinimumSampleFrequency : ULONG; + MaximumSampleFrequency : ULONG; + SampleFrequencyGranularity : ULONG; + end; + {$EXTERNALSYM _AUDIO_STREAM_CONFIG_CAPS} + AUDIO_STREAM_CONFIG_CAPS = _AUDIO_STREAM_CONFIG_CAPS; + {$EXTERNALSYM AUDIO_STREAM_CONFIG_CAPS} + TAudioStreamConfigCaps = _AUDIO_STREAM_CONFIG_CAPS; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMStreamConfig;'} + {$EXTERNALSYM IAMStreamConfig} + IAMStreamConfig = interface(IUnknown) + ['{C6E13340-30AC-11d0-A18C-00A0C9118956}'] + (*** IAMStreamConfig methods ***) + function SetFormat(const pmt: TAMMediaType): HResult; stdcall; + function GetFormat(out ppmt: PAMMediaType): HResult; stdcall; + function GetNumberOfCapabilities(out piCount, piSize: Integer): HResult; stdcall; + function GetStreamCaps(iIndex: Integer; out ppmt: PAMMediaType; + out pSCC): HResult; stdcall; + end; + + InterleavingMode = ( + INTERLEAVE_NONE, + INTERLEAVE_CAPTURE, + INTERLEAVE_FULL, + INTERLEAVE_NONE_BUFFERED + ); + {$EXTERNALSYM InterleavingMode} + TInterleavingMode = InterleavingMode; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IConfigInterleaving;'} + {$EXTERNALSYM IConfigInterleaving} + IConfigInterleaving = interface(IUnknown) + ['{BEE3D220-157B-11d0-BD23-00A0C911CE86}'] + (*** IConfigInterleaving methods ***) + function put_Mode(mode: TInterleavingMode): HResult; stdcall; + function get_Mode(out pMode: TInterleavingMode): HResult; stdcall; + function put_Interleaving(prtInterleave, prtPreroll: PReferenceTime): HResult; stdcall; + function get_Interleaving(out prtInterleave, prtPreroll: TReferenceTime): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IConfigAviMux;'} + {$EXTERNALSYM IConfigAviMux} + IConfigAviMux = interface(IUnknown) + ['{5ACD6AA0-F482-11ce-8B67-00AA00A3F1A6}'] + (*** IConfigAviMux methods ***) + function SetMasterStream(iStream: Longint): HResult; stdcall; + function GetMasterStream(out pStream: Longint): HResult; stdcall; + function SetOutputCompatibilityIndex(fOldIndex: BOOL): HResult; stdcall; + function GetOutputCompatibilityIndex(out pfOldIndex: BOOL): HResult; stdcall; + end; + +const + CompressionCaps_CanQuality = $1; + {$EXTERNALSYM CompressionCaps_CanQuality} + CompressionCaps_CanCrunch = $2; + {$EXTERNALSYM CompressionCaps_CanCrunch} + CompressionCaps_CanKeyFrame = $4; + {$EXTERNALSYM CompressionCaps_CanKeyFrame} + CompressionCaps_CanBFrame = $8; + {$EXTERNALSYM CompressionCaps_CanBFrame} + CompressionCaps_CanWindow = $10; + {$EXTERNALSYM CompressionCaps_CanWindow} + +type + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMVideoCompression;'} + {$EXTERNALSYM IAMVideoCompression} + IAMVideoCompression = interface(IUnknown) + ['{C6E13343-30AC-11d0-A18C-00A0C9118956}'] + (*** IAMVideoCompression methods ***) + function put_KeyFrameRate(KeyFrameRate: Longint): HResult; stdcall; + function get_KeyFrameRate(out pKeyFrameRate: Longint): HResult; stdcall; + function put_PFramesPerKeyFrame(PFramesPerKeyFrame: Longint): HResult; stdcall; + function get_PFramesPerKeyFrame(out pPFramesPerKeyFrame: Longint): HResult; stdcall; + function put_Quality(Quality: double): HResult; stdcall; + function get_Quality(out pQuality: double): HResult; stdcall; + function put_WindowSize(WindowSize: int64): HResult; stdcall; + function get_WindowSize(out pWindowSize: int64): HResult; stdcall; + function GetInfo(pszVersion: PWideChar; var pcbVersion: Integer; + pszDescription: PWideChar; var pcbDescription: Integer; + out pDefaultKeyFrameRate, pDefaultPFramesPerKey: Longint; + out pDefaultQuality: double; out pCapabilities: Longint): HResult; stdcall; + function OverrideKeyFrame(FrameNumber: Longint): HResult; stdcall; + function OverrideFrameSize(FrameNumber, Size: Longint): HResult; stdcall; + end; + +const + VfwCaptureDialog_Source = $1; + {$EXTERNALSYM VfwCaptureDialog_Source} + VfwCaptureDialog_Format = $2; + {$EXTERNALSYM VfwCaptureDialog_Format} + VfwCaptureDialog_Display = $4; + {$EXTERNALSYM VfwCaptureDialog_Display} + + VfwCompressDialog_Config = $1; + {$EXTERNALSYM VfwCompressDialog_Config} + VfwCompressDialog_About = $2; + {$EXTERNALSYM VfwCompressDialog_About} + + VfwCompressDialog_QueryConfig = $4; + {$EXTERNALSYM VfwCompressDialog_QueryConfig} + VfwCompressDialog_QueryAbout = $8; + {$EXTERNALSYM VfwCompressDialog_QueryAbout} + +type + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMVfwCaptureDialogs;'} + {$EXTERNALSYM IAMVfwCaptureDialogs} + IAMVfwCaptureDialogs = interface(IUnknown) + ['{D8D715A0-6E5E-11D0-B3F0-00AA003761C5}'] + (*** IAMVfwCaptureDialogs methods ***) + function HasDialog(iDialog: Integer): HResult; stdcall; + function ShowDialog(iDialog: Integer; hwnd: HWND): HResult; stdcall; + function SendDriverMessage(iDialog: Integer; uMsg: Integer; + dw1, dw2: Longint): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMVfwCompressDialogs;'} + {$EXTERNALSYM IAMVfwCompressDialogs} + IAMVfwCompressDialogs = interface(IUnknown) + ['{D8D715A3-6E5E-11D0-B3F0-00AA003761C5}'] + (*** IAMVfwCompressDialogs methods ***) + function ShowDialog(iDialog: Integer; hwnd: HWND): HResult; stdcall; + function GetState(out pState; var pcbState: Integer): HResult; stdcall; + function SetState(var pState; cbState: Integer): HResult; stdcall; + function SendDriverMessage(uMsg: Integer; dw1, dw2: Longint): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMDroppedFrames;'} + {$EXTERNALSYM IAMDroppedFrames} + IAMDroppedFrames = interface(IUnknown) + ['{C6E13344-30AC-11d0-A18C-00A0C9118956}'] + (*** IAMDroppedFrames methods ***) + function GetNumDropped(out plDropped: Longint): HResult; stdcall; + function GetNumNotDropped(out plNotDropped: Longint): HResult; stdcall; + function GetDroppedInfo(lSize: Longint; out plArray: Longint; + out plNumCopied: Longint): HResult; stdcall; + function GetAverageFrameSize(out plAverageSize: Longint): HResult; stdcall; + end; + +const + AMF_AUTOMATICGAIN = -1; + {$EXTERNALSYM AMF_AUTOMATICGAIN} + +type + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMAudioInputMixer;'} + {$EXTERNALSYM IAMAudioInputMixer} + IAMAudioInputMixer = interface(IUnknown) + ['{54C39221-8380-11d0-B3F0-00AA003761C5}'] + (*** IAMAudioInputMixer methods ***) + function put_Enable(fEnable: BOOL): HResult; stdcall; + function get_Enable(out pfEnable: BOOL): HResult; stdcall; + function put_Mono(fMono: BOOL): HResult; stdcall; + function get_Mono(out pfMono: BOOL): HResult; stdcall; + function put_MixLevel(Level: double): HResult; stdcall; + function get_MixLevel(out pLevel: double): HResult; stdcall; + function put_Pan(Pan: double): HResult; stdcall; + function get_Pan(out pPan: double): HResult; stdcall; + function put_Loudness(fLoudness: BOOL): HResult; stdcall; + function get_Loudness(out pfLoudness: BOOL): HResult; stdcall; + function put_Treble(Treble: double): HResult; stdcall; + function get_Treble(out pTreble: double): HResult; stdcall; + function get_TrebleRange(out pRange: double): HResult; stdcall; + function put_Bass(Bass: double): HResult; stdcall; + function get_Bass(out pBass: double): HResult; stdcall; + function get_BassRange(out pRange: double): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMBufferNegotiation;'} + {$EXTERNALSYM IAMBufferNegotiation} + IAMBufferNegotiation = interface(IUnknown) + ['{56ED71A0-AF5F-11D0-B3F0-00AA003761C5}'] + (*** IAMBufferNegotiation methods ***) + function SuggestAllocatorProperties(const pprop: TAllocatorProperties): HResult; stdcall; + function GetAllocatorProperties(var pprop: TAllocatorProperties): HResult; stdcall; + end; + +const + AnalogVideo_None = 0; + {$EXTERNALSYM AnalogVideo_None} + AnalogVideo_NTSC_M = $1; + {$EXTERNALSYM AnalogVideo_NTSC_M} + AnalogVideo_NTSC_M_J = $2; + {$EXTERNALSYM AnalogVideo_NTSC_M_J} + AnalogVideo_NTSC_433 = $4; + {$EXTERNALSYM AnalogVideo_NTSC_433} + AnalogVideo_PAL_B = $10; + {$EXTERNALSYM AnalogVideo_PAL_B} + AnalogVideo_PAL_D = $20; + {$EXTERNALSYM AnalogVideo_PAL_D} + AnalogVideo_PAL_G = $40; + {$EXTERNALSYM AnalogVideo_PAL_G} + AnalogVideo_PAL_H = $80; + {$EXTERNALSYM AnalogVideo_PAL_H} + AnalogVideo_PAL_I = $100; + {$EXTERNALSYM AnalogVideo_PAL_I} + AnalogVideo_PAL_M = $200; + {$EXTERNALSYM AnalogVideo_PAL_M} + AnalogVideo_PAL_N = $400; + {$EXTERNALSYM AnalogVideo_PAL_N} + AnalogVideo_PAL_60 = $800; + {$EXTERNALSYM AnalogVideo_PAL_60} + AnalogVideo_SECAM_B = $1000; + {$EXTERNALSYM AnalogVideo_SECAM_B} + AnalogVideo_SECAM_D = $2000; + {$EXTERNALSYM AnalogVideo_SECAM_D} + AnalogVideo_SECAM_G = $4000; + {$EXTERNALSYM AnalogVideo_SECAM_G} + AnalogVideo_SECAM_H = $8000; + {$EXTERNALSYM AnalogVideo_SECAM_H} + AnalogVideo_SECAM_K = $10000; + {$EXTERNALSYM AnalogVideo_SECAM_K} + AnalogVideo_SECAM_K1 = $20000; + {$EXTERNALSYM AnalogVideo_SECAM_K1} + AnalogVideo_SECAM_L = $40000; + {$EXTERNALSYM AnalogVideo_SECAM_L} + AnalogVideo_SECAM_L1 = $80000; + {$EXTERNALSYM AnalogVideo_SECAM_L1} + + AnalogVideo_NTSC_Mask = $00000007; + {$EXTERNALSYM AnalogVideo_NTSC_Mask} + AnalogVideo_PAL_Mask = $00000FF0; + {$EXTERNALSYM AnalogVideo_PAL_Mask} + AnalogVideo_SECAM_Mask = $000FF000; + {$EXTERNALSYM AnalogVideo_SECAM_Mask} + +type + tagTunerInputType =( + TunerInputCable, + TunerInputAntenna + ); + {$EXTERNALSYM tagTunerInputType} + TunerInputType = tagTunerInputType; + {$EXTERNALSYM TunerInputType} + TTunerInputType = TunerInputType; + + VideoCopyProtectionType = ( + VideoCopyProtectionMacrovisionBasic, + VideoCopyProtectionMacrovisionCBI + ); + {$EXTERNALSYM VideoCopyProtectionType} + TVideoCopyProtectionType = VideoCopyProtectionType; + + TPhysicalConnectorType = {$IFDEF TYPE_IDENTITY}type {$ENDIF} LongWord; + const + PhysConn_Video_Tuner = 1; + {$EXTERNALSYM PhysConn_Video_Tuner} + PhysConn_Video_Composite = PhysConn_Video_Tuner + 1; + {$EXTERNALSYM PhysConn_Video_Composite} + PhysConn_Video_SVideo = PhysConn_Video_Composite + 1; + {$EXTERNALSYM PhysConn_Video_SVideo} + PhysConn_Video_RGB = PhysConn_Video_SVideo + 1; + {$EXTERNALSYM PhysConn_Video_RGB} + PhysConn_Video_YRYBY = PhysConn_Video_RGB + 1; + {$EXTERNALSYM PhysConn_Video_YRYBY} + PhysConn_Video_SerialDigital = PhysConn_Video_YRYBY + 1; + {$EXTERNALSYM PhysConn_Video_SerialDigital} + PhysConn_Video_ParallelDigital = PhysConn_Video_SerialDigital + 1; + {$EXTERNALSYM PhysConn_Video_ParallelDigital} + PhysConn_Video_SCSI = PhysConn_Video_ParallelDigital + 1; + {$EXTERNALSYM PhysConn_Video_SCSI} + PhysConn_Video_AUX = PhysConn_Video_SCSI + 1; + {$EXTERNALSYM PhysConn_Video_AUX} + PhysConn_Video_1394 = PhysConn_Video_AUX + 1; + {$EXTERNALSYM PhysConn_Video_1394} + PhysConn_Video_USB = PhysConn_Video_1394 + 1; + {$EXTERNALSYM PhysConn_Video_USB} + PhysConn_Video_VideoDecoder = PhysConn_Video_USB + 1; + {$EXTERNALSYM PhysConn_Video_VideoDecoder} + PhysConn_Video_VideoEncoder = PhysConn_Video_VideoDecoder + 1; + {$EXTERNALSYM PhysConn_Video_VideoEncoder} + PhysConn_Video_SCART = PhysConn_Video_VideoEncoder + 1; + {$EXTERNALSYM PhysConn_Video_SCART} + PhysConn_Video_Black = PhysConn_Video_SCART + 1; + {$EXTERNALSYM PhysConn_Video_Black} + PhysConn_Audio_Tuner = $1000; + {$EXTERNALSYM PhysConn_Audio_Tuner} + PhysConn_Audio_Line = PhysConn_Audio_Tuner + 1; + {$EXTERNALSYM PhysConn_Audio_Line} + PhysConn_Audio_Mic = PhysConn_Audio_Line + 1; + {$EXTERNALSYM PhysConn_Audio_Mic} + PhysConn_Audio_AESDigital = PhysConn_Audio_Mic + 1; + {$EXTERNALSYM PhysConn_Audio_AESDigital} + PhysConn_Audio_SPDIFDigital = PhysConn_Audio_AESDigital + 1; + {$EXTERNALSYM PhysConn_Audio_SPDIFDigital} + PhysConn_Audio_SCSI = PhysConn_Audio_SPDIFDigital + 1; + {$EXTERNALSYM PhysConn_Audio_SCSI} + PhysConn_Audio_AUX = PhysConn_Audio_SCSI + 1; + {$EXTERNALSYM PhysConn_Audio_AUX} + PhysConn_Audio_1394 = PhysConn_Audio_AUX + 1; + {$EXTERNALSYM PhysConn_Audio_1394} + PhysConn_Audio_USB = PhysConn_Audio_1394 + 1; + {$EXTERNALSYM PhysConn_Audio_USB} + PhysConn_Audio_AudioDecoder = PhysConn_Audio_USB + 1; + {$EXTERNALSYM PhysConn_Audio_AudioDecoder} + +type + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMAnalogVideoDecoder;'} + {$EXTERNALSYM IAMAnalogVideoDecoder} + IAMAnalogVideoDecoder = interface(IUnknown) + ['{C6E13350-30AC-11d0-A18C-00A0C9118956}'] + (*** IAMAnalogVideoDecoder methods ***) + function get_AvailableTVFormats(out lAnalogVideoStandard: Longint): HResult; stdcall; + function put_TVFormat(lAnalogVideoStandard: Longint): HResult; stdcall; + function get_TVFormat(out plAnalogVideoStandard: Longint): HResult; stdcall; + function get_HorizontalLocked(out plLocked: Longint): HResult; stdcall; + function put_VCRHorizontalLocking(lVCRHorizontalLocking: Longint): HResult; stdcall; + function get_VCRHorizontalLocking(out plVCRHorizontalLocking: Longint): HResult; stdcall; + function get_NumberOfLines(out plNumberOfLines: Longint): HResult; stdcall; + function put_OutputEnable(lOutputEnable: LongBool): HResult; stdcall; + function get_OutputEnable(out plOutputEnable: LongBool): HResult; stdcall; + end; + + tagVideoProcAmpProperty = ( + VideoProcAmp_Brightness, + VideoProcAmp_Contrast, + VideoProcAmp_Hue, + VideoProcAmp_Saturation, + VideoProcAmp_Sharpness, + VideoProcAmp_Gamma, + VideoProcAmp_ColorEnable, + VideoProcAmp_WhiteBalance, + VideoProcAmp_BacklightCompensation, + VideoProcAmp_Gain + ); + {$EXTERNALSYM tagVideoProcAmpProperty} + VideoProcAmpProperty = tagVideoProcAmpProperty; + {$EXTERNALSYM VideoProcAmpProperty} + TVideoProcAmpProperty = VideoProcAmpProperty; + + tagVideoProcAmpFlags = ( + {$IFNDEF COMPILER6_UP} + VideoProcAmp_Flags_INVALID_0, + VideoProcAmp_Flags_Manual, + VideoProcAmp_Flags_Auto + {$ELSE} + VideoProcAmp_Flags_Manual = 1, + VideoProcAmp_Flags_Auto + {$ENDIF} + ); + {$EXTERNALSYM tagVideoProcAmpFlags} + VideoProcAmpFlags = tagVideoProcAmpFlags; + {$EXTERNALSYM VideoProcAmpFlags} + TVideoProcAmpFlags = VideoProcAmpFlags; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMVideoProcAmp;'} + {$EXTERNALSYM IAMVideoProcAmp} + IAMVideoProcAmp = interface(IUnknown) + ['{C6E13360-30AC-11d0-A18C-00A0C9118956}'] + (*** IAMVideoProcAmp methods ***) + function GetRange(Property_:TVideoProcAmpProperty; out pMin, pMax, pSteppingDelta, + pDefault: Longint; out pCapsFlags: TVideoProcAmpFlags): HResult; stdcall; + function Set_(Property_: TVideoProcAmpProperty; lValue: Longint; + Flags: TVideoProcAmpFlags): HResult; stdcall; + function Get(Property_: TVideoProcAmpProperty; out lValue: Longint; + out Flags: TVideoProcAmpFlags): HResult; stdcall; + end; + + tagCameraControlProperty = ( + CameraControl_Pan, + CameraControl_Tilt, + CameraControl_Roll, + CameraControl_Zoom, + CameraControl_Exposure, + CameraControl_Iris, + CameraControl_Focus + ); + {$EXTERNALSYM tagCameraControlProperty} + CameraControlProperty = tagCameraControlProperty; + {$EXTERNALSYM CameraControlProperty} + TCameraControlProperty = CameraControlProperty; + + tagCameraControlFlags = ( + {$IFNDEF COMPILER6_UP} + CameraControl_Flags_INVALID_0, + CameraControl_Flags_Manual, + CameraControl_Flags_Auto + {$ELSE} + CameraControl_Flags_Manual = 1, + CameraControl_Flags_Auto + {$ENDIF} + ); + {$EXTERNALSYM tagCameraControlFlags} + CameraControlFlags = tagCameraControlFlags; + {$EXTERNALSYM CameraControlFlags} + TCameraControlFlags = CameraControlFlags; + + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMCameraControl;'} + {$EXTERNALSYM IAMCameraControl} + IAMCameraControl = interface(IUnknown) + ['{C6E13370-30AC-11d0-A18C-00A0C9118956}'] + (*** IAMCameraControl methods ***) + function GetRange(Property_: TCameraControlProperty; + out pMin, pMax, pSteppingDelta, pDefault, pCapsFlags: Longint): HResult; stdcall; + function Set_(Property_: TCameraControlProperty; lValue: Longint; + Flags: TCameraControlFlags): HResult; stdcall; + function Get(Property_: TCameraControlProperty; out lValue: Longint; + out Flags: TCameraControlFlags): HResult; stdcall; + end; + +const + VideoControlFlag_FlipHorizontal = $1; + {$EXTERNALSYM VideoControlFlag_FlipHorizontal} + VideoControlFlag_FlipVertical = $2; + {$EXTERNALSYM VideoControlFlag_FlipVertical} + VideoControlFlag_ExternalTriggerEnable = $4; + {$EXTERNALSYM VideoControlFlag_ExternalTriggerEnable} + VideoControlFlag_Trigger = $8; + {$EXTERNALSYM VideoControlFlag_Trigger} + +type + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMVideoControl;'} + {$EXTERNALSYM IAMVideoControl} + IAMVideoControl = interface(IUnknown) + ['{6a2e0670-28e4-11d0-a18c-00a0c9118956}'] + (*** IAMVideoControl methods ***) + function GetCaps(pPin: IPin; out pCapsFlags: Longint): HResult; stdcall; + function SetMode(pPin: IPin; Mode: Longint): HResult; stdcall; + function GetMode(pPin: IPin; out Mode: Longint): HResult; stdcall; + function GetCurrentActualFrameRate(pPin: IPin; out ActualFrameRate: Int64): HResult; stdcall; + function GetMaxAvailableFrameRate(pPin: IPin; iIndex: Longint; Dimensions: TSize; out MaxAvailableFrameRate: Int64): HResult; stdcall; + function GetFrameRateList(pPin: IPin; iIndex: Longint; Dimensions: TSize; out ListSize: Longint; out FrameRates: PInt64): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMCrossbar;'} + {$EXTERNALSYM IAMCrossbar} + IAMCrossbar = interface(IUnknown) + ['{C6E13380-30AC-11d0-A18C-00A0C9118956}'] + (*** IAMCrossbar methods ***) + function get_PinCounts(out OutputPinCount, InputPinCount: Longint): HResult; stdcall; + function CanRoute(OutputPinIndex, InputPinIndex: Longint): HResult; stdcall; + function Route(OutputPinIndex, InputPinIndex: Longint): HResult; stdcall; + function get_IsRoutedTo(OutputPinIndex: Longint; + out InputPinIndex: Longint): HResult; stdcall; + function get_CrossbarPinInfo(IsInputPin: BOOL; PinIndex: Longint; + out PinIndexRelated : longint; out PhysicalType: TPhysicalConnectorType): HResult; stdcall; + end; + +type + {$IFNDEF COMPILER6_UP} + tagAMTunerSubChannel = {$IFDEF TYPE_IDENTITY}type {$ENDIF} LongWord; + const + AMTUNER_SUBCHAN_NO_TUNE = -2; + {$EXTERNALSYM AMTUNER_SUBCHAN_NO_TUNE} + AMTUNER_SUBCHAN_DEFAULT = -1; + {$EXTERNALSYM AMTUNER_SUBCHAN_DEFAULT} + {$ELSE} + tagAMTunerSubChannel = ( + AMTUNER_SUBCHAN_NO_TUNE = -2, + AMTUNER_SUBCHAN_DEFAULT = -1 + ); + {$ENDIF} +type + {$EXTERNALSYM tagAMTunerSubChannel} + AMTunerSubChannel = tagAMTunerSubChannel; + {$EXTERNALSYM AMTunerSubChannel} + TAMTunerSubChannel = AMTunerSubChannel; + +type + {$IFNDEF COMPILER6_UP} + tagAMTunerSignalStrength = {$IFDEF TYPE_IDENTITY}type {$ENDIF} LongWord; + const + AMTUNER_HASNOSIGNALSTRENGTH = -1; + {$EXTERNALSYM AMTUNER_HASNOSIGNALSTRENGTH} + AMTUNER_NOSIGNAL = 0; + {$EXTERNALSYM AMTUNER_NOSIGNAL} + AMTUNER_SIGNALPRESENT = 1; + {$EXTERNALSYM AMTUNER_SIGNALPRESENT} + {$ELSE} + tagAMTunerSignalStrength = ( + AMTUNER_HASNOSIGNALSTRENGTH = -1, + AMTUNER_NOSIGNAL = 0, + AMTUNER_SIGNALPRESENT = 1 + ); + {$ENDIF} +type + {$EXTERNALSYM tagAMTunerSignalStrength} + AMTunerSignalStrength = tagAMTunerSignalStrength; + {$EXTERNALSYM AMTunerSignalStrength} + TAMTunerSignalStrength = AMTunerSignalStrength; + +type + {$IFNDEF COMPILER6_UP} + tagAMTunerModeType = {$IFDEF TYPE_IDENTITY}type {$ENDIF} LongWord; + const + AMTUNER_MODE_DEFAULT = 0; + {$EXTERNALSYM AMTUNER_MODE_DEFAULT} + AMTUNER_MODE_TV = 1; + {$EXTERNALSYM AMTUNER_MODE_TV} + AMTUNER_MODE_FM_RADIO = 2; + {$EXTERNALSYM AMTUNER_MODE_FM_RADIO} + AMTUNER_MODE_AM_RADIO = 4; + {$EXTERNALSYM AMTUNER_MODE_AM_RADIO} + AMTUNER_MODE_DSS = 8; + {$EXTERNALSYM AMTUNER_MODE_DSS} + {$ELSE} + tagAMTunerModeType = ( + AMTUNER_MODE_DEFAULT = 0, + AMTUNER_MODE_TV = 1, + AMTUNER_MODE_FM_RADIO = 2, + AMTUNER_MODE_AM_RADIO = 4, + AMTUNER_MODE_DSS = 8 + ); + {$ENDIF} +type + {$EXTERNALSYM tagAMTunerModeType} + AMTunerModeType = tagAMTunerModeType; + {$EXTERNALSYM AMTunerModeType} + TAMTunerModeType = AMTunerModeType; + +type + tagAMTunerEventType = ( + {$IFNDEF COMPILER6_UP} + AMTUNER_EVENT_INVALID_0, + AMTUNER_EVENT_CHANGED + {$ELSE} + AMTUNER_EVENT_CHANGED = 1 + {$ENDIF} + ); + {$EXTERNALSYM tagAMTunerEventType} + AMTunerEventType = tagAMTunerEventType; + {$EXTERNALSYM AMTunerEventType} + TAMTunerEventType = AMTunerEventType; + + IAMTunerNotification = interface; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMTuner;'} + {$EXTERNALSYM IAMTuner} + IAMTuner = interface(IUnknown) + ['{211A8761-03AC-11d1-8D13-00AA00BD8339}'] + (*** IAMTuner methods ***) + function put_Channel(lChannel, lVideoSubChannel, lAudioSubChannel: Longint): HResult; stdcall; + function get_Channel(out lChannel, lVideoSubChannel, lAudioSubChannel: Longint): HResult; stdcall; + function ChannelMinMax(out lChannelMin, lChannelMax: Longint): HResult; stdcall; + function put_CountryCode(lCountryCode: Longint): HResult; stdcall; + function get_CountryCode(out lCountryCode: Longint): HResult; stdcall; + function put_TuningSpace(lTuningSpace: Longint): HResult; stdcall; + function get_TuningSpace(out lTuningSpace: Longint): HResult; stdcall; + function Logon(hCurrentUser: THandle): HResult; stdcall; + function Logout: HResult; stdcall; + function SignalPresent(out plSignalStrength: Longint): HResult; stdcall; + function put_Mode(lMode: TAMTunerModeType): HResult; stdcall; + function get_Mode(out plMode: TAMTunerModeType): HResult; stdcall; + function GetAvailableModes(out plModes: Longint): HResult; stdcall; + function RegisterNotificationCallBack(pNotify: IAMTunerNotification; + lEvents: Longint): HResult; stdcall; + function UnRegisterNotificationCallBack(pNotify: IAMTunerNotification): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMTunerNotification;'} + {$EXTERNALSYM IAMTunerNotification} + IAMTunerNotification = interface(IUnknown) + ['{211A8760-03AC-11d1-8D13-00AA00BD8339}'] + (*** IAMTunerNotification methods ***) + function OnEvent(Event: TAMTunerEventType): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMTVTuner;'} + {$EXTERNALSYM IAMTVTuner} + IAMTVTuner = interface(IAMTuner) + ['{211A8766-03AC-11d1-8D13-00AA00BD8339}'] + (*** IAMTVTuner methods ***) + function get_AvailableTVFormats(out lAnalogVideoStandard: Longint): HResult; stdcall; + function get_TVFormat(out plAnalogVideoStandard: Longint): HResult; stdcall; + function AutoTune(lChannel: Longint; out plFoundSignal: Longint): HResult; stdcall; + function StoreAutoTune: HResult; stdcall; + function get_NumInputConnections(out plNumInputConnections: Longint): HResult; stdcall; + function put_InputType(lIndex: Longint; InputType: TTunerInputType): HResult; stdcall; + function get_InputType(lIndex: Longint; out InputType: TTunerInputType): HResult; stdcall; + function put_ConnectInput(lIndex: Longint): HResult; stdcall; + function get_ConnectInput(out plIndex: Longint): HResult; stdcall; + function get_VideoFrequency(out lFreq: Longint): HResult; stdcall; + function get_AudioFrequency(out lFreq: Longint): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IBPCSatelliteTuner;'} + {$EXTERNALSYM IBPCSatelliteTuner} + IBPCSatelliteTuner = interface(IAMTuner) + ['{211A8765-03AC-11d1-8D13-00AA00BD8339}'] + (*** IBPCSatelliteTuner methods ***) + function get_DefaultSubChannelTypes(out plDefaultVideoType, plDefaultAudioType: Longint): HResult; stdcall; + function put_DefaultSubChannelTypes(lDefaultVideoType, lDefaultAudioType: Longint): HResult; stdcall; + function IsTapingPermitted: HResult; stdcall; + end; + + {$IFNDEF COMPILER6_UP} + tagTVAudioMode = {$IFDEF TYPE_IDENTITY}type {$ENDIF} LongWord; + const + AMTVAUDIO_MODE_MONO = $1; + {$EXTERNALSYM AMTVAUDIO_MODE_MONO} + AMTVAUDIO_MODE_STEREO = $2; + {$EXTERNALSYM AMTVAUDIO_MODE_STEREO} + AMTVAUDIO_MODE_LANG_A = $10; + {$EXTERNALSYM AMTVAUDIO_MODE_LANG_A} + AMTVAUDIO_MODE_LANG_B = $20; + {$EXTERNALSYM AMTVAUDIO_MODE_LANG_B} + AMTVAUDIO_MODE_LANG_C = $40; + {$EXTERNALSYM AMTVAUDIO_MODE_LANG_C} + {$ELSE} + tagTVAudioMode = ( + AMTVAUDIO_MODE_MONO = $1, + AMTVAUDIO_MODE_STEREO = $2, + AMTVAUDIO_MODE_LANG_A = $10, + AMTVAUDIO_MODE_LANG_B = $20, + AMTVAUDIO_MODE_LANG_C = $40 + ); + {$ENDIF} +type + {$EXTERNALSYM tagTVAudioMode} + TVAudioMode = tagTVAudioMode; + {$EXTERNALSYM TVAudioMode} + TTVAudioMode = TVAudioMode; + +type + + tagAMTVAudioEventType = ( + {$IFNDEF COMPILER6_UP} + AMTVAUDIO_EVENT_INVALID_0, + AMTVAUDIO_EVENT_CHANGED + {$ELSE} + AMTVAUDIO_EVENT_CHANGED = 1 + {$ENDIF} + ); + {$EXTERNALSYM tagAMTVAudioEventType} + AMTVAudioEventType = tagAMTVAudioEventType; + {$EXTERNALSYM AMTVAudioEventType} + TAMTVAudioEventType = AMTVAudioEventType; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMTVAudio;'} + {$EXTERNALSYM IAMTVAudio} + IAMTVAudio = interface(IUnknown) + ['{83EC1C30-23D1-11d1-99E6-00A0C9560266}'] + (*** IAMTVAudio methods ***) + function GetHardwareSupportedTVAudioModes(out plModes: Longint): HResult; stdcall; + function GetAvailableTVAudioModes(out plModes: Longint): HResult; stdcall; + function get_TVAudioMode(out plMode: Longint): HResult; stdcall; + function put_TVAudioMode(lMode: Longint): HResult; stdcall; + function RegisterNotificationCallBack(pNotify: IAMTunerNotification; + lEvents: Longint): HResult; stdcall; + function UnRegisterNotificationCallBack(pNotify: IAMTunerNotification): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMTVAudioNotification;'} + {$EXTERNALSYM IAMTVAudioNotification} + IAMTVAudioNotification = interface(IUnknown) + ['{83EC1C33-23D1-11D1-99E6-00A0C9560266}'] + (*** IAMTVAudioNotification methods ***) + function OnEvent(Event: TAMTVAudioEventType): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMAnalogVideoEncoder;'} + {$EXTERNALSYM IAMAnalogVideoEncoder} + IAMAnalogVideoEncoder = interface(IUnknown) + ['{C6E133B0-30AC-11d0-A18C-00A0C9118956}'] + (*** IAMAnalogVideoEncoder methods ***) + function get_AvailableTVFormats(out lAnalogVideoStandard: Longint): HResult; stdcall; + function put_TVFormat(lAnalogVideoStandard: Longint): HResult; stdcall; + function get_TVFormat(out plAnalogVideoStandard: Longint): HResult; stdcall; + function put_CopyProtection(lVideoCopyProtection: Longint): HResult; stdcall; + function get_CopyProtection(out lVideoCopyProtection: Longint): HResult; stdcall; + function put_CCEnable(lCCEnable: LongBool): HResult; stdcall; + function get_CCEnable(out lCCEnable: LongBool): HResult; stdcall; + end ; + + AMPROPERTY_PIN = ( + AMPROPERTY_PIN_CATEGORY, + AMPROPERTY_PIN_MEDIUM + ); + {$EXTERNALSYM AMPROPERTY_PIN} + TAMPropertyPin = AMPROPERTY_PIN; + +const + KSPROPERTY_SUPPORT_GET = 1; + {$EXTERNALSYM KSPROPERTY_SUPPORT_GET} + KSPROPERTY_SUPPORT_SET = 2; + {$EXTERNALSYM KSPROPERTY_SUPPORT_SET} + +type + {$HPPEMIT 'typedef System::DelphiInterface _di_IKsPropertySet;'} + {$EXTERNALSYM IKsPropertySet} + IKsPropertySet = interface(IUnknown) + ['{31EFAC30-515C-11d0-A9AA-00AA0061BE93}'] + (*** IKsPropertySet methods ***) + function Set_(const guidPropSet: TGUID; dwPropID: TAMPropertyPin; + pInstanceData: pointer; cbInstanceData: DWORD; pPropData: pointer; cbPropData: DWORD): HResult; stdcall; + function Get(const guidPropSet: TGUID; dwPropID: TAMPropertyPin; + pInstanceData: pointer; cbInstanceData: DWORD; out pPropData ; cbPropData: DWORD; + out pcbReturned: DWORD): HResult; stdcall; + function QuerySupported(const guidPropSet: TGUID; dwPropID: TAMPropertyPin; + out pTypeSupport: DWORD): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IMediaPropertyBag;'} + {$EXTERNALSYM IMediaPropertyBag} + IMediaPropertyBag = interface(IPropertyBag) + ['{6025A880-C0D5-11D0-BD4E-00A0C911CE86}'] + (*** IMediaPropertyBag methods ***) + function EnumProperty(iProperty: ULONG; var pvarPropertyName, + pvarPropertyValue: OleVariant): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IPersistMediaPropertyBag;'} + {$EXTERNALSYM IPersistMediaPropertyBag} + IPersistMediaPropertyBag = interface(IPersist) + ['{5738E040-B67F-11d0-BD4D-00A0C911CE86}'] + (*** IPersistMediaPropertyBag methods ***) + function InitNew: HResult; stdcall; + function Load(pPropBag: IMediaPropertyBag; pErrorLog: IErrorLog): HResult; stdcall; + function Save(pPropBag: IMediaPropertyBag; fClearDirty, fSaveAllProperties: BOOL): HResult; stdcall; + end; + + //Deprecated Interface + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMPhysicalPinInfo;'} + {$EXTERNALSYM IAMPhysicalPinInfo} + IAMPhysicalPinInfo = interface(IUnknown) + ['{F938C991-3029-11CF-8C44-00AA006B6814}'] + (*** IAMPhysicalPinInfo methods ***) + function GetPhysicalType(out pType: Longint; out ppszType: PWideChar): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMExtDevice;'} + {$EXTERNALSYM IAMExtDevice} + IAMExtDevice = interface(IUnknown) + ['{B5730A90-1A2C-11CF-8C23-00AA006B6814}'] + (*** IAMExtDevice methods ***) + function GetCapability(Capability: Longint; out pValue: Longint; out pdblValue: double): HResult; stdcall; + function get_ExternalDeviceID(out ppszData: PWideChar): HResult; stdcall; + function get_ExternalDeviceVersion(out ppszData: PWideChar): HResult; stdcall; + function put_DevicePower(PowerMode: Longint): HResult; stdcall; + function get_DevicePower(out pPowerMode: Longint): HResult; stdcall; + function Calibrate(hEvent: THandle; Mode: Longint; out pStatus: Longint): HResult; stdcall; + function put_DevicePort(DevicePort: Longint): HResult; stdcall; + function get_DevicePort(out pDevicePort: Longint): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMExtTransport;'} + {$EXTERNALSYM IAMExtTransport} + IAMExtTransport = interface(IUnknown) + ['{A03CD5F0-3045-11CF-8C44-00AA006B6814}'] + (*** IAMExtTransport methods ***) + function GetCapability(Capability: Longint; out pValue: Longint; out pdblValue: double): HResult; stdcall; + function put_MediaState(State: Longint): HResult; stdcall; + function get_MediaState(out pState: Longint): HResult; stdcall; + function put_LocalControl(State: Longint): HResult; stdcall; + function get_LocalControl(out pState: Longint): HResult; stdcall; + function GetStatus(StatusItem: Longint; out pValue: Longint): HResult; stdcall; + function GetTransportBasicParameters(Param: Longint; var pValue: Longint; ppszData: pointer): HResult; stdcall; + function SetTransportBasicParameters(Param: Longint; Value: Longint; pszData: PWideChar): HResult; stdcall; + function GetTransportVideoParameters(Param: Longint; out pValue: Longint): HResult; stdcall; + function SetTransportVideoParameters(Param: Longint; Value: Longint): HResult; stdcall; + function GetTransportAudioParameters(Param: Longint; out pValue: Longint): HResult; stdcall; + function SetTransportAudioParameters(Param: Longint; Value: Longint): HResult; stdcall; + function put_Mode(Mode: Longint): HResult; stdcall; + function get_Mode(out pMode: Longint): HResult; stdcall; + function put_Rate(dblRate: double): HResult; stdcall; + function get_Rate(out pdblRate: double): HResult; stdcall; + function GetChase(out pEnabled, pOffset: Longint; var phEvent: THandle): HResult; stdcall; + function SetChase(Enable, Offset: Longint; hEvent: THandle): HResult; stdcall; + function GetBump(out pSpeed, pDuration: Longint): HResult; stdcall; + function SetBump(Speed, Duration: Longint): HResult; stdcall; + function get_AntiClogControl(out pEnabled: Longint): HResult; stdcall; + function put_AntiClogControl(Enable: Longint): HResult; stdcall; + function GetEditPropertySet(EditID: Longint; out pState: Longint): HResult; stdcall; + function SetEditPropertySet(var pEditID: Longint; State: Longint): HResult; stdcall; + function GetEditProperty(EditID, Param: Longint; out pValue: Longint): HResult; stdcall; + function SetEditProperty(EditID, Param, Value: Longint): HResult; stdcall; + function get_EditStart(out pValue: Longint): HResult; stdcall; + function put_EditStart(Value: Longint): HResult; stdcall; + end; + + PTimeCode = ^TTimeCode; + _timecode = record + wFrameRate : Word; + wFrameFract : Word; + dwFrames : DWORD; + end; + {$EXTERNALSYM _timecode} + TIMECODE = _timecode; + {$EXTERNALSYM TIMECODE} + TTimeCode = _timecode; + + PTimeCodeSample = ^TTimeCodeSample; + tagTIMECODE_SAMPLE = record + qwTick : Int64; + timecode : TIMECODE; + dwUser : DWORD; + dwFlags : DWORD; + end; + {$EXTERNALSYM tagTIMECODE_SAMPLE} + TIMECODE_SAMPLE = tagTIMECODE_SAMPLE; + {$EXTERNALSYM TIMECODE_SAMPLE} + TTimeCodeSample = tagTIMECODE_SAMPLE; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMTimecodeReader;'} + {$EXTERNALSYM IAMTimecodeReader} + IAMTimecodeReader = interface(IUnknown) + ['{9B496CE1-811B-11CF-8C77-00AA006B6814}'] + (*** IAMTimecodeReader methods ***) + function GetTCRMode(Param: Longint; out pValue: Longint): HResult; stdcall; + function SetTCRMode(Param: Longint; Value: Longint): HResult; stdcall; + function put_VITCLine(Line: Longint): HResult; stdcall; + function get_VITCLine(out pLine: Longint): HResult; stdcall; + function GetTimecode(out pTimecodeSample: TTimeCodeSample): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMTimecodeGenerator;'} + {$EXTERNALSYM IAMTimecodeGenerator} + IAMTimecodeGenerator = interface(IUnknown) + ['{9B496CE0-811B-11CF-8C77-00AA006B6814}'] + (*** IAMTimecodeGenerator methods ***) + function GetTCGMode(Param: Longint; out pValue: Longint): HResult; stdcall; + function SetTCGMode(Param: Longint; Value: Longint): HResult; stdcall; + function put_VITCLine(Line: Longint): HResult; stdcall; + function get_VITCLine(out Line: Longint): HResult; stdcall; + function SetTimecode(var pTimecodeSample: TTimeCodeSample): HResult; stdcall; + function GetTimecode(out pTimecodeSample: TTimeCodeSample): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMTimecodeDisplay;'} + {$EXTERNALSYM IAMTimecodeDisplay} + IAMTimecodeDisplay = interface(IUnknown) + ['{9B496CE2-811B-11CF-8C77-00AA006B6814}'] + (*** IAMTimecodeDisplay methods ***) + function GetTCDisplayEnable(out pState: Longint): HResult; stdcall; + function SetTCDisplayEnable(State: Longint): HResult; stdcall; + function GetTCDisplay(Param: Longint; out pValue: Longint): HResult; stdcall; + function SetTCDisplay(Param, Value: Longint): HResult; stdcall; + end; + + //Deprecated Interface + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMDevMemoryAllocator;'} + {$EXTERNALSYM IAMDevMemoryAllocator} + IAMDevMemoryAllocator = interface(IUnknown) + ['{C6545BF0-E76B-11D0-BD52-00A0C911CE86}'] + (*** IAMDevMemoryAllocator methods ***) + function GetInfo(out pdwcbTotalFree, pdwcbLargestFree, pdwcbTotalMemory, pdwcbMinimumChunk: DWORD): HResult; stdcall; + function CheckMemory(pBuffer: Pointer): HResult; stdcall; + function Alloc(out ppBuffer: Pointer; var pdwcbBuffer: DWORD): HResult; stdcall; + function Free(pBuffer: Pointer): HResult; stdcall; + function GetDevMemoryObject(out ppUnkInnner: IUnknown; pUnkOuter: IUnknown): HResult; stdcall; + end; + + //Deprecated Interface + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMDevMemoryControl;'} + {$EXTERNALSYM IAMDevMemoryControl} + IAMDevMemoryControl = interface(IUnknown) + ['{C6545BF1-E76B-11D0-BD52-00A0C911CE86}'] + (*** IAMDevMemoryControl methods ***) + function QueryWriteSync: HResult; stdcall; + function WriteSync: HResult; stdcall; + function GetDevId(out pdwDevId: DWORD): HResult; stdcall; + end; + +const + AMSTREAMSELECTINFO_ENABLED = $1; + {$EXTERNALSYM AMSTREAMSELECTINFO_ENABLED} + AMSTREAMSELECTINFO_EXCLUSIVE = $2; + {$EXTERNALSYM AMSTREAMSELECTINFO_EXCLUSIVE} + + AMSTREAMSELECTENABLE_ENABLE = $1; + {$EXTERNALSYM AMSTREAMSELECTENABLE_ENABLE} + AMSTREAMSELECTENABLE_ENABLEALL = $2; + {$EXTERNALSYM AMSTREAMSELECTENABLE_ENABLEALL} + +type + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMStreamSelect;'} + {$EXTERNALSYM IAMStreamSelect} + IAMStreamSelect = interface(IUnknown) + ['{C1960960-17F5-11D1-ABE1-00A0C905F375}'] + (*** IAMStreamSelect methods ***) + function Count(out pcStreams: DWORD): HResult; stdcall; + function Info(lIndex: Longint; out ppmt: PAMMediaType; + out pdwFlags: DWORD; out plcid: LCID; out pdwGroup: DWORD; + out ppszName: PWCHAR; out ppObject: IUnknown; out ppUnk : IUnknown): HResult; stdcall; + function Enable(lIndex: Longint; dwFlags: DWORD): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMResourceControl;'} + {$EXTERNALSYM IAMResourceControl} + IAMResourceControl = interface(IUnknown) + ['{8389d2d0-77d7-11d1-abe6-00a0c905f375}'] + (*** IAMResourceControl methods ***) + function Reserve(dwFlags: DWORD; var pvReserved: pointer): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMClockAdjust;'} + {$EXTERNALSYM IAMClockAdjust} + IAMClockAdjust = interface(IUnknown) + ['{4d5466b0-a49c-11d1-abe8-00a0c905f375}'] + (*** IAMClockAdjust methods ***) + function SetClockDelta(rtDelta: TReferenceTime): HResult; stdcall; + end; + +const + AM_FILTER_MISC_FLAGS_IS_RENDERER = $1; + {$EXTERNALSYM AM_FILTER_MISC_FLAGS_IS_RENDERER} + AM_FILTER_MISC_FLAGS_IS_SOURCE = $2; + {$EXTERNALSYM AM_FILTER_MISC_FLAGS_IS_SOURCE} + +type + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMFilterMiscFlags;'} + {$EXTERNALSYM IAMFilterMiscFlags} + IAMFilterMiscFlags = interface(IUnknown) + ['{2dd74950-a890-11d1-abe8-00a0c905f375}'] + (*** IAMFilterMiscFlags methods ***) + function GetMiscFlags: ULONG; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IDrawVideoImage;'} + {$EXTERNALSYM IDrawVideoImage} + IDrawVideoImage = interface(IUnknown) + ['{48efb120-ab49-11d2-aed2-00a0c995e8d5}'] + (*** IDrawVideoImage methods ***) + function DrawVideoImageBegin: HResult; stdcall; + function DrawVideoImageEnd: HResult; stdcall; + function DrawVideoImageDraw(hdc: HDC; lprcSrc, lprcDst: PRECT): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IDecimateVideoImage;'} + {$EXTERNALSYM IDecimateVideoImage} + IDecimateVideoImage = interface(IUnknown) + ['{2e5ea3e0-e924-11d2-b6da-00a0c995e8df}'] + (*** IDecimateVideoImage methods ***) + function SetDecimationImageSize(lWidth, lHeight: Longint):HResult; stdcall; + function ResetDecimationImageSize: HResult; stdcall; + end; + + _DECIMATION_USAGE = ( + DECIMATION_LEGACY, + DECIMATION_USE_DECODER_ONLY, + DECIMATION_USE_VIDEOPORT_ONLY, + DECIMATION_USE_OVERLAY_ONLY, + DECIMATION_DEFAULT + ); + {$EXTERNALSYM _DECIMATION_USAGE} + DECIMATION_USAGE = _DECIMATION_USAGE; + {$EXTERNALSYM DECIMATION_USAGE} + TDecimationUsage = DECIMATION_USAGE; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMVideoDecimationProperties;'} + {$EXTERNALSYM IAMVideoDecimationProperties} + IAMVideoDecimationProperties = interface(IUnknown) + ['{60d32930-13da-11d3-9ec6-c4fcaef5c7be}'] + (*** IAMVideoDecimationProperties methods ***) + function QueryDecimationUsage(out lpUsage: TDecimationUsage):HResult; stdcall; + function SetDecimationUsage(Usage: TDecimationUsage):HResult; stdcall; + end; + +const + AM_PUSHSOURCECAPS_INTERNAL_RM = $1; + {$EXTERNALSYM AM_PUSHSOURCECAPS_INTERNAL_RM} + AM_PUSHSOURCECAPS_NOT_LIVE = $2; + {$EXTERNALSYM AM_PUSHSOURCECAPS_NOT_LIVE} + AM_PUSHSOURCECAPS_PRIVATE_CLOCK = $4; + {$EXTERNALSYM AM_PUSHSOURCECAPS_PRIVATE_CLOCK} + AM_PUSHSOURCEREQS_USE_STREAM_CLOCK = $10000; + {$EXTERNALSYM AM_PUSHSOURCEREQS_USE_STREAM_CLOCK} + AM_PUSHSOURCEREQS_USE_CLOCK_CHAIN = $20000; + {$EXTERNALSYM AM_PUSHSOURCEREQS_USE_CLOCK_CHAIN} + +type + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMLatency;'} + {$EXTERNALSYM IAMLatency} + IAMLatency = interface(IUnknown) + ['{62EA93BA-EC62-11d2-B770-00C04FB6BD3D}'] + (*** IAMLatency methods ***) + function GetLatency(var prtLatency: TReferenceTime): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMPushSource;'} + {$EXTERNALSYM IAMPushSource} + IAMPushSource = interface(IAMLatency) + ['{F185FE76-E64E-11d2-B76E-00C04FB6BD3D}'] + (*** IAMPushSource methods ***) + function GetPushSourceFlags(out pFlags: ULONG): HResult; stdcall; + function SetPushSourceFlags(Flags: ULONG): HResult; stdcall; + function SetStreamOffset(rtOffset: TReferenceTime): HResult; stdcall; + function GetStreamOffset(out prtOffset: TReferenceTime): HResult; stdcall; + function GetMaxStreamOffset(out prtMaxOffset: TReferenceTime): HResult; stdcall; + function SetMaxStreamOffset(rtMaxOffset: TReferenceTime): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMDeviceRemoval;'} + {$EXTERNALSYM IAMDeviceRemoval} + IAMDeviceRemoval = interface(IUnknown) + ['{f90a6130-b658-11d2-ae49-0000f8754b99}'] + (*** IAMDeviceRemoval methods ***) + function DeviceInfo(out pclsidInterfaceClass: TGUID; + out pwszSymbolicLink: PWideChar): HResult; stdcall; + function Reassociate: HResult; stdcall; + function Disassociate: HResult; stdcall; + end; + +type + PTDVInfo = ^TDVInfo; + DVINFO = record + //for 1st 5/6 DIF seq. + dwDVAAuxSrc : DWORD; + dwDVAAuxCtl : DWORD; + //for 2nd 5/6 DIF seq. + dwDVAAuxSrc1 : DWORD; + dwDVAAuxCtl1 : DWORD; + //for video information + dwDVVAuxSrc : DWORD; + dwDVVAuxCtl : DWORD; + dwDVReserved: array[0..1] of DWORD; + end; + {$EXTERNALSYM DVINFO} + TDVInfo = DVINFO; + +const + //DVENCODERRESOLUTION + DVENCODERRESOLUTION_720x480 = 2012; + {$EXTERNALSYM DVENCODERRESOLUTION_720x480} + DVENCODERRESOLUTION_360x240 = 2013; + {$EXTERNALSYM DVENCODERRESOLUTION_360x240} + DVENCODERRESOLUTION_180x120 = 2014; + {$EXTERNALSYM DVENCODERRESOLUTION_180x120} + DVENCODERRESOLUTION_88x60 = 2015; + {$EXTERNALSYM DVENCODERRESOLUTION_88x60} + + //DVENCODERVIDEOFORMAT + DVENCODERVIDEOFORMAT_NTSC = 2000; + {$EXTERNALSYM DVENCODERVIDEOFORMAT_NTSC} + DVENCODERVIDEOFORMAT_PAL = 2001; + {$EXTERNALSYM DVENCODERVIDEOFORMAT_PAL} + + //DVENCODERFORMAT + DVENCODERFORMAT_DVSD = 2007; + {$EXTERNALSYM DVENCODERFORMAT_DVSD} + DVENCODERFORMAT_DVHD = 2008; + {$EXTERNALSYM DVENCODERFORMAT_DVHD} + DVENCODERFORMAT_DVSL = 2009; + {$EXTERNALSYM DVENCODERFORMAT_DVSL} + +type + {$HPPEMIT 'typedef System::DelphiInterface _di_IDVEnc;'} + {$EXTERNALSYM IDVEnc} + IDVEnc = interface(IUnknown) + ['{d18e17a0-aacb-11d0-afb0-00aa00b67a42}'] + (*** IDVEnc methods ***) + function get_IFormatResolution(out VideoFormat, DVFormat, Resolution: integer; + fDVInfo: ByteBool; out sDVInfo: TDVINFO): HResult; stdcall; + function put_IFormatResolution(VideoFormat, DVFormat, Resolution: integer; + fDVInfo: ByteBool; var sDVInfo: TDVINFO): HResult; stdcall; + end; + +const + //DVDECODERRESOLUTION + DVDECODERRESOLUTION_720x480 = 1000; + {$EXTERNALSYM DVDECODERRESOLUTION_720x480} + DVDECODERRESOLUTION_360x240 = 1001; + {$EXTERNALSYM DVDECODERRESOLUTION_360x240} + DVDECODERRESOLUTION_180x120 = 1002; + {$EXTERNALSYM DVDECODERRESOLUTION_180x120} + DVDECODERRESOLUTION_88x60 = 1003; + {$EXTERNALSYM DVDECODERRESOLUTION_88x60} + + //DVRESOLUTION + DVRESOLUTION_FULL = 1000; + {$EXTERNALSYM DVRESOLUTION_FULL} + DVRESOLUTION_HALF = 1001; + {$EXTERNALSYM DVRESOLUTION_HALF} + DVRESOLUTION_QUARTER = 1002; + {$EXTERNALSYM DVRESOLUTION_QUARTER} + DVRESOLUTION_DC = 1003; + {$EXTERNALSYM DVRESOLUTION_DC} + +type + {$HPPEMIT 'typedef System::DelphiInterface _di_IIPDVDec;'} + {$EXTERNALSYM IIPDVDec} + IIPDVDec = interface(IUnknown) + ['{b8e8bd60-0bfe-11d0-af91-00aa00b67a42}'] + (*** IIPDVDec methods ***) + function get_IPDisplay(out displayPix : integer): HResult; stdcall; + function put_IPDisplay(displayPix: integer): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IDVRGB219;'} + {$EXTERNALSYM IDVRGB219} + IDVRGB219 = interface(IUnknown) + ['{58473A19-2BC8-4663-8012-25F81BABDDD1}'] + (*** IDVRGB219 methods ***) + function SetRGB219(bState: BOOL): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IDVSplitter;'} + {$EXTERNALSYM IDVSplitter} + IDVSplitter = interface(IUnknown) + ['{92a3a302-da7c-4a1f-ba7e-1802bb5d2d02}'] + (*** IDVSplitter methods ***) + function DiscardAlternateVideoFrames(nDiscard: integer): HResult; stdcall; + end; + +//_AM_AUDIO_RENDERER_STAT_PARAM +const + AM_AUDREND_STAT_PARAM_BREAK_COUNT = 1; + {$EXTERNALSYM AM_AUDREND_STAT_PARAM_BREAK_COUNT} + AM_AUDREND_STAT_PARAM_SLAVE_MODE = AM_AUDREND_STAT_PARAM_BREAK_COUNT + 1; + {$EXTERNALSYM AM_AUDREND_STAT_PARAM_SLAVE_MODE} + AM_AUDREND_STAT_PARAM_SILENCE_DUR = AM_AUDREND_STAT_PARAM_SLAVE_MODE + 1; + {$EXTERNALSYM AM_AUDREND_STAT_PARAM_SILENCE_DUR} + AM_AUDREND_STAT_PARAM_LAST_BUFFER_DUR = AM_AUDREND_STAT_PARAM_SILENCE_DUR + 1; + {$EXTERNALSYM AM_AUDREND_STAT_PARAM_LAST_BUFFER_DUR} + AM_AUDREND_STAT_PARAM_DISCONTINUITIES = AM_AUDREND_STAT_PARAM_LAST_BUFFER_DUR + 1; + {$EXTERNALSYM AM_AUDREND_STAT_PARAM_DISCONTINUITIES} + AM_AUDREND_STAT_PARAM_SLAVE_RATE = AM_AUDREND_STAT_PARAM_DISCONTINUITIES + 1; + {$EXTERNALSYM AM_AUDREND_STAT_PARAM_SLAVE_RATE} + AM_AUDREND_STAT_PARAM_SLAVE_DROPWRITE_DUR = AM_AUDREND_STAT_PARAM_SLAVE_RATE + 1; + {$EXTERNALSYM AM_AUDREND_STAT_PARAM_SLAVE_DROPWRITE_DUR} + AM_AUDREND_STAT_PARAM_SLAVE_HIGHLOWERROR = AM_AUDREND_STAT_PARAM_SLAVE_DROPWRITE_DUR + 1; + {$EXTERNALSYM AM_AUDREND_STAT_PARAM_SLAVE_HIGHLOWERROR} + AM_AUDREND_STAT_PARAM_SLAVE_LASTHIGHLOWERROR = AM_AUDREND_STAT_PARAM_SLAVE_HIGHLOWERROR + 1; + {$EXTERNALSYM AM_AUDREND_STAT_PARAM_SLAVE_LASTHIGHLOWERROR} + AM_AUDREND_STAT_PARAM_SLAVE_ACCUMERROR = AM_AUDREND_STAT_PARAM_SLAVE_LASTHIGHLOWERROR + 1; + {$EXTERNALSYM AM_AUDREND_STAT_PARAM_SLAVE_ACCUMERROR} + AM_AUDREND_STAT_PARAM_BUFFERFULLNESS = AM_AUDREND_STAT_PARAM_SLAVE_ACCUMERROR + 1; + {$EXTERNALSYM AM_AUDREND_STAT_PARAM_BUFFERFULLNESS} + AM_AUDREND_STAT_PARAM_JITTER = AM_AUDREND_STAT_PARAM_BUFFERFULLNESS + 1; + {$EXTERNALSYM AM_AUDREND_STAT_PARAM_JITTER} + +type + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMAudioRendererStats;'} + {$EXTERNALSYM IAMAudioRendererStats} + IAMAudioRendererStats = interface(IUnknown) + ['{22320CB2-D41A-11d2-BF7C-D7CB9DF0BF93}'] + (*** IAMAudioRendererStats methods ***) + function GetStatParam(dwParam: DWORD; out pdwParam1, pdwParam2: DWORD): HResult; stdcall; + end; + +//AM_INTF_SEARCH_FLAGS +const + AM_INTF_SEARCH_INPUT_PIN = $1; + {$EXTERNALSYM AM_INTF_SEARCH_INPUT_PIN} + AM_INTF_SEARCH_OUTPUT_PIN = $2; + {$EXTERNALSYM AM_INTF_SEARCH_OUTPUT_PIN} + AM_INTF_SEARCH_FILTER = $4; + {$EXTERNALSYM AM_INTF_SEARCH_FILTER} + +type + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMGraphStreams;'} + {$EXTERNALSYM IAMGraphStreams} + IAMGraphStreams = interface(IUnknown) + ['{632105FA-072E-11d3-8AF9-00C04FB6BD3D}'] + (*** IAMGraphStreams methods ***) + function FindUpstreamInterface(pPin: IPin; const riid: TGUID; out ppvInterface; + dwFlags: DWORD): HResult; stdcall; + function SyncUsingStreamOffset(bUseStreamOffset: BOOL): HResult; stdcall; + function SetMaxGraphLatency(rtMaxGraphLatency: TReferenceTime): HResult; stdcall; + end; + +//AMOVERLAYFX +const + AMOVERFX_NOFX = 0; + {$EXTERNALSYM AMOVERFX_NOFX} + AMOVERFX_MIRRORLEFTRIGHT = $2; + {$EXTERNALSYM AMOVERFX_MIRRORLEFTRIGHT} + AMOVERFX_MIRRORUPDOWN = $4; + {$EXTERNALSYM AMOVERFX_MIRRORUPDOWN} + AMOVERFX_DEINTERLACE = $8; + {$EXTERNALSYM AMOVERFX_DEINTERLACE} + +type + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMOverlayFX;'} + {$EXTERNALSYM IAMOverlayFX} + IAMOverlayFX = interface(IUnknown) + ['{62fae250-7e65-4460-bfc9-6398b322073c}'] + (*** IAMOverlayFX methods ***) + function QueryOverlayFXCaps(out lpdwOverlayFXCaps: DWORD): HResult; stdcall; + function SetOverlayFX(dwOverlayFX: DWORD): HResult; stdcall; + function GetOverlayFX(out lpdwOverlayFX: DWORD): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMOpenProgress;'} + {$EXTERNALSYM IAMOpenProgress} + IAMOpenProgress = interface(IUnknown) + ['{8E1C39A1-DE53-11cf-AA63-0080C744528D}'] + (*** IAMOpenProgress methods ***) + function QueryProgress(out pllTotal, pllCurrent: int64): HResult; stdcall; + function AbortOperation: HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IMpeg2Demultiplexer;'} + {$EXTERNALSYM IMpeg2Demultiplexer} + IMpeg2Demultiplexer = interface(IUnknown) + ['{436eee9c-264f-4242-90e1-4e330c107512}'] + (*** IMpeg2Demultiplexer methods ***) + function CreateOutputPin(var pMediaType: TAMMediaType; pszPinName: PWideChar; + out ppIPin: IPin): HResult; stdcall; + function SetOutputPinMediaType(pszPinName: PWideChar; var pMediaType: TAMMediaType): HResult; stdcall; + function DeleteOutputPin(pszPinName: PWideChar): HResult; stdcall; + end; + +const + MPEG2_PROGRAM_STREAM_MAP = $00000000; + {$EXTERNALSYM MPEG2_PROGRAM_STREAM_MAP} + MPEG2_PROGRAM_ELEMENTARY_STREAM = $00000001; + {$EXTERNALSYM MPEG2_PROGRAM_ELEMENTARY_STREAM} + MPEG2_PROGRAM_DIRECTORY_PES_PACKET = $00000002; + {$EXTERNALSYM MPEG2_PROGRAM_DIRECTORY_PES_PACKET} + MPEG2_PROGRAM_PACK_HEADER = $00000003; + {$EXTERNALSYM MPEG2_PROGRAM_PACK_HEADER} + MPEG2_PROGRAM_PES_STREAM = $00000004; + {$EXTERNALSYM MPEG2_PROGRAM_PES_STREAM} + MPEG2_PROGRAM_SYSTEM_HEADER = $00000005; + {$EXTERNALSYM MPEG2_PROGRAM_SYSTEM_HEADER} + SUBSTREAM_FILTER_VAL_NONE = $10000000; + {$EXTERNALSYM SUBSTREAM_FILTER_VAL_NONE} + +type + PStreamIDMap = ^TStreamIDMap; + STREAM_ID_MAP = record + stream_id : ULONG; + dwMediaSampleContent : DWORD; + ulSubstreamFilterValue: ULONG; + iDataOffset : integer; + end; + {$EXTERNALSYM STREAM_ID_MAP} + TStreamIDMap = STREAM_ID_MAP; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IEnumStreamIdMap;'} + {$EXTERNALSYM IEnumStreamIdMap} + IEnumStreamIdMap = interface(IUnknown) + ['{945C1566-6202-46fc-96C7-D87F289C6534}'] + (*** IEnumStreamIdMap methods ***) + function Next(cRequest: ULONG; pStreamIdMap: PStreamIDMap; + out pcReceived: ULONG): HResult; stdcall; + function Skip(cRecords: ULONG): HResult; stdcall; + function Reset: HResult; stdcall; + function Clone(out ppIEnumStreamIdMap: IEnumStreamIdMap): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IMPEG2StreamIdMap;'} + {$EXTERNALSYM IMPEG2StreamIdMap} + IMPEG2StreamIdMap = interface(IUnknown) + ['{D0E04C47-25B8-4369-925A-362A01D95444}'] + (*** IMPEG2StreamIdMap methods ***) + function MapStreamId(ulStreamId: ULONG; MediaSampleContent: DWORD; + ulSubstreamFilterValue: ULONG; iDataOffset: integer): HResult; stdcall; + function UnmapStreamId(culStreamId: ULONG; var pulStreamId: ULONG): HResult; stdcall; + function EnumStreamIdMap(out ppIEnumStreamIdMap: IEnumStreamIdMap): HResult; stdcall; + end; + + {$NODEFINE IAMovie} // deprecated + IAMovie = interface(IFilterGraph) + ['{359ACE10-7688-11CF-8B23-00805F6CEF60}'] + (*** IAMovie methods ***) + function Connect(ppinOut, ppinIn: IPin): HResult; stdcall; + function Render(ppinOut: IPin): HResult; stdcall; + function Run: HResult; stdcall; + function Pause: HResult; stdcall; + function Stop: HResult; stdcall; + function GetState(msTimeout: DWORD; out pfs: TFilterState): HResult; stdcall; + function RenderFile(strFilename: PWideChar): HResult; stdcall; + function AddSourceFilter(strFilename: PWideChar; out ppUnk: IBaseFilter): HResult; stdcall; + function GetEventHandle(out hEvent: THandle): HResult; stdcall; + function GetEvent(out lEventCode, lParam1, lParam2: Longint; msTimeout: DWORD): HResult; stdcall; + function WaitForCompletion(msTimeout: DWORD; out pEvCode: Longint): HResult; stdcall; + function CancelDefaultHandling(lEvCode: Longint): HResult; stdcall; + function RestoreDefaultHandling(lEvCode: Longint): HResult; stdcall; + function get_Duration(out plength: TRefTime): HResult; stdcall; + function put_CurrentPosition(llTime: TRefTime): HResult; stdcall; + function get_CurrentPosition(out pllTime: TRefTime): HResult; stdcall; + function get_StopTime(out pllTime: TRefTime): HResult; stdcall; + function put_StopTime(llTime: TRefTime): HResult; stdcall; + function get_PrerollTime(out pllTime: TRefTime): HResult; stdcall; + function put_PrerollTime(llTime: TRefTime): HResult; stdcall; + function put_Rate(dRate: double): HResult; stdcall; + function get_Rate(out pdRate: double): HResult; stdcall; + function RemoveAllFilters: HResult; stdcall; + function Play: HResult; stdcall; + function PlayFile(strFilename: PWideChar): HResult; stdcall; + function EnumFiltersByInterface(const riid: TGUID; + out ppEnum: IEnumFilters): HResult; stdcall; + function EnumPins(out ppEnum: IEnumPins): HResult; stdcall; + function EnumPinsIn(out ppEnum: IEnumPins): HResult; stdcall; + function EnumPinsOut(out ppEnum: IEnumPins): HResult; stdcall; + function RenderAll: HResult; stdcall; + function RenderNewFile(strFilename: PWideChar): HResult; stdcall; + function FreeEventParams(lEvCode, lParam1, lParam2: Longint): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IRegisterServiceProvider;'} + {$EXTERNALSYM IRegisterServiceProvider} + IRegisterServiceProvider = interface(IUnknown) + ['{7B3A2F01-0751-48DD-B556-004785171C54}'] + (*** IRegisterServiceProvider methods ***) + function RegisterService(const guidService: TGUID; pUnkObject: IUnknown): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMClockSlave;'} + {$EXTERNALSYM IAMClockSlave} + IAMClockSlave = interface(IUnknown) + ['{9FD52741-176D-4b36-8F51-CA8F933223BE}'] + (*** IAMClockSlave methods ***) + function SetErrorTolerance(dwTolerance: DWORD): HResult; stdcall; + function GetErrorTolerance(out dwTolerance: DWORD): HResult; stdcall; + end; + +//--------------------------------------------------------------------- +// +// IAMGraphBuilderCallback interface +// +// Interface which gives the app a chance to configure filters +// before a connection is attempted. +// +// If this interface is supported by the site passed in to the graph +// via IObjectWithSite::SetSite, the graph will call back with each +// filter it creates as part of the Render or Connect process. Does +// not call back for source filters. Filter may be discarded and not +// used in graph or may be connected and disconnected more than once +// +// The callback occurs with the graph lock held, so do not call into +// the graph again and do not wait on other threads calling into the +// graph. +// +//--------------------------------------------------------------------- + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMGraphBuilderCallback;'} + {$EXTERNALSYM IAMGraphBuilderCallback} + IAMGraphBuilderCallback = interface(IUnknown) + ['{4995f511-9ddb-4f12-bd3b-f04611807b79}'] + (*** IAMGraphBuilderCallback methods ***) + // graph builder selected a filter to create and attempt to + // connect. failure indicates filter should be rejected. + function SelectedFilter(pMon: IMoniker): HResult; stdcall; + // app configures filter during this call. failure indicates + // filter should be rejected. + function CreatedFilter(pFil: IBaseFilter): HResult; stdcall; + end; + +// Note: Because this interface was not defined as a proper interface it is") +// supported under C++ only. Methods aren't stdcall.") + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMFilterGraphCallback;'} + {$EXTERNALSYM IAMFilterGraphCallback} + IAMFilterGraphCallback = interface(IUnknown) + ['{56a868fd-0ad4-11ce-b0a3-0020af0ba770}'] + (*** IAMFilterGraphCallback methods ***) + // S_OK means rendering complete, S_FALSE means retry now.") + // DCoder: thiscall fix. DON'T use ph1 and ph2, these are just placeholders + // to get the real address of pPin !!! + function UnableToRender(ph1, ph2: integer; pPin: IPin): HResult; // thiscall + end; + +//------------------------------------------------------------------------------ +// File: EncAPI.idl +// +// Desc: Encoder (and future decoder) interface definitions. +// +// Copyright (c) 1992 - 2002, Microsoft Corporation. All rights reserved. +//------------------------------------------------------------------------------ + + CodecAPIEventData = record + guid : TGUID; + dataLength : DWORD; + reserved : array[0..2] of DWORD; + // data: array[0..dataLength-1] of Byte; + end; + {$EXTERNALSYM CodecAPIEventData} + TCodecAPIEventData = CodecAPIEventData; + +// Applications can pass the CODECAPI_VIDEO_ENCODER to IsSupported to test for video encoders +// Similarly, the GUIDs for audio encoders, video decoders, audio decoders and muxes can be +// used to test for the codec classification +// +// See uuids.h for a more detailed list. + {$HPPEMIT 'typedef System::DelphiInterface _di_ICodecAPI;'} + {$EXTERNALSYM ICodecAPI} + ICodecAPI = interface(IUnknown) + ['{901db4c7-31ce-41a2-85dc-8fa0bf41b8da}'] + (*** ICodecAPI methods ***) + // Query whether a given parameter is supported. + function IsSupported(const Api: TGUID): HResult; stdcall; + // Query whether a given parameter can be changed given the codec selection + // and other parameter selections. + function IsModifiable(const Api: TGUID): HResult; stdcall; + // Returns the valid range of values that the parameter supports should + // the parameter support a stepped range as opposed to a list of specific + // values. The support is [ValueMin .. ValueMax] by SteppingDelta. + // + // Ranged variant types must fall into one of the below types. Each + // parameter will, by definition, return a specific type. + // + // If the range has no stepping delta (any delta will do), the Stepping + // delta will be empty (VT_EMPTY). + function GetParameterRange(const Api: TGUID; out ValueMin, ValueMax, + SteppingDelta: OleVariant): HResult; stdcall; + // Returns the list of values supported by the given parameter as a + // COM allocated array. The total number of values will be placed in + // the ValuesCount parameter and the Values array will contain the + // individual values. This array must be freed by the caller through + // CoTaskMemFree(). + function GetParameterValues(const Api: TGUID; out Values: POleVariant; + out ValuesCount: ULONG): HResult; stdcall; + // Get the default value for a parameter, if one exists. Otherwise, + // an error will be returned. + function GetDefaultValue(const Aoi: TGUID; out Value: OleVariant): HResult; stdcall; + // Get the current value of a parameter. + function GetValue(const Api: TGUID; out Value: OleVariant): HResult; + // Set the current value of a parameter. + function SetValue(const Api: TGUID; var Value: OleVariant): HResult; stdcall; + // new methods beyond IEncoderAPI + + // Enable events to be reported for the given event GUID. For DShow + // events, the event is returned as + // (EC_CODECAPI_EVENT, lParam=userData, lParam2=CodecAPIEventData* Data) + // where + // - the CodecAPIEventData is COM allocated memory and must be handled and freed + // by the application using CoTaskMemFree(). + // - the userData is the same pointer passed to RegisterForEvent + // + // Each data block starts with the following structure: + // struct CodecAPIEventData + // { + // GUID guid; + // DWORD dataLength; + // DWORD reserved[3]; // pad to 16 byte alignment + // BYTE data[dataLength]; + // } + // The guid parameter identifies the event. The data associated with the event follows the + // structure (represented by the variable length BYTE data[dataLength] array). + // + // If guid is equal to CODECAPI_CHANGELISTS, then data is an array of GUIDs that changed as + // a result of setting the parameter, as follows: + // GUID changedGuids[ header.dataLength / sizeof(GUID) ] + // + // The current array is limited, so a driver may send multiple messages if the array size is + // exceeded. + // + function RegisterForEvent(const Api: TGUID; userData: Pointer): HResult; stdcall; + // Disable event reporting for the given event GUID. + function UnregisterForEvent(const Api: TGUID): HResult; stdcall; + // SetAllDefaults + function SetAllDefaults: HResult; stdcall; + // Extended SetValue & SetAllDefaults: + // Changes the current value of a parameter and returns back an alteration list + // The secondary arguments return back a list of other settings + // that changed as a result of the SetValue() call (for UI updates etc) + // The client must free the buffer. + function SetValueWithNotify(const Api: TGUID; var Value: Olevariant; + out ChangedParam: PGUID; out ChangedParamCount: ULONG): HResult; stdcall; + function SetAllDefaultsWithNotify(out ChangedParam: PGUID; + out ChangedParamCount: ULONG): HResult; stdcall; + // Load the current settings from a stream + function GetAllSettings(Stream: IStream): HResult; stdcall; + // Save the current settings to a stream + function SetAllSettings(Stream: IStream): HResult; stdcall; + function SetAllSettingsWithNotify(Stream: IStream; out ChangedParam: PGUID; + out ChangedParamCount: ULONG): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IGetCapabilitiesKey;'} + {$EXTERNALSYM IGetCapabilitiesKey} + IGetCapabilitiesKey = interface(IUnknown) + ['{a8809222-07bb-48ea-951c-33158100625b}'] + (*** IGetCapabilitiesKey methods ***) + function GetCapabilitiesKey(out pHKey: HKEY): HResult; stdcall; + end; + +// ----------------------------------------------------------------------------------------- +// From this point on, this is retained for backwards compatiblity only +// Do not use this for future encoders +// ----------------------------------------------------------------------------------------- + {$HPPEMIT 'typedef System::DelphiInterface _di_IEncoderAPI;'} + {$EXTERNALSYM IEncoderAPI} + IEncoderAPI = interface(IUnknown) + ['{70423839-6ACC-4b23-B079-21DBF08156A5}'] + (*** IEncoderAPI methods ***) + function IsSupported(const Api: TGUID): HResult; stdcall; + function IsAvailable(const Api: TGUID): HResult; stdcall; + function GetParameterRange(const Api: TGUID; out ValueMin, ValueMax, + SteppingDelta: OleVariant): HResult; stdcall; + function GetParameterValues(const Api: TGUID; out Values: POleVariant; + out ValuesCount: ULONG): HResult; stdcall; + function GetDefaultValue (const Api: TGUID; out Value: OleVariant): HResult; stdcall; + function GetValue(const Api: TGUID; out Value: OleVariant): HResult; stdcall; + function SetValue(const Api: TGUID; var Value: OleVariant): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IVideoEncoder;'} + {$EXTERNALSYM IVideoEncoder} + IVideoEncoder = interface(IEncoderAPI) + ['{02997C3B-8E1B-460e-9270-545E0DE9563E}'] + (*** IVideoEncoder methods ***) + end; + +//--------------------------------------------------------------------- +// +// Old Encoder API Interfaces +// +//--------------------------------------------------------------------- + + VIDEOENCODER_BITRATE_MODE = ( + // Bit rate used for encoding is constant + ConstantBitRate, + // Bit rate used for encoding is variable with the specified bitrate used + // as a guaranteed average over a specified window. The default window + // size is considered to be 5 minutes. + VariableBitRateAverage, + // Bit rate used for encoding is variable with the specified bitrate used + // as a peak rate over a specified window. The default window size + // is considered to be 500ms (classically one GOP). + VariableBitRatePeak + ); + {$EXTERNALSYM VIDEOENCODER_BITRATE_MODE} + TVideoEncoderBitrateMode = VIDEOENCODER_BITRATE_MODE; + +const + AM_GETDECODERCAP_QUERY_VMR_SUPPORT = $00000001; + {$EXTERNALSYM AM_GETDECODERCAP_QUERY_VMR_SUPPORT} + VMR_NOTSUPPORTED = $00000000; + {$EXTERNALSYM VMR_NOTSUPPORTED} + VMR_SUPPORTED = $00000001; + {$EXTERNALSYM VMR_SUPPORTED} + + AM_QUERY_DECODER_VMR_SUPPORT = $00000001; + {$EXTERNALSYM AM_QUERY_DECODER_VMR_SUPPORT} + AM_QUERY_DECODER_DXVA_1_SUPPORT = $00000002; + {$EXTERNALSYM AM_QUERY_DECODER_DXVA_1_SUPPORT} + + AM_QUERY_DECODER_DVD_SUPPORT = $00000003; + {$EXTERNALSYM AM_QUERY_DECODER_DVD_SUPPORT} + AM_QUERY_DECODER_ATSC_SD_SUPPORT = $00000004; + {$EXTERNALSYM AM_QUERY_DECODER_ATSC_SD_SUPPORT} + AM_QUERY_DECODER_ATSC_HD_SUPPORT = $00000005; + {$EXTERNALSYM AM_QUERY_DECODER_ATSC_HD_SUPPORT} + AM_GETDECODERCAP_QUERY_VMR9_SUPPORT = $00000006; + {$EXTERNALSYM AM_GETDECODERCAP_QUERY_VMR9_SUPPORT} + + DECODER_CAP_NOTSUPPORTED = $00000000; + {$EXTERNALSYM DECODER_CAP_NOTSUPPORTED} + DECODER_CAP_SUPPORTED = $00000001; + {$EXTERNALSYM DECODER_CAP_SUPPORTED} + + CDEF_CLASS_DEFAULT = $0001; + {$EXTERNALSYM CDEF_CLASS_DEFAULT} + CDEF_BYPASS_CLASS_MANAGER = $0002; + {$EXTERNALSYM CDEF_BYPASS_CLASS_MANAGER} + //CDEF_CLASS_LEGACY = $0004; + CDEF_MERIT_ABOVE_DO_NOT_USE = $0008; + {$EXTERNALSYM CDEF_MERIT_ABOVE_DO_NOT_USE} + CDEF_DEVMON_CMGR_DEVICE = $0010; + {$EXTERNALSYM CDEF_DEVMON_CMGR_DEVICE} + CDEF_DEVMON_DMO = $0020; + {$EXTERNALSYM CDEF_DEVMON_DMO} + CDEF_DEVMON_PNP_DEVICE = $0040; + {$EXTERNALSYM CDEF_DEVMON_PNP_DEVICE} + CDEF_DEVMON_FILTER = $0080; + {$EXTERNALSYM CDEF_DEVMON_FILTER} + CDEF_DEVMON_SELECTIVE_MASK = $00f0; + {$EXTERNALSYM CDEF_DEVMON_SELECTIVE_MASK} + +type + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMDecoderCaps;'} + {$EXTERNALSYM IAMDecoderCaps} + IAMDecoderCaps = interface(IUnknown) + ['{c0dff467-d499-4986-972b-e1d9090fa941}'] + (*** IAMDecoderCaps methods ***) + function GetDecoderCaps(dwCapIndex: DWORD; out lpdwCap: DWORD): HResult; stdcall; + end; + +/////////////////////////////////////////////////////////////////////////////// +// +// IAMCertifiedOutputProtection +// +/////////////////////////////////////////////////////////////////////////////// + + PAMCOPPSignature = ^TAMCOPPSignature; + AMCOPPSignature = packed record + Signature: array[0..255] of byte; + end; + {.$EXTERNALSYM AMCOPPSignature} + TAMCOPPSignature = AMCOPPSignature; + + AMCOPPCommand = packed record + macKDI: TGUID; // 16 bytes + guidCommandID: TGUID; // 16 bytes + dwSequence: DWORD; // 4 bytes + cbSizeData: DWORD; // 4 bytes + CommandData: array[0..4055] of byte; // 4056 bytes (4056+4+4+16+16 = 4096) + end; + {.$EXTERNALSYM AMCOPPCommand} + TAMCOPPCommand = AMCOPPCommand; + LPAMCOPPCommand = ^AMCOPPCommand; + {.$EXTERNALSYM LPAMCOPPCommand} + PAMCOPPCommand = LPAMCOPPCommand; + + AMCOPPStatusInput = packed record + rApp: TGUID; // 16 bytes + guidStatusRequestID: TGUID;// 16 bytes + dwSequence: DWORD; // 4 bytes + cbSizeData: DWORD; // 4 bytes + StatusData: array[0..4055] of byte; // 4056 bytes (4056+4+4+16+16 = 4096) + end; + {.$EXTERNALSYM AMCOPPStatusInput} + TAMCOPPStatusInput = AMCOPPStatusInput; + LPAMCOPPStatusInput = ^AMCOPPStatusInput; + {.$EXTERNALSYM LPAMCOPPStatusInput} + PAMCOPPStatusInput = LPAMCOPPStatusInput; + + AMCOPPStatusOutput = packed record + macKDI: TGUID; // 16 bytes + cbSizeData: DWORD; // 4 bytes + COPPStatus: array[0..4075] of byte; // 4076 bytes (4076+16+4 = 4096) + end; + {.$EXTERNALSYM AMCOPPStatusOutput} + TAMCOPPStatusOutput = AMCOPPStatusOutput; + LPAMCOPPStatusOutput = ^AMCOPPStatusOutput; + {.$EXTERNALSYM LPAMCOPPStatusOutput} + PAMCOPPStatusOutput = LPAMCOPPStatusOutput; + + {.$HPPEMIT 'typedef System::DelphiInterface _di_IAMCertifiedOutputProtection;'} + {.$EXTERNALSYM IAMCertifiedOutputProtection} + IAMCertifiedOutputProtection = interface(IUnknown) + ['{6FEDED3E-0FF1-4901-A2F1-43F7012C8515}'] + function KeyExchange( + pRandom: PGUID; // 128-bit random number generated by Graphics Driver + var VarLenCertGH: PByte; // Graphics Hardware certificate, memory released by CoTaskMemFree + pdwLengthCertGH: PDWORD // Length of Graphics Hardware certificate + ): HRESULT; stdcall; + + // Concatenation of 128-bit random data security session key, + // 128-bit random data integrity session key, 32-bit random + // starting status sequence number and 32-bit random starting + // command sequence number encrypted with the public key of + // the graphic hardware. This value is 2048 bits long. + function SessionSequenceStart(pSig: PAMCOPPSignature): HRESULT; stdcall; + + function ProtectionCommand(cmd: PAMCOPPCommand): HRESULT; stdcall; // Encrypted command + + function ProtectionStatus( + pStatusInput: PAMCOPPStatusInput; // Encrypted Status request + pStatusOutput: PAMCOPPStatusOutput): HRESULT; stdcall; // Encrypted Status results + end; + +//////////////////////////////////////////////////////////////////////////////// + + {$HPPEMIT 'typedef System::DelphiInterface _di_ICreateDevEnum;'} + {$EXTERNALSYM ICreateDevEnum} + ICreateDevEnum = interface(IUnknown) + ['{29840822-5B84-11D0-BD3B-00A0C911CE86}'] + (*** ICreateDevEnum methods ***) + function CreateClassEnumerator(const clsidDeviceClass: TGUID; + out ppEnumMoniker: IEnumMoniker; dwFlags: DWORD): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IFilterMapper3;'} + {$EXTERNALSYM IFilterMapper3} + IFilterMapper3 = interface(IFilterMapper2) + ['{b79bb0b1-33c1-11d1-abe1-00a0c905f375}'] + (*** IFilterMapper3 methods ***) + function GetICreateDevEnum(out ppEnum: ICreateDevEnum): HResult; stdcall; + end; + +//replacement for DVD_TextStringType in GetDVDTextStringAsNative, GetDVDTextStringAsUnicode + +{$IFNDEF COMPILER6_UP} +type + DVD_TextStringType = {$IFDEF TYPE_IDENTITY}type {$ENDIF}LongWord; +const + DVD_Struct_Volume = $00000001; + DVD_Struct_Title = $00000002; + DVD_Struct_ParentalID = $00000003; + DVD_Struct_PartOfTitle = $00000004; + DVD_Struct_Cell = $00000005; + DVD_Stream_Audio = $00000010; + DVD_Stream_Subpicture = $00000011; + DVD_Stream_Angle = $00000012; + DVD_Channel_Audio = $00000020; + DVD_General_Name = $00000030; + DVD_General_Comments = $00000031; + DVD_Title_Series = $00000038; + DVD_Title_Movie = $00000039; + DVD_Title_Video = $0000003A; + DVD_Title_Album = $0000003B; + DVD_Title_Song = $0000003C; + DVD_Title_Other = $0000003F; + DVD_Title_Sub_Series = $00000040; + DVD_Title_Sub_Movie = $00000041; + DVD_Title_Sub_Video = $00000042; + DVD_Title_Sub_Album = $00000043; + DVD_Title_Sub_Song = $00000044; + DVD_Title_Sub_Other = $00000047; + DVD_Title_Orig_Series = $00000048; + DVD_Title_Orig_Movie = $00000049; + DVD_Title_Orig_Video = $0000004A; + DVD_Title_Orig_Album = $0000004B; + DVD_Title_Orig_Song = $0000004C; + DVD_Title_Orig_Other = $0000004F; + DVD_Other_Scene = $00000050; + DVD_Other_Cut = $00000051; + DVD_Other_Take = $00000052; +{$ELSE} +type + DVD_TextStringType = ( + DVD_Struct_Volume = $00000001, + DVD_Struct_Title = $00000002, + DVD_Struct_ParentalID = $00000003, + DVD_Struct_PartOfTitle = $00000004, + DVD_Struct_Cell = $00000005, + DVD_Stream_Audio = $00000010, + DVD_Stream_Subpicture = $00000011, + DVD_Stream_Angle = $00000012, + DVD_Channel_Audio = $00000020, + DVD_General_Name = $00000030, + DVD_General_Comments = $00000031, + DVD_Title_Series = $00000038, + DVD_Title_Movie = $00000039, + DVD_Title_Video = $0000003A, + DVD_Title_Album = $0000003B, + DVD_Title_Song = $0000003C, + DVD_Title_Other = $0000003F, + DVD_Title_Sub_Series = $00000040, + DVD_Title_Sub_Movie = $00000041, + DVD_Title_Sub_Video = $00000042, + DVD_Title_Sub_Album = $00000043, + DVD_Title_Sub_Song = $00000044, + DVD_Title_Sub_Other = $00000047, + DVD_Title_Orig_Series = $00000048, + DVD_Title_Orig_Movie = $00000049, + DVD_Title_Orig_Video = $0000004A, + DVD_Title_Orig_Album = $0000004B, + DVD_Title_Orig_Song = $0000004C, + DVD_Title_Orig_Other = $0000004F, + DVD_Other_Scene = $00000050, + DVD_Other_Cut = $00000051, + DVD_Other_Take = $00000052 + ); +{$ENDIF} +{$EXTERNALSYM DVD_TextStringType} +type + TDVDTextStringType = DVD_TextStringType; + + // For IDVDControl2.SetOption flags + DVD_OPTION_FLAG = ( + {$IFNDEF COMPILER6_UP} + DVD_Option_INVALID_0, + DVD_ResetOnStop, + {$ELSE} + DVD_ResetOnStop = 1, + {$ENDIF} + DVD_NotifyParentalLevelChange, + DVD_HMSF_TimeCodeEvents, + DVD_AudioDuringFFwdRew // default FALSE (or by reg) // DirectX9 Specific + ); + {$EXTERNALSYM DVD_OPTION_FLAG} + TDVDOptionFlag = DVD_OPTION_FLAG; + + tagDVD_DOMAIN = ( + {$IFNDEF COMPILER6_UP} + DVD_DOMAIN_INVALID_0, + DVD_DOMAIN_FirstPlay, + {$ELSE} + DVD_DOMAIN_FirstPlay = 1, + {$ENDIF} + DVD_DOMAIN_VideoManagerMenu, + DVD_DOMAIN_VideoTitleSetMenu, + DVD_DOMAIN_Title, + DVD_DOMAIN_Stop + ); + {$EXTERNALSYM tagDVD_DOMAIN} + DVD_DOMAIN = tagDVD_DOMAIN; + {$EXTERNALSYM DVD_DOMAIN} + TDVDDomain = DVD_DOMAIN; + + + tagDVD_MENU_ID = ( + {$EXTERNALSYM tagDVD_MENU_ID} + {$IFNDEF COMPILER6_UP} + DVD_MENU_INVALID_0, + DVD_MENU_INVALID_1, + DVD_MENU_Title, + {$ELSE} + DVD_MENU_Title = 2, + {$ENDIF} + DVD_MENU_Root, + DVD_MENU_Subpicture, + DVD_MENU_Audio, + DVD_MENU_Angle, + DVD_MENU_Chapter + ); + DVD_MENU_ID = tagDVD_MENU_ID; + {$EXTERNALSYM DVD_MENU_ID} + TDVDMenuID = DVD_MENU_ID; + + tagDVD_DISC_SIDE = ( + {$IFNDEF COMPILER6_UP} + DVD_SIDE_INVALID_0, + DVD_SIDE_A, + DVD_SIDE_B + {$ELSE} + DVD_SIDE_A = 1, + DVD_SIDE_B = 2 + {$ENDIF} + ); + {$EXTERNALSYM tagDVD_DISC_SIDE} + DVD_DISC_SIDE = tagDVD_DISC_SIDE; + {$EXTERNALSYM DVD_DISC_SIDE} + TDVDDiscSide = DVD_DISC_SIDE; + + tagDVD_PREFERRED_DISPLAY_MODE = ( + DISPLAY_CONTENT_DEFAULT, + DISPLAY_16x9, + DISPLAY_4x3_PANSCAN_PREFERRED, + DISPLAY_4x3_LETTERBOX_PREFERRED + ); + {$EXTERNALSYM tagDVD_PREFERRED_DISPLAY_MODE} + DVD_PREFERRED_DISPLAY_MODE = tagDVD_PREFERRED_DISPLAY_MODE; + {$EXTERNALSYM DVD_PREFERRED_DISPLAY_MODE} + TDVDPreferredDisplayMode = DVD_PREFERRED_DISPLAY_MODE; + + tagDVD_VIDEO_COMPRESSION = ( + DVD_VideoCompression_Other, + DVD_VideoCompression_MPEG1, + DVD_VideoCompression_MPEG22 + ); + {$EXTERNALSYM tagDVD_VIDEO_COMPRESSION} + DVD_VIDEO_COMPRESSION = tagDVD_VIDEO_COMPRESSION; + {$EXTERNALSYM DVD_VIDEO_COMPRESSION} + TDVDVideoCompression = DVD_VIDEO_COMPRESSION; + + tagDVD_AUDIO_APPMODE = ( + DVD_AudioMode_None, + DVD_AudioMode_Karaoke, + DVD_AudioMode_Surround, + DVD_AudioMode_Other + ); + {$EXTERNALSYM tagDVD_AUDIO_APPMODE} + DVD_AUDIO_APPMODE = tagDVD_AUDIO_APPMODE; + {$EXTERNALSYM DVD_AUDIO_APPMODE} + TDVDAudioAPPMode = DVD_AUDIO_APPMODE; + + tagDVD_AUDIO_FORMAT = ( + DVD_AudioFormat_AC3, + DVD_AudioFormat_MPEG1, + DVD_AudioFormat_MPEG1_DRC, + DVD_AudioFormat_MPEG2, + DVD_AudioFormat_MPEG2_DRC, + DVD_AudioFormat_LPCM, + DVD_AudioFormat_DTS, + DVD_AudioFormat_SDDS, + DVD_AudioFormat_Other + ); + {$EXTERNALSYM tagDVD_AUDIO_FORMAT} + DVD_AUDIO_FORMAT = tagDVD_AUDIO_FORMAT; + {$EXTERNALSYM DVD_AUDIO_FORMAT} + TDVDAudioFormat = DVD_AUDIO_FORMAT; + + +// DVD_KARAOKE_DOWNMIX +const + DVD_Mix_0to0 = $1 ; + {$EXTERNALSYM DVD_Mix_0to0} + DVD_Mix_1to0 = $2 ; + {$EXTERNALSYM DVD_Mix_1to0} + DVD_Mix_2to0 = $4 ; + {$EXTERNALSYM DVD_Mix_2to0} + DVD_Mix_3to0 = $8 ; + {$EXTERNALSYM DVD_Mix_3to0} + DVD_Mix_4to0 = $10 ; + {$EXTERNALSYM DVD_Mix_4to0} + DVD_Mix_Lto0 = $20 ; + {$EXTERNALSYM DVD_Mix_Lto0} + DVD_Mix_Rto0 = $40 ; + {$EXTERNALSYM DVD_Mix_Rto0} + DVD_Mix_0to1 = $100 ; + {$EXTERNALSYM DVD_Mix_0to1} + DVD_Mix_1to1 = $200 ; + {$EXTERNALSYM DVD_Mix_1to1} + DVD_Mix_2to1 = $400 ; + {$EXTERNALSYM DVD_Mix_2to1} + DVD_Mix_3to1 = $800 ; + {$EXTERNALSYM DVD_Mix_3to1} + DVD_Mix_4to1 = $1000; + {$EXTERNALSYM DVD_Mix_4to1} + DVD_Mix_Lto1 = $2000; + {$EXTERNALSYM DVD_Mix_Lto1} + DVD_Mix_Rto1 = $4000; + {$EXTERNALSYM DVD_Mix_Rto1} + +type + tagDVD_AUDIO_LANG_EXT = ( + DVD_AUD_EXT_NotSpecified, + DVD_AUD_EXT_Captions, + DVD_AUD_EXT_VisuallyImpaired, + DVD_AUD_EXT_DirectorComments1, + DVD_AUD_EXT_DirectorComments2 + ); + {$EXTERNALSYM tagDVD_AUDIO_LANG_EXT} + DVD_AUDIO_LANG_EXT = tagDVD_AUDIO_LANG_EXT; + {$EXTERNALSYM DVD_AUDIO_LANG_EXT} + TDVDAudioLangExt = DVD_AUDIO_LANG_EXT; + + tagDVD_SUBPICTURE_TYPE = ( + DVD_SPType_NotSpecified, + DVD_SPType_Language, + DVD_SPType_Other + ); + {$EXTERNALSYM tagDVD_SUBPICTURE_TYPE} + DVD_SUBPICTURE_TYPE = tagDVD_SUBPICTURE_TYPE; + {$EXTERNALSYM DVD_SUBPICTURE_TYPE} + TDVDSubpictureType = DVD_SUBPICTURE_TYPE; + + tagDVD_SUBPICTURE_CODING = ( + DVD_SPCoding_RunLength, + DVD_SPCoding_Extended, + DVD_SPCoding_Other + ); + {$EXTERNALSYM tagDVD_SUBPICTURE_CODING} + DVD_SUBPICTURE_CODING = tagDVD_SUBPICTURE_CODING; + {$EXTERNALSYM DVD_SUBPICTURE_CODING} + TDVDSubpictureCoding = DVD_SUBPICTURE_CODING; + + {$IFNDEF COMPILER6_UP} + tagDVD_SUBPICTURE_LANG_EXT = {$IFDEF TYPE_IDENTITY}type {$ENDIF}LongWord; + const + DVD_SP_EXT_NotSpecified = 0; + DVD_SP_EXT_Caption_Normal = 1; + DVD_SP_EXT_Caption_Big = 2; + DVD_SP_EXT_Caption_Children = 3; + DVD_SP_EXT_CC_Normal = 5; + DVD_SP_EXT_CC_Big = 6; + DVD_SP_EXT_CC_Children = 7; + DVD_SP_EXT_Forced = 9; + DVD_SP_EXT_DirectorComments_Normal = 13; + DVD_SP_EXT_DirectorComments_Big = 14; + DVD_SP_EXT_DirectorComments_Children = 15; + {$ELSE} + tagDVD_SUBPICTURE_LANG_EXT = ( + DVD_SP_EXT_NotSpecified = 0, + DVD_SP_EXT_Caption_Normal = 1, + DVD_SP_EXT_Caption_Big = 2, + DVD_SP_EXT_Caption_Children = 3, + DVD_SP_EXT_CC_Normal = 5, + DVD_SP_EXT_CC_Big = 6, + DVD_SP_EXT_CC_Children = 7, + DVD_SP_EXT_Forced = 9, + DVD_SP_EXT_DirectorComments_Normal = 13, + DVD_SP_EXT_DirectorComments_Big = 14, + DVD_SP_EXT_DirectorComments_Children = 15 + ); + {$ENDIF} +type + {$EXTERNALSYM tagDVD_SUBPICTURE_LANG_EXT} + DVD_SUBPICTURE_LANG_EXT = tagDVD_SUBPICTURE_LANG_EXT; + {$EXTERNALSYM DVD_SUBPICTURE_LANG_EXT} + TDVDSubpictureLangExt = DVD_SUBPICTURE_LANG_EXT; + +type + tagDVD_KARAOKE_ASSIGNMENT = ( + DVD_Assignment_reserved0, + DVD_Assignment_reserved1, + DVD_Assignment_LR, + DVD_Assignment_LRM, + DVD_Assignment_LR1, + DVD_Assignment_LRM1, + DVD_Assignment_LR12, + DVD_Assignment_LRM12 + ); + {$EXTERNALSYM tagDVD_KARAOKE_ASSIGNMENT} + DVD_KARAOKE_ASSIGNMENT = tagDVD_KARAOKE_ASSIGNMENT; + {$EXTERNALSYM DVD_KARAOKE_ASSIGNMENT} + TDVDKaraokeAssignment = DVD_KARAOKE_ASSIGNMENT; + + DVD_RELATIVE_BUTTON = ( + {$IFNDEF COMPILER6_UP} + DVD_Relative_INVALID_0, + DVD_Relative_Upper, + DVD_Relative_Lower, + DVD_Relative_Left, + DVD_Relative_Right + {$ELSE} + DVD_Relative_Upper = 1, + DVD_Relative_Lower = 2, + DVD_Relative_Left = 3, + DVD_Relative_Right = 4 + {$ENDIF} + ); + {$EXTERNALSYM DVD_RELATIVE_BUTTON} + TDVDRelativeButton = DVD_RELATIVE_BUTTON; + + DVD_REGISTER = {$IFDEF TYPE_IDENTITY}type {$ENDIF}Word; + {$EXTERNALSYM DVD_REGISTER} + GPRMArray = array[0..15] of DVD_REGISTER; + {$EXTERNALSYM GPRMArray} + + SPRMArray = array[0..23] of DVD_REGISTER; + {$EXTERNALSYM SPRMArray} + TSPRMArray = SPRMArray; + + tagDVD_ATR = record + ulCAT : ULONG; + pbATRI: array[0..767] of Byte; + end; + {$EXTERNALSYM tagDVD_ATR} + DVD_ATR = tagDVD_ATR; + {$EXTERNALSYM DVD_ATR} + TDVDAtr = tagDVD_ATR; + + DVD_VideoATR = array[0..1] of Byte; + {$EXTERNALSYM DVD_VideoATR} + DVD_AudioATR = array[0..7] of Byte; + {$EXTERNALSYM DVD_AudioATR} + DVD_SubpictureATR = array[0..5] of Byte; + {$EXTERNALSYM DVD_SubpictureATR} + + (*** DVD_SubpictureATR methods ***) + tagDVD_FRAMERATE = ( + {$IFNDEF COMPILER6_UP} + DVD_FPS_INVALID_0, + DVD_FPS_25, + DVD_FPS_INVALID_2, + DVD_FPS_30NonDrop + {$ELSE} + DVD_FPS_25 = 1, + DVD_FPS_30NonDrop = 3 + {$ENDIF} + ); + + {$EXTERNALSYM tagDVD_FRAMERATE} + DVD_FRAMERATE = tagDVD_FRAMERATE; + {$EXTERNALSYM DVD_FRAMERATE} + TDVDFramerate = DVD_FRAMERATE; + + +//typedef struct tagDVD_TIMECODE +//{ +// ULONG Hours1 :4; // Hours +// ULONG Hours10 :4; // Tens of Hours +// +// ULONG Minutes1 :4; // Minutes +// ULONG Minutes10:4; // Tens of Minutes +// +// ULONG Seconds1 :4; // Seconds +// ULONG Seconds10:4; // Tens of Seconds +// +// ULONG Frames1 :4; // Frames +// ULONG Frames10 :2; // Tens of Frames +// +// ULONG FrameRateCode: 2; // use DVD_FRAMERATE to indicate frames/sec and drop/non-drop +//} DVD_TIMECODE; + + tagDVD_TIMECODE = record + Hours1 : byte; + Hours10 : byte; + Minutes1 : byte; + Minutes10 : byte; + Seconds1 : byte; + Seconds10 : byte; + Frames1 : byte; + Frames10 : byte; + FrameRateCode: byte; + end; + {$EXTERNALSYM tagDVD_TIMECODE} + DVD_TIMECODE = tagDVD_TIMECODE; + {$EXTERNALSYM DVD_TIMECODE} + TDVDTimeCode = tagDVD_TIMECODE; + +//DVD_TIMECODE_FLAGS +const + DVD_TC_FLAG_25fps = $1; + {$EXTERNALSYM DVD_TC_FLAG_25fps} + DVD_TC_FLAG_30fps = $2; + {$EXTERNALSYM DVD_TC_FLAG_30fps} + DVD_TC_FLAG_DropFrame = $4; + {$EXTERNALSYM DVD_TC_FLAG_DropFrame} + DVD_TC_FLAG_Interpolated = $8; + {$EXTERNALSYM DVD_TC_FLAG_Interpolated} + +type + PDVDHMSFTimeCode = ^TDVDHMSFTimeCode; + tagDVD_HMSF_TIMECODE = record + {$EXTERNALSYM tagDVD_HMSF_TIMECODE} + bHours : BYTE; + bMinutes : BYTE; + bSeconds : BYTE; + bFrames : BYTE; + end; + DVD_HMSF_TIMECODE = tagDVD_HMSF_TIMECODE; + {$EXTERNALSYM DVD_HMSF_TIMECODE} + TDVDHMSFTimeCode = tagDVD_HMSF_TIMECODE; + + tagDVD_PLAYBACK_LOCATION2 = record + TitleNum : ULONG; + ChapterNum : ULONG; + TimeCode : DVD_HMSF_TIMECODE; + TimeCodeFlags : ULONG; + end; + {$EXTERNALSYM tagDVD_PLAYBACK_LOCATION2} + DVD_PLAYBACK_LOCATION2 = tagDVD_PLAYBACK_LOCATION2; + {$EXTERNALSYM DVD_PLAYBACK_LOCATION2} + TDVDPlayBackLocation2 = tagDVD_PLAYBACK_LOCATION2; + + tagDVD_PLAYBACK_LOCATION = record + TitleNum : ULONG; + ChapterNum : ULONG; + TimeCode : ULONG; + end; + {$EXTERNALSYM tagDVD_PLAYBACK_LOCATION} + DVD_PLAYBACK_LOCATION = tagDVD_PLAYBACK_LOCATION; + {$EXTERNALSYM DVD_PLAYBACK_LOCATION} + TDVDPlaybackLocation = tagDVD_PLAYBACK_LOCATION; + + VALID_UOP_SOMTHING_OR_OTHER = {$IFDEF TYPE_IDENTITY}type {$ENDIF} DWord; + {$EXTERNALSYM VALID_UOP_SOMTHING_OR_OTHER} + +VALID_UOP_FLAG = {$IFDEF TYPE_IDENTITY}type {$ENDIF} DWord; +{$EXTERNALSYM VALID_UOP_FLAG} + const + UOP_FLAG_Play_Title_Or_AtTime = $1; + {$EXTERNALSYM UOP_FLAG_Play_Title_Or_AtTime} + UOP_FLAG_Play_Chapter = $2; + {$EXTERNALSYM UOP_FLAG_Play_Chapter} + UOP_FLAG_Play_Title = $4; + {$EXTERNALSYM UOP_FLAG_Play_Title} + UOP_FLAG_Stop = $8; + {$EXTERNALSYM UOP_FLAG_Stop} + UOP_FLAG_ReturnFromSubMenu = $10; + {$EXTERNALSYM UOP_FLAG_ReturnFromSubMenu} + UOP_FLAG_Play_Chapter_Or_AtTime = $20; + {$EXTERNALSYM UOP_FLAG_Play_Chapter_Or_AtTime} + UOP_FLAG_PlayPrev_Or_Replay_Chapter = $40; + {$EXTERNALSYM UOP_FLAG_PlayPrev_Or_Replay_Chapter} + UOP_FLAG_PlayNext_Chapter = $80; + {$EXTERNALSYM UOP_FLAG_PlayNext_Chapter} + UOP_FLAG_Play_Forwards = $100; + {$EXTERNALSYM UOP_FLAG_Play_Forwards} + UOP_FLAG_Play_Backwards = $200; + {$EXTERNALSYM UOP_FLAG_Play_Backwards} + UOP_FLAG_ShowMenu_Title = $400; + {$EXTERNALSYM UOP_FLAG_ShowMenu_Title} + UOP_FLAG_ShowMenu_Root = $800; + {$EXTERNALSYM UOP_FLAG_ShowMenu_Root} + UOP_FLAG_ShowMenu_SubPic = $1000; + {$EXTERNALSYM UOP_FLAG_ShowMenu_SubPic} + UOP_FLAG_ShowMenu_Audio = $2000; + {$EXTERNALSYM UOP_FLAG_ShowMenu_Audio} + UOP_FLAG_ShowMenu_Angle = $4000; + {$EXTERNALSYM UOP_FLAG_ShowMenu_Angle} + UOP_FLAG_ShowMenu_Chapter = $8000; + {$EXTERNALSYM UOP_FLAG_ShowMenu_Chapter} + UOP_FLAG_Resume = $10000; + {$EXTERNALSYM UOP_FLAG_Resume} + UOP_FLAG_Select_Or_Activate_Button = $20000; + {$EXTERNALSYM UOP_FLAG_Select_Or_Activate_Button} + UOP_FLAG_Still_Off = $40000; + {$EXTERNALSYM UOP_FLAG_Still_Off} + UOP_FLAG_Pause_On = $80000; + {$EXTERNALSYM UOP_FLAG_Pause_On} + UOP_FLAG_Select_Audio_Stream = $100000; + {$EXTERNALSYM UOP_FLAG_Select_Audio_Stream} + UOP_FLAG_Select_SubPic_Stream = $200000; + {$EXTERNALSYM UOP_FLAG_Select_SubPic_Stream} + UOP_FLAG_Select_Angle = $400000; + {$EXTERNALSYM UOP_FLAG_Select_Angle} + UOP_FLAG_Select_Karaoke_Audio_Presentation_Mode = $800000; + {$EXTERNALSYM UOP_FLAG_Select_Karaoke_Audio_Presentation_Mode} + UOP_FLAG_Select_Video_Mode_Preference = $1000000; + {$EXTERNALSYM UOP_FLAG_Select_Video_Mode_Preference} + +type + DVD_TextCharSet = ( + DVD_CharSet_Unicode, + DVD_CharSet_ISO646, + DVD_CharSet_JIS_Roman_Kanji, + DVD_CharSet_ISO8859_1, + DVD_CharSet_ShiftJIS_Kanji_Roman_Katakana + ); + {$EXTERNALSYM DVD_TextCharSet} + TDVDTextCharSet = DVD_TextCharSet; + +const + DVD_TITLE_MENU = $000; + {$EXTERNALSYM DVD_TITLE_MENU} + DVD_STREAM_DATA_CURRENT = $800; + {$EXTERNALSYM DVD_STREAM_DATA_CURRENT} + DVD_STREAM_DATA_VMGM = $400; + {$EXTERNALSYM DVD_STREAM_DATA_VMGM} + DVD_STREAM_DATA_VTSM = $401; + {$EXTERNALSYM DVD_STREAM_DATA_VTSM} + DVD_DEFAULT_AUDIO_STREAM = $0f ; + {$EXTERNALSYM DVD_DEFAULT_AUDIO_STREAM} + +type + tagDVD_DECODER_CAPS = record + dwSize : DWORD; + dwAudioCaps : DWORD; + dFwdMaxRateVideo : double; + dFwdMaxRateAudio : double; + dFwdMaxRateSP : double; + dBwdMaxRateVideo : double; + dBwdMaxRateAudio : double; + dBwdMaxRateSP : double; + dwRes1 : DWORD; + dwRes2 : DWORD; + dwRes3 : DWORD; + dwRes4 : DWORD; + end; + {$EXTERNALSYM tagDVD_DECODER_CAPS} + DVD_DECODER_CAPS = tagDVD_DECODER_CAPS; + {$EXTERNALSYM DVD_DECODER_CAPS} + TDVDDecoderCaps = tagDVD_DECODER_CAPS; + +const + DVD_AUDIO_CAPS_AC3 = $00000001; + {$EXTERNALSYM DVD_AUDIO_CAPS_AC3} + DVD_AUDIO_CAPS_MPEG2 = $00000002; + {$EXTERNALSYM DVD_AUDIO_CAPS_MPEG2} + DVD_AUDIO_CAPS_LPCM = $00000004; + {$EXTERNALSYM DVD_AUDIO_CAPS_LPCM} + DVD_AUDIO_CAPS_DTS = $00000008; + {$EXTERNALSYM DVD_AUDIO_CAPS_DTS} + DVD_AUDIO_CAPS_SDDS = $00000010; + {$EXTERNALSYM DVD_AUDIO_CAPS_SDDS} + +type + tagDVD_VideoAttributes = record + fPanscanPermitted : BOOL; + fLetterboxPermitted : BOOL; + ulAspectX : ULONG; + ulAspectY : ULONG; + ulFrameRate : ULONG; + ulFrameHeight : ULONG; + Compression : DVD_VIDEO_COMPRESSION; + fLine21Field1InGOP : BOOL; + fLine21Field2InGOP : BOOL; + ulSourceResolutionX : ULONG; + ulSourceResolutionY : ULONG; + fIsSourceLetterboxed : BOOL; + fIsFilmMode : BOOL; + end; + {$EXTERNALSYM tagDVD_VideoAttributes} + DVD_VideoAttributes = tagDVD_VideoAttributes; + {$EXTERNALSYM DVD_VideoAttributes} + TDVDVideoAttributes = tagDVD_VideoAttributes; + + tagDVD_SubpictureAttributes = record + Type_ : DVD_SUBPICTURE_TYPE ; + CodingMode : DVD_SUBPICTURE_CODING ; + Language : LCID ; + LanguageExtension : DVD_SUBPICTURE_LANG_EXT ; + end; + {$EXTERNALSYM tagDVD_SubpictureAttributes} + DVD_SubpictureAttributes = tagDVD_SubpictureAttributes; + {$EXTERNALSYM DVD_SubpictureAttributes} + TDVDSubpictureAttributes = tagDVD_SubpictureAttributes; + + tagDVD_TITLE_APPMODE = ( + {$IFNDEF COMPILER6_UP} + DVD_AppMode_Not_Specified, + DVD_AppMode_Karaoke, + DVD_AppMode_INVALID_2, + DVD_AppMode_Other + {$ELSE} + DVD_AppMode_Not_Specified = 0, + DVD_AppMode_Karaoke = 1, + DVD_AppMode_Other = 3 + {$ENDIF} + ); + {$EXTERNALSYM tagDVD_TITLE_APPMODE} + DVD_TITLE_APPMODE = tagDVD_TITLE_APPMODE; + {$EXTERNALSYM DVD_TITLE_APPMODE} + TDVDTitleAPPMode = DVD_TITLE_APPMODE; + + tagDVD_MUA_MixingInfo = record + fMixTo0 : BOOL; + fMixTo1 : BOOL; + fMix0InPhase : BOOL; + fMix1InPhase : BOOL; + dwSpeakerPosition : DWORD; + end; + {$EXTERNALSYM tagDVD_MUA_MixingInfo} + DVD_MUA_MixingInfo = tagDVD_MUA_MixingInfo; + {$EXTERNALSYM DVD_MUA_MixingInfo} + TDVDMUAMixingInfo = tagDVD_MUA_MixingInfo; + + tagDVD_MUA_Coeff = record + log2_alpha : Double; + log2_beta : Double; + end; + {$EXTERNALSYM tagDVD_MUA_Coeff} + DVD_MUA_Coeff = tagDVD_MUA_Coeff; + {$EXTERNALSYM DVD_MUA_Coeff} + TDVDMUACoeff = tagDVD_MUA_Coeff; + + tagDVD_MultichannelAudioAttributes = record + Info : array[0..7] of DVD_MUA_MixingInfo; + Coeff : array[0..7] of DVD_MUA_Coeff; + end; + {$EXTERNALSYM tagDVD_MultichannelAudioAttributes} + DVD_MultichannelAudioAttributes = tagDVD_MultichannelAudioAttributes; + {$EXTERNALSYM DVD_MultichannelAudioAttributes} + TDVDMultichannelAudioAttributes = tagDVD_MultichannelAudioAttributes; + +// DVD_KARAOKE_CONTENTS +const + DVD_Karaoke_GuideVocal1 = $1; + {$EXTERNALSYM DVD_Karaoke_GuideVocal1} + DVD_Karaoke_GuideVocal2 = $2; + {$EXTERNALSYM DVD_Karaoke_GuideVocal2} + DVD_Karaoke_GuideMelody1 = $4; + {$EXTERNALSYM DVD_Karaoke_GuideMelody1} + DVD_Karaoke_GuideMelody2 = $8; + {$EXTERNALSYM DVD_Karaoke_GuideMelody2} + DVD_Karaoke_GuideMelodyA = $10; + {$EXTERNALSYM DVD_Karaoke_GuideMelodyA} + DVD_Karaoke_GuideMelodyB = $20; + {$EXTERNALSYM DVD_Karaoke_GuideMelodyB} + DVD_Karaoke_SoundEffectA = $40; + {$EXTERNALSYM DVD_Karaoke_SoundEffectA} + DVD_Karaoke_SoundEffectB = $80; + {$EXTERNALSYM DVD_Karaoke_SoundEffectB} + +type + + tagDVD_AudioAttributes = record + AppMode : DVD_AUDIO_APPMODE; + AppModeData : BYTE; + AudioFormat : DVD_AUDIO_FORMAT; + Language : LCID; + LanguageExtension : DVD_AUDIO_LANG_EXT; + fHasMultichannelInfo : BOOL; + dwFrequency : DWORD; + bQuantization : BYTE; + bNumberOfChannels : BYTE; + dwReserved : array[0..1] of DWORD; + end; + {$EXTERNALSYM tagDVD_AudioAttributes} + DVD_AudioAttributes = tagDVD_AudioAttributes; + {$EXTERNALSYM DVD_AudioAttributes} + TDVDAudioAttributes = tagDVD_AudioAttributes; + + tagDVD_TitleMainAttributes = record + AppMode: DVD_TITLE_APPMODE ; + VideoAttributes : DVD_VideoAttributes; + ulNumberOfAudioStreams : ULONG ; + AudioAttributes : array[0..7] of DVD_AudioAttributes; + MultichannelAudioAttributes : array[0..7] of DVD_MultichannelAudioAttributes; + ulNumberOfSubpictureStreams : ULONG ; + SubpictureAttributes : array[0..31] of DVD_SubpictureAttributes; + end; + {$EXTERNALSYM tagDVD_TitleMainAttributes} + DVD_TitleAttributes = tagDVD_TitleMainAttributes; + {$EXTERNALSYM DVD_TitleAttributes} + TDVDTitleAttributes = tagDVD_TitleMainAttributes; + + tagDVD_MenuAttributes = record + fCompatibleRegion : array[0..7] of BOOL; + VideoAttributes : DVD_VideoAttributes; + fAudioPresent : BOOL; + AudioAttributes : DVD_AudioAttributes; + fSubpicturePresent : BOOL; + SubpictureAttributes : DVD_SubpictureAttributes; + end; + {$EXTERNALSYM tagDVD_MenuAttributes} + DVD_MenuAttributes = tagDVD_MenuAttributes; + {$EXTERNALSYM DVD_MenuAttributes} + TDVDMenuAttributes = tagDVD_MenuAttributes; + + tagDVD_KaraokeAttributes = record + bVersion : BYTE; + fMasterOfCeremoniesInGuideVocal1 : BOOL; + fDuet : BOOL; + ChannelAssignment : TDVDKaraokeAssignment; + wChannelContents : array[0..7] of WORD; + end; + {$EXTERNALSYM tagDVD_KaraokeAttributes} + DVD_KaraokeAttributes = tagDVD_KaraokeAttributes; + {$EXTERNALSYM DVD_KaraokeAttributes} + TDVDKaraokeAttributes = tagDVD_KaraokeAttributes; + + +const + DVD_PARENTAL_LEVEL_8 = $8000; + {$EXTERNALSYM DVD_PARENTAL_LEVEL_8} + DVD_PARENTAL_LEVEL_7 = $4000; + {$EXTERNALSYM DVD_PARENTAL_LEVEL_7} + DVD_PARENTAL_LEVEL_6 = $2000; + {$EXTERNALSYM DVD_PARENTAL_LEVEL_6} + DVD_PARENTAL_LEVEL_5 = $1000; + {$EXTERNALSYM DVD_PARENTAL_LEVEL_5} + DVD_PARENTAL_LEVEL_4 = $0800; + {$EXTERNALSYM DVD_PARENTAL_LEVEL_4} + DVD_PARENTAL_LEVEL_3 = $0400; + {$EXTERNALSYM DVD_PARENTAL_LEVEL_3} + DVD_PARENTAL_LEVEL_2 = $0200; + {$EXTERNALSYM DVD_PARENTAL_LEVEL_2} + DVD_PARENTAL_LEVEL_1 = $0100; + {$EXTERNALSYM DVD_PARENTAL_LEVEL_1} + +type + DVD_CMD_FLAGS = {$IFDEF TYPE_IDENTITY}type {$ENDIF} DWORD; + {$EXTERNALSYM DVD_CMD_FLAGS} + +const + DVD_CMD_FLAG_None = $00000000; + {$EXTERNALSYM DVD_CMD_FLAG_None} + DVD_CMD_FLAG_Flush = $00000001; + {$EXTERNALSYM DVD_CMD_FLAG_Flush} + DVD_CMD_FLAG_SendEvents = $00000002; + {$EXTERNALSYM DVD_CMD_FLAG_SendEvents} + DVD_CMD_FLAG_Block = $00000004; + {$EXTERNALSYM DVD_CMD_FLAG_Block} + DVD_CMD_FLAG_StartWhenRendered = $00000008; + {$EXTERNALSYM DVD_CMD_FLAG_StartWhenRendered} + DVD_CMD_FLAG_EndAfterRendered = $00000010; + {$EXTERNALSYM DVD_CMD_FLAG_EndAfterRendered} + +type + CountryCode = array[0..1] of BYTE; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IDvdState;'} + {$EXTERNALSYM IDvdState} + IDvdState = interface(IUnknown) + ['{86303d6d-1c4a-4087-ab42-f711167048ef}'] + (*** IDvdState methods ***) + function GetDiscID(out pullUniqueID: Double): HResult; stdcall; + function GetParentalLevel(out pulParentalLevel: ULONG): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IDvdCmd;'} + {$EXTERNALSYM IDvdCmd} + IDvdCmd = interface(IUnknown) + ['{5A4A97E4-94EE-4A55-9751-74B5643AA27D}'] + (*** IDvdCmd methods ***) + function WaitForStart: HResult; stdcall; + function WaitForEnd: HResult; stdcall; + end; + + //Deprecated Interface + {$HPPEMIT 'typedef System::DelphiInterface _di_IDvdControl;'} + {$EXTERNALSYM IDvdControl} + IDvdControl = interface(IUnknown) + ['{A70EFE61-E2A3-11D0-A9BE-00AA0061BE93}'] + (*** IDvdControl methods ***) + function TitlePlay(uiTitle: ULONG): HResult; stdcall; + function ChapterPlay(uiTitle: ULONG; uiChapter: ULONG): HResult; stdcall; + function TimePlay(uiTitle: ULONG; bcdTime: ULONG): HResult; stdcall; + function StopForResume: HResult; stdcall; + function GoUp: HResult; stdcall; + function TimeSearch(bcdTime: ULONG): HResult; stdcall; + function ChapterSearch(Chapter: ULONG): HResult; stdcall; + function PrevPGSearch: HResult; stdcall; + function TopPGSearch: HResult; stdcall; + function NextPGSearch: HResult; stdcall; + function ForwardScan(dwSpeed: double): HResult; stdcall; + function BackwardScan(dwSpeed: double): HResult; stdcall; + function MenuCall(MenuID: TDVDMenuID): HResult; stdcall; + function Resume: HResult; stdcall; + function UpperButtonSelect: HResult; stdcall; + function LowerButtonSelect: HResult; stdcall; + function LeftButtonSelect: HResult; stdcall; + function RightButtonSelect: HResult; stdcall; + function ButtonActivate: HResult; stdcall; + function ButtonSelectAndActivate(uiButton: ULONG): HResult; stdcall; + function StillOff: HResult; stdcall; + function PauseOn: HResult; stdcall; + function PauseOff: HResult; stdcall; + function MenuLanguageSelect(Language: LCID): HResult; stdcall; + function AudioStreamChange(nAudio: ULONG): HResult; stdcall; + function SubpictureStreamChange(nSubPicture: ULONG; bDisplay: BOOL): HResult; stdcall; + function AngleChange(ulAngle: ULONG): HResult; stdcall; + function ParentalLevelSelect(ulParentalLevel: ULONG): HResult; stdcall; + function ParentalCountrySelect(wCountry: Word): HResult; stdcall; + function KaraokeAudioPresentationModeChange(ulMode: ULONG): HResult; stdcall; + function VideoModePreferrence(ulPreferredDisplayMode: ULONG): HResult; stdcall; + function SetRoot(pszPath: LPCWSTR): HResult; stdcall; + function MouseActivate(point: TPoint): HResult; stdcall; + function MouseSelect(point: TPoint): HResult; stdcall; + function ChapterPlayAutoStop(ulTitle, ulChapter, ulChaptersToPlay: ULONG): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IDvdControl2;'} + {$EXTERNALSYM IDvdControl2} + IDvdControl2 = interface(IUnknown) + ['{33BC7430-EEC0-11D2-8201-00A0C9D74842}'] + (*** IDvdControl2 methods ***) + function PlayTitle(ulTitle, dwFlags: ULONG; var ppCmd: IDvdCmd): HResult; stdcall; + function PlayChapterInTitle(ulTitle, ulChapter: ULONG; dwFlags: DWORD; var ppCmd: IDvdCmd): HResult; stdcall; + function PlayAtTimeInTitle(ulTitle: ULONG; var pStartTime: TDVDHMSFTimeCode; dwFlags: DWORD; out ppCmd: IDvdCmd): HResult; stdcall; + function Stop: HResult; stdcall; + function ReturnFromSubmenu(dwFlags: DWORD; out ppCmd: IDvdCmd): HResult; stdcall; + function PlayAtTime(pTime: PDVDHMSFTimeCode; dwFlags: DWORD; out ppCmd: IDvdCmd): HResult; stdcall; + function PlayChapter(ulChapter: ULONG; dwFlags: DWORD; out ppCmd: IDvdCmd): HResult; stdcall; + function PlayPrevChapter(dwFlags: DWORD; out ppCmd: IDvdCmd): HResult; stdcall; + function ReplayChapter(dwFlags: DWORD; out ppCmd: IDvdCmd): HResult; stdcall; + function PlayNextChapter(dwFlags: DWORD; out ppCmd: IDvdCmd): HResult; stdcall; + function PlayForwards(dSpeed: double; dwFlags: DWORD; out ppCmd: IDvdCmd): HResult; stdcall; + function PlayBackwards(dSpeed: double; dwFlags: DWORD; out ppCmd: IDvdCmd): HResult; stdcall; + function ShowMenu(MenuID: TDVDMenuID; dwFlags: DVD_CMD_FLAGS;out ppCmd: IDvdCmd): HResult; stdcall; + function Resume(dwFlags: DWORD; out ppCmd: IDvdCmd): HResult; stdcall; + function SelectRelativeButton(buttonDir: TDVDRelativeButton): HResult; stdcall; + function ActivateButton: HResult; stdcall; + function SelectButton(ulButton: ULONG): HResult; stdcall; + function SelectAndActivateButton(ulButton: ULONG): HResult; stdcall; + function StillOff: HResult; stdcall; + function Pause(bState: BOOL): HResult; stdcall; + function SelectAudioStream(ulAudio: ULONG; dwFlags: DWORD; out ppCmd: IDvdCmd): HResult; stdcall; + function SelectSubpictureStream(ulSubPicture: ULONG; dwFlags: DWORD; out ppCmd: IDvdCmd): HResult; stdcall; + function SetSubpictureState(bState: BOOL; dwFlags: DWORD; out ppCmd: IDvdCmd): HResult; stdcall; + function SelectAngle(ulAngle: ULONG; dwFlags: DWORD; out ppCmd: IDvdCmd): HResult; stdcall; + function SelectParentalLevel(ulParentalLevel: ULONG): HResult; stdcall; + function SelectParentalCountry(bCountry: CountryCode): HResult; stdcall; + function SelectKaraokeAudioPresentationMode(ulMode: ULONG): HResult; stdcall; + function SelectVideoModePreference(ulPreferredDisplayMode: ULONG): HResult; stdcall; + function SetDVDDirectory(pszwPath: LPCWSTR): HResult; stdcall; + function ActivateAtPosition(point: TPoint): HResult; stdcall; + function SelectAtPosition(point : TPoint): HResult; stdcall; + function PlayChaptersAutoStop(ulTitle, ulChapter, ulChaptersToPlay: ULONG; dwFlags: DWORD; out ppCmd: IDvdCmd): HResult; stdcall; + function AcceptParentalLevelChange(bAccept: BOOL): HResult; stdcall; + function SetOption(flag: TDVDOptionFlag; fState: BOOL): HResult; stdcall; + function SetState(pState: IDvdState; dwFlags: DWORD; out ppCmd: IDvdCmd): HResult; stdcall; + function PlayPeriodInTitleAutoStop(ulTitle: ULONG; var pStartTime, pEndTime: TDVDHMSFTimeCode; dwFlags: DWORD; out ppCmd: IDvdCmd): HResult; stdcall; + function SetGPRM(ulIndex: ULONG; wValue: WORD; dwFlags: DWORD; out ppCmd: IDvdCmd): HResult; stdcall; + function SelectDefaultMenuLanguage(Language: LCID): HResult; stdcall; + function SelectDefaultAudioLanguage(Language: LCID; audioExtension: TDVDAudioLangExt): HResult; stdcall; + function SelectDefaultSubpictureLanguage(Language: LCID; subpictureExtension: TDVDSubpictureLangExt): HResult; stdcall; + end; + + //Deprecated Interface + {$HPPEMIT 'typedef System::DelphiInterface _di_IDvdInfo;'} + {$EXTERNALSYM IDvdInfo} + IDvdInfo = interface(IUnknown) + ['{A70EFE60-E2A3-11D0-A9BE-00AA0061BE93}'] + (*** IDvdInfo methods ***) + function GetCurrentDomain(out pDomain: TDVDDomain): HResult; stdcall; + function GetCurrentLocation(out pLocation: TDVDPlaybackLocation): HResult; stdcall; + function GetTotalTitleTime(out pTotalTime: ULONG): HResult; stdcall; + function GetCurrentButton(out pnButtonsAvailable, pnCurrentButton: ULONG): HResult; stdcall; + function GetCurrentAngle(out pnAnglesAvailable, pnCurrentAngle: ULONG): HResult; stdcall; + function GetCurrentAudio(out pnStreamsAvailable, pnCurrentStream: ULONG): HResult; stdcall; + function GetCurrentSubpicture(out pnStreamsAvailable, pnCurrentStream: ULONG; + out pIsDisabled: BOOL): HResult; stdcall; + function GetCurrentUOPS(out pUOP: VALID_UOP_SOMTHING_OR_OTHER): HResult; stdcall; + function GetAllSPRMs(var pRegisterArray: TSPRMArray): HResult; stdcall; + function GetAllGPRMs(var pRegisterArray: GPRMArray): HResult; stdcall; + function GetAudioLanguage(nStream: ULONG; out pLanguage: LCID): HResult; stdcall; + function GetSubpictureLanguage(nStream: ULONG; out pLanguage: LCID): HResult; stdcall; + function GetTitleAttributes(nTitle: ULONG; out pATR: TDVDAtr): HResult; stdcall; + function GetVMGAttributes(out pATR: TDVDAtr): HResult; stdcall; + function GetCurrentVideoAttributes(out pATR: DVD_VideoATR): HResult; stdcall; + function GetCurrentAudioAttributes(out pATR: DVD_AudioATR): HResult; stdcall; + function GetCurrentSubpictureAttributes(out pATR: DVD_SubpictureATR): HResult; stdcall; + function GetCurrentVolumeInfo(out pNumOfVol, pThisVolNum: ULONG; + out pSide: TDVDDiscSide; out pNumOfTitles: ULONG): HResult; stdcall; + function GetDVDTextInfo(out pTextManager: Byte; cbBufSize: ULONG; + out pcbActualSize: ULONG): HResult; stdcall; + function GetPlayerParentalLevel(out pParentalLevel, pCountryCode: ULONG): HResult; stdcall; + function GetNumberOfChapters(ulTitle: ULONG; out pNumberOfChapters: ULONG): HResult; stdcall; + function GetTitleParentalLevels(ulTitle: ULONG; out pParentalLevels: ULONG): HResult; stdcall; + function GetRoot(pRoot: PChar; cbBufSize: ULONG; out pcbActualSize: ULONG): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IDvdInfo2;'} + {$EXTERNALSYM IDvdInfo2} + IDvdInfo2 = interface(IUnknown) + ['{34151510-EEC0-11D2-8201-00A0C9D74842}'] + (*** IDvdInfo2 methods ***) + function GetCurrentDomain(out pDomain: TDVDDomain): HResult; stdcall; + function GetCurrentLocation(out pLocation: TDVDPlaybackLocation2): HResult; stdcall; + function GetTotalTitleTime(out pTotalTime: TDVDHMSFTimeCode; out ulTimeCodeFlags: ULONG): HResult; stdcall; + function GetCurrentButton(out pulButtonsAvailable, pulCurrentButton: ULONG): HResult; stdcall; + function GetCurrentAngle(out pulAnglesAvailable, pulCurrentAngle: ULONG): HResult; stdcall; + function GetCurrentAudio(out pulStreamsAvailable, pulCurrentStream: ULONG): HResult; stdcall; + function GetCurrentSubpicture(out pulStreamsAvailable, pulCurrentStream: ULONG; out pbIsDisabled: BOOL): HResult; stdcall; + function GetCurrentUOPS(out pulUOPs: ULONG): HResult; stdcall; + function GetAllSPRMs(out pRegisterArray: TSPRMArray): HResult; stdcall; + function GetAllGPRMs(out pRegisterArray: GPRMArray): HResult; stdcall; + function GetAudioLanguage(ulStream: ULONG; out pLanguage: LCID): HResult; stdcall; + function GetSubpictureLanguage(ulStream: ULONG; out pLanguage: LCID): HResult; stdcall; + function GetTitleAttributes(ulTitle: ULONG; out pMenu: TDVDMenuAttributes; out pTitle: TDVDTitleAttributes): HResult; stdcall; + function GetVMGAttributes(out pATR: TDVDMenuAttributes): HResult; stdcall; + function GetCurrentVideoAttributes(out pATR: TDVDVideoAttributes): HResult; stdcall; + function GetAudioAttributes(ulStream: ULONG; out pATR: TDVDAudioAttributes): HResult; stdcall; + function GetKaraokeAttributes(ulStream: ULONG; out pAttributes: TDVDKaraokeAttributes): HResult; stdcall; + function GetSubpictureAttributes(ulStream :ULONG; out pATR: TDVDSubpictureAttributes): HResult; stdcall; + function GetDVDVolumeInfo(out pulNumOfVolumes, pulVolume: ULONG; out pSide: TDVDDiscSide; out pulNumOfTitles: ULONG): HResult; stdcall; + function GetDVDTextNumberOfLanguages(out pulNumOfLangs: ULONG): HResult; stdcall; + function GetDVDTextLanguageInfo(ulLangIndex: ULONG; out pulNumOfStrings: ULONG; out pLangCode: LCID; out pbCharacterSet: TDVDTextCharSet): HResult; stdcall; + function GetDVDTextStringAsNative(ulLangIndex, ulStringIndex: ULONG; out pbBuffer; ulMaxBufferSize: ULONG; out pulActualSize: ULONG; out pType: TDVDTextStringType): HResult; stdcall; + function GetDVDTextStringAsUnicode(ulLangIndex, ulStringIndex: ULONG; out pchwBuffer; ulMaxBufferSize: ULONG; out pulActualSize: ULONG; out pType: TDVDTextStringType): HResult; stdcall; + function GetPlayerParentalLevel(out pulParentalLevel: ULONG; out pbCountryCode: CountryCode): HResult; stdcall; + function GetNumberOfChapters(ulTitle: ULONG; out pulNumOfChapters: ULONG): HResult; stdcall; + function GetTitleParentalLevels(ulTitle: ULONG; out pulParentalLevels: ULONG): HResult; stdcall; + function GetDVDDirectory(out pszwPath; ulMaxSize: ULONG; out pulActualSize: ULONG): HResult; stdcall; + function IsAudioStreamEnabled(ulStreamNum: ULONG; out pbEnabled: BOOL): HResult; stdcall; + function GetDiscID(pszwPath: LPCWSTR; out pullDiscID: Int64): HResult; stdcall; + function GetState(out pStateData: IDvdState): HResult; stdcall; + function GetMenuLanguages(out pLanguages: LCID; ulMaxLanguages: ULONG; out pulActualLanguages: ULONG): HResult; stdcall; + function GetButtonAtPosition(point: Tpoint;out pulButtonIndex: ULONG): HResult; stdcall; + function GetCmdFromEvent(lParam1: integer; out pCmdObj: IDvdCmd): HResult; stdcall; + function GetDefaultMenuLanguage(out pLanguage: LCID): HResult; stdcall; + function GetDefaultAudioLanguage(out pLanguage: LCID; out pAudioExtension: TDVDAudioLangExt): HResult; stdcall; + function GetDefaultSubpictureLanguage(out pLanguage: LCID; out pSubpictureExtension: TDVDSubpictureLangExt): HResult; stdcall; + function GetDecoderCaps(out pCaps: TDVDDecoderCaps): HResult; stdcall; + function GetButtonRect(ulButton: ULONG; out pRect: TRect): HResult; stdcall; + function IsSubpictureStreamEnabled(ulStreamNum: ULONG; out pbEnabled: BOOL): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IVideoFrameStep;'} + {$EXTERNALSYM IVideoFrameStep} + IVideoFrameStep = interface(IUnknown) + ['{e46a9787-2b71-444d-a4b5-1fab7b708d6a}'] + (*** IVideoFrameStep methods ***) + function Step(dwFrames: DWORD; pStepObject: IUnKnown): HResult; stdcall; + function CanStep(bMultiple: longint; pStepObject: IUnknown): HResult; stdcall; + function CancelStep: HResult; stdcall; + end; + + + +const + AM_DVD_HWDEC_PREFER = $01; // default + {$EXTERNALSYM AM_DVD_HWDEC_PREFER} + AM_DVD_HWDEC_ONLY = $02; + {$EXTERNALSYM AM_DVD_HWDEC_ONLY} + AM_DVD_SWDEC_PREFER = $04; + {$EXTERNALSYM AM_DVD_SWDEC_PREFER} + AM_DVD_SWDEC_ONLY = $08; + {$EXTERNALSYM AM_DVD_SWDEC_ONLY} + AM_DVD_NOVPE = $100; + {$EXTERNALSYM AM_DVD_NOVPE} + // DirectX9 Specific + AM_DVD_VMR9_ONLY = $800; // only use VMR9 (otherwise fail) for rendering + {$EXTERNALSYM AM_DVD_VMR9_ONLY} + + AM_DVD_STREAM_VIDEO = $1; + {$EXTERNALSYM AM_DVD_STREAM_VIDEO} + AM_DVD_STREAM_AUDIO = $2; + {$EXTERNALSYM AM_DVD_STREAM_AUDIO} + AM_DVD_STREAM_SUBPIC = $4; + {$EXTERNALSYM AM_DVD_STREAM_SUBPIC} + +type + AM_DVD_RENDERSTATUS = record + hrVPEStatus: HResult; + bDvdVolInvalid: BOOL; + bDvdVolUnknown: BOOL; + bNoLine21In: BOOL; + bNoLine21Out: BOOL; + iNumStreams: Integer; + iNumStreamsFailed: Integer; + dwFailedStreamsFlag: DWORD; + end; + {$EXTERNALSYM AM_DVD_RENDERSTATUS} + TAMDVDRenderStatus = AM_DVD_RENDERSTATUS; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IDvdGraphBuilder;'} + {$EXTERNALSYM IDvdGraphBuilder} + IDvdGraphBuilder = interface(IUnknown) + ['{FCC152B6-F372-11d0-8E00-00C04FD7C08B}'] + (*** IDvdGraphBuilder methods ***) + function GetFiltergraph(out ppGB: IGraphBuilder): HResult; stdcall; + function GetDvdInterface(const riid: TGUID; out ppvIF): HResult; stdcall; + function RenderDvdVideoVolume(lpcwszPathName: PWideChar; dwFlags: DWORD; + out pStatus: TAMDVDRenderStatus): HResult; stdcall; + end; + +//_AM_OVERLAY_NOTIFY_FLAGS +const + AM_OVERLAY_NOTIFY_VISIBLE_CHANGE = $1; + {$EXTERNALSYM AM_OVERLAY_NOTIFY_VISIBLE_CHANGE} + AM_OVERLAY_NOTIFY_SOURCE_CHANGE = $2; + {$EXTERNALSYM AM_OVERLAY_NOTIFY_SOURCE_CHANGE} + AM_OVERLAY_NOTIFY_DEST_CHANGE = $4; + {$EXTERNALSYM AM_OVERLAY_NOTIFY_DEST_CHANGE} + +type + {$HPPEMIT 'typedef System::DelphiInterface _di_IDDrawExclModeVideoCallback;'} + {$EXTERNALSYM IDDrawExclModeVideoCallback} + IDDrawExclModeVideoCallback = interface(IUnknown) + ['{913c24a0-20ab-11d2-9038-00a0c9697298}'] + (*** IDDrawExclModeVideoCallback methods ***) + function OnUpdateOverlay(bBefore: BOOL; dwFlags: DWORD; bOldVisible: BOOL; + var prcOldSrc, prcOldDest: TRECT; bNewVisible: BOOL; var prcNewSrc, prcNewDest: TRECT): HResult; stdcall; + function OnUpdateColorKey(var pKey: TCOLORKEY; dwColor: DWORD): HResult; stdcall; + function OnUpdateSize(dwWidth, dwHeight, dwARWidth, dwARHeight: DWORD): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IDDrawExclModeVideo;'} + {$EXTERNALSYM IDDrawExclModeVideo} + IDDrawExclModeVideo = interface(IUnknown) + ['{153ACC21-D83B-11d1-82BF-00A0C9696C8F}'] + (*** IDDrawExclModeVideo methods ***) + function SetDDrawObject(pDDrawObject: IDirectDraw): HResult; stdcall; + function GetDDrawObject(out ppDDrawObject: IDirectDraw; out pbUsingExternal: BOOL): HResult; stdcall; + function SetDDrawSurface(pDDrawSurface: IDirectDrawSurface): HResult; stdcall; + function GetDDrawSurface(out ppDDrawSurface: IDirectDrawSurface; out pbUsingExternal: BOOL): HResult; stdcall; + function SetDrawParameters(prcSource, prcTarget: PRECT): HResult; stdcall; + function GetNativeVideoProps(out pdwVideoWidth, pdwVideoHeight, pdwPictAspectRatioX,pdwPictAspectRatioY: DWORD): HResult; stdcall; + function SetCallbackInterface(pCallback: IDDrawExclModeVideoCallback; dwFlags: DWORD): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IPinConnection;'} + {$EXTERNALSYM IPinConnection} + IPinConnection = interface(IUnknown) + ['{4a9a62d3-27d4-403d-91e9-89f540e55534}'] + (*** IPinConnection methods ***) + function DynamicQueryAccept(var pmt: TAMMediaType): HResult; stdcall; + function NotifyEndOfStream(hNotifyEvent: THandle): HResult; stdcall; + function IsEndPin: HResult; stdcall; + function DynamicDisconnect: HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IPinFlowControl;'} + {$EXTERNALSYM IPinFlowControl} + IPinFlowControl = interface(IUnknown) + ['{c56e9858-dbf3-4f6b-8119-384af2060deb}'] + (*** IPinFlowControl methods ***) + function Block(dwBlockFlags: DWORD; hEvent: THandle): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IGraphConfigCallback;'} + {$EXTERNALSYM IGraphConfigCallback} + IGraphConfigCallback = interface(IUnknown) + ['{ade0fd60-d19d-11d2-abf6-00a0c905f375}'] + (*** IGraphConfigCallback methods ***) + function Reconfigure(var pvContext; dwFlags: DWORD): HResult; stdcall; + end; + +const + //_AM_PIN_FLOW_CONTROL_BLOCK_FLAGS + AM_PIN_FLOW_CONTROL_BLOCK = $1; + {$EXTERNALSYM AM_PIN_FLOW_CONTROL_BLOCK} + + //_AM_GRAPH_CONFIG_RECONNECT_FLAGS + AM_GRAPH_CONFIG_RECONNECT_DIRECTCONNECT = $1; + {$EXTERNALSYM AM_GRAPH_CONFIG_RECONNECT_DIRECTCONNECT} + AM_GRAPH_CONFIG_RECONNECT_CACHE_REMOVED_FILTERS = $2; + {$EXTERNALSYM AM_GRAPH_CONFIG_RECONNECT_CACHE_REMOVED_FILTERS} + AM_GRAPH_CONFIG_RECONNECT_USE_ONLY_CACHED_FILTERS = $4; + {$EXTERNALSYM AM_GRAPH_CONFIG_RECONNECT_USE_ONLY_CACHED_FILTERS} + + //_AM_FILTER_FLAGS + AM_FILTER_FLAGS_REMOVABLE = $1; + {$EXTERNALSYM AM_FILTER_FLAGS_REMOVABLE} + + //_REM_FILTER_FLAGS + REMFILTERF_LEAVECONNECTED = $1; + {$EXTERNALSYM REMFILTERF_LEAVECONNECTED} + +type + {$HPPEMIT 'typedef System::DelphiInterface _di_IGraphConfig;'} + {$EXTERNALSYM IGraphConfig} + IGraphConfig = interface(IUnknown) + ['{03A1EB8E-32BF-4245-8502-114D08A9CB88}'] + (*** IGraphConfig methods ***) + function Reconnect(pOutputPin, pInputPin: IPin; pmtFirstConnection: PAMMediaType; + pUsingFilter: IBaseFilter; hAbortEvent: THandle; dwFlags: DWORD): HResult; stdcall; + function Reconfigure(pCallback: IGraphConfigCallback; var pvContext; + dwFlags: DWORD; hAbortEvent: THandle): HResult; stdcall; + function AddFilterToCache(pFilter: IBaseFilter): HResult; stdcall; + function EnumCacheFilter(out pEnum: IEnumFilters): HResult; stdcall; + function RemoveFilterFromCache(pFilter: IBaseFilter): HResult; stdcall; + function GetStartTime(out prtStart: TReferenceTime): HResult; stdcall; + function PushThroughData(pOutputPin: IPin; pConnection: IPinConnection; hEventAbort: PHANDLE): HResult; stdcall; + function SetFilterFlags(pFilter: IBaseFilter; dwFlags: DWORD): HResult; stdcall; + function GetFilterFlags(pFilter: IBaseFilter; out pdwFlags: DWORD): HResult; stdcall; + function RemoveFilterEx(pFilter: IBaseFilter; Flags: DWORD): HResult; stdcall; + end; + +// Filter Chain Definition +// +// Filter chains have the following properties: +// +// - Each filter chain has one or more filters. +// +// - Each filter in a filter chain has at most one connected input pin and one +// connected output pin. For example, filters A, C, D, F, G, H, I, J and K +// (see the diagram below) can be in a filter chain because each one has at +// most one connected input pin and one connected output pin. +// +// - Any filter in a chain is reachable by any other filter in the chain. +// For example, in the filter chain F-G-H, F can reach H by following the F- +// G connection to G and then following the G-H connection to H. Filters F +// and J cannot be in the same filter chain because J is not reachable from +// F. Anotherwords, there no sequence of connected filters between F and J. +// +// - The start filter is the only filter in the filter chain who's input +// pin is not connected to another filter in the chain. For instance, F is +// the start filter in F-G-H because F's input pin is connected to E and E +// is not in the filter chain. G's input pin is connected to F and H's is +// connected to G. Both F and G are in the filter chain. +// +// - The end filter is the only filter in the filter chain who's output pin +// is not connected to another filter in the chain. For example, in the +// filter chain J-K, K is the end filter because K's output pin is +// connected to L. J's output pin is connected to K and K is in the J-K +// filter chain. +// +// +// --->|---| |---|---> +// | C |--->| D | +// |---| |---|--->|---| |---|--->|---| |---| |---| |---| +// | A |--->| B | | E |--->| F |--->| G |--->| H | +// |---| |---|--->|---|------------>|---| |---| |---| |---| +// | I |---> +// --->|---|---> +// +// |---| |---| |---| +// | J |--->| K |--->| L | +// |---| |---| |---| +// +// Example Filter Graph +// +// +// +// IFilterChain Methods Documentation +// +// HResult StartChain( [in] IBaseFilter *pStartFilter, [in] IBaseFilter *pEndFilter ); +// +// StartChain() switches all the filters in the chain into the running state +// If one of the filters will not switch to the running state, then all the filters +// in the chain are stopped. This method can only be called if the filter graph is +// running. +// +// Parameters: +// - pStartFilter [in] +// The first filter in the filter chain. Note that this can be the same +// filter as pEndFilter . +// +// - pEndFilter [in] +// The last filter in the filter chain. Note that this can be the same +// filter as pStartFilter. If pEndFilter is NULL then the filter chain extends +// from pStartFilter to the last downstream filter which can be in a filter chain. +// For example, IFilterChain::StartChain( A, NULL ) would start filter A. +// IFilterChain::StartChain( G, NULL ) would start filters G and H. +// IFilterChain::StartChain( C, NULL ) would start filters C and D. Finally, +// IFilterChain::StartChain( E, NULL ) would fail because E cannot be in a +// filter chain (see the Filter Chain Definition section for more information). +// +// Return Value: +// An HResult. See the Direct Show SDK and COM SDK documentation for more +// information on interpreting HRESULTs. +// +// +// +// +// HResult PauseChain( [in] IBaseFilter *pStartFilter, [in] IBaseFilter *pEndFilter ); +// +// PauseChain() switches all the filters in a chain to the paused state. If it cannot +// switch one of the filtres into the paused state, all the filters in the chain are +// stopped. This method can only be called if the filter graph is paused. +// +// Parameters: +// - pStartFilter [in] +// The first filter in the filter chain. Note that this can be the same +// filter as pEndFilter . +// +// - pEndFilter [in] +// The last filter in the filter chain. Note that this can be the same +// filter as pStartFilter. If pEndFilter is NULL then the filter chain extends +// from pStartFilter to the last downstream filter which can be in a filter chain. +// For example, IFilterChain::StopChain( A, NULL ) would stop filter A. +// IFilterChain::StopChain( G, NULL ) would stop filters G and H. +// IFilterChain::StopChain( C, NULL ) would stop filters C and D. Finally, +// IFilterChain::StopChain( E, NULL ) would fail because E cannot be in a filter +// chain (see the Filter Chain Definition section for more information). +// +// +// Return Value: +// An HResult. See the Direct Show SDK and COM SDK documentation for more +// information on interpreting HRESULTs. +// +// +// +// HResult StopChain( [in] IBaseFilter *pStartFilter, [in] IBaseFilter *pEndFilter ); +// +// StopChain() switches all the filters in chain to the stopped state. +// +// Parameters: +// - pStartFilter [in] +// The first filter in the filter chain. Note that this can be the same +// filter as pEndFilter . +// +// - pEndFilter [in] +// The last filter in the filter chain. Note that this can be the same +// filter as pStartFilter. If pEndFilter is NULL then the filter chain extends +// from pStartFilter to the last downstream filter which can be in a filter chain. +// For example, IFilterChain::StopChain( A, NULL ) would stop filter A. +// IFilterChain::StopChain( G, NULL ) would stop filters G and H. +// IFilterChain::StopChain( C, NULL ) would stop filters C and D. Finally, +// IFilterChain::StopChain( E, NULL ) would fail because E cannot be in a filter +// chain (see the Filter Chain Definition section for more information). +// +// +// Return Value: +// An HResult. See the Direct Show SDK and COM SDK documentation for more +// information on interpreting HRESULTs. +// +// +// +// +// +// HResult RemoveChain( [in] IBaseFilter *pStartFilter, [in] IBaseFilter *pEndFilter ); +// +// RemoveChain() removes every filter in a chain from the filter graph. +// The filters can be removed while the graph is running. +// +// Parameters: +// - pStartFilter [in] +// The first filter in the filter chain. Note that this can be the same +// filter as pEndFilter . +// +// - pEndFilter [in] +// The last filter in the filter chain. Note that this can be the same +// filter as pStartFilter. If pEndFilter is NULL then the filter chain +// extends from pStartFilter to the last downstream filter which can be in a +// filter chain. For example, IFilterChain::RemoveChain( A, NULL ) would remove +// filter A from the filter graph. IFilterChain::RemoveChain( G, NULL ) would +// remove filters G and H. IFilterChain::RemoveChain( C, NULL ) would remove +// filters C and D. Finally, IFilterChain::RemoveChain( E, NULL ) would fail +// because E cannot be in a filter chain (see the Filter Chain Definition +// section for more information). +// +// +// Return Value: +// An HResult. See the Direct Show SDK and COM SDK documentation for more +// information on interpreting HRESULTs. +// +// + + {$HPPEMIT 'typedef System::DelphiInterface _di_IFilterChain;'} + {$EXTERNALSYM IFilterChain} + IFilterChain = interface(IUnknown) + ['{DCFBDCF6-0DC2-45f5-9AB2-7C330EA09C29}'] + (*** IFilterChain methods ***) + function StartChain(pStartFilter, pEndFilter: IBaseFilter): HResult; stdcall; + function PauseChain(pStartFilter, pEndFilter: IBaseFilter): HResult; stdcall; + function StopChain(pStartFilter, pEndFilter: IBaseFilter): HResult; stdcall; + function RemoveChain(pStartFilter, pEndFilter: IBaseFilter): HResult; stdcall; + end; + +/////////////////////////////////////////////////////////////////////////////// +// +// Allocator Presenter interfaces +// +/////////////////////////////////////////////////////////////////////////////// +{$IFDEF ENABLEVMR7} +//===================================================================== +// +// IVMRImagePresenter +// +//===================================================================== +type + VMRPresentationFlags = {$IFDEF TYPE_IDENTITY}type {$ENDIF} LongWord; + {$EXTERNALSYM VMRPresentationFlags} + const + VMRSample_SyncPoint = $00000001; + {$EXTERNALSYM VMRSample_SyncPoint} + VMRSample_Preroll = $00000002; + {$EXTERNALSYM VMRSample_Preroll} + VMRSample_Discontinuity = $00000004; + {$EXTERNALSYM VMRSample_Discontinuity} + VMRSample_TimeValid = $00000008; + {$EXTERNALSYM VMRSample_TimeValid} + VMRSample_SrcDstRectsValid = $00000010; + {$EXTERNALSYM VMRSample_SrcDstRectsValid} + + +type + PVMRPresentationInfo = ^TVMRPresentationInfo; + tagVMRPRESENTATIONINFO = record + dwFlags : DWORD; + lpSurf : IDIRECTDRAWSURFACE7; + rtStart : TReferenceTime; + rtEnd : TReferenceTime; + szAspectRatio : TSIZE; + rcSrc : TRECT; + rcDst : TRECT; + dwTypeSpecificFlags : DWORD; + dwInterlaceFlags : DWORD; + end; + {$EXTERNALSYM tagVMRPRESENTATIONINFO} + VMRPRESENTATIONINFO = tagVMRPRESENTATIONINFO; + {$EXTERNALSYM VMRPRESENTATIONINFO} + TVMRPresentationInfo = tagVMRPRESENTATIONINFO; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IVMRImagePresenter;'} + {$EXTERNALSYM IVMRImagePresenter} + IVMRImagePresenter = interface(IUnknown) + ['{CE704FE7-E71E-41fb-BAA2-C4403E1182F5}'] + (*** IVMRImagePresenter methods ***) + function StartPresenting(dwUserID: DWORD): HResult; stdcall; + function StopPresenting(dwUserID: DWORD): HResult; stdcall; + function PresentImage(dwUserID: DWORD; lpPresInfo: PVMRPRESENTATIONINFO): HResult; stdcall; + end; +{$ENDIF} + +{$IFDEF ENABLEVMR7} +//===================================================================== +// +// IVMRSurfaceAllocator +// +//===================================================================== + +const + AMAP_PIXELFORMAT_VALID = $01; + {$EXTERNALSYM AMAP_PIXELFORMAT_VALID} + AMAP_3D_TARGET = $02; + {$EXTERNALSYM AMAP_3D_TARGET} + AMAP_ALLOW_SYSMEM = $04; + {$EXTERNALSYM AMAP_ALLOW_SYSMEM} + AMAP_FORCE_SYSMEM = $08; + {$EXTERNALSYM AMAP_FORCE_SYSMEM} + AMAP_DIRECTED_FLIP = $10; + {$EXTERNALSYM AMAP_DIRECTED_FLIP} + AMAP_NO_EXTRA_BUFFERS = $20; + {$EXTERNALSYM AMAP_NO_EXTRA_BUFFERS} + +type + PVMRAllocationInfo = ^TVMRAllocationInfo; + tagVMRALLOCATIONINFO = record + dwFlags : DWORD; + lpHdr : PBITMAPINFOHEADER; + lpPixFmt : PDDPIXELFORMAT; + szAspectRatio : TSIZE; + dwMinBuffers : DWORD; + dwMaxBuffers : DWORD; + dwInterlaceFlags : DWORD; + szNativeSize : TSIZE ; + end; + {$EXTERNALSYM tagVMRALLOCATIONINFO} + VMRALLOCATIONINFO = tagVMRALLOCATIONINFO; + {$EXTERNALSYM VMRALLOCATIONINFO} + TVMRAllocationInfo = tagVMRALLOCATIONINFO; + + IVMRSurfaceAllocatorNotify = interface; + {$HPPEMIT 'typedef System::DelphiInterface _di_IVMRSurfaceAllocator;'} + {$EXTERNALSYM IVMRSurfaceAllocator} + IVMRSurfaceAllocator = interface(IUnknown) + ['{31ce832e-4484-458b-8cca-f4d7e3db0b52}'] + (*** IVMRSurfaceAllocator methods ***) + function AllocateSurface(dwUserID: DWORD; lpAllocInfo: PVMRALLOCATIONINFO; + var lpdwActualBuffers: DWORD; out lplpSurface: IDIRECTDRAWSURFACE7): HResult; stdcall; + function FreeSurface(dwID: DWORD): HResult; stdcall; + function PrepareSurface(dwUserID: DWORD; lpSurface: IDIRECTDRAWSURFACE7; + dwSurfaceFlags: DWORD): HResult; stdcall; + function AdviseNotify(lpIVMRSurfAllocNotify: IVMRSurfaceAllocatorNotify): HResult; stdcall; + end; +{$ENDIF} + +{$IFDEF ENABLEVMR7} +//===================================================================== +// +// IVMRSurfaceAllocatorNotify +// +//===================================================================== + + {$HPPEMIT 'typedef System::DelphiInterface _di_IVMRSurfaceAllocatorNotify;'} + {$EXTERNALSYM IVMRSurfaceAllocatorNotify} + IVMRSurfaceAllocatorNotify = interface(IUnknown) + ['{aada05a8-5a4e-4729-af0b-cea27aed51e2}'] + (*** IVMRSurfaceAllocatorNotify methods ***) + function AdviseSurfaceAllocator(dwUserID: DWORD; lpIVRMSurfaceAllocator: IVMRSurfaceAllocator): HResult; stdcall; + function SetDDrawDevice(lpDDrawDevice: IDirectDraw7; hMonitor: HMONITOR): HResult; stdcall; + function ChangeDDrawDevice(lpDDrawDevice: IDIRECTDRAW7; hMonitor: HMONITOR): HResult; stdcall; + function RestoreDDrawSurfaces: HResult; stdcall; + function NotifyEvent(EventCode: LongInt; Param1, Param2: LongInt): HResult; stdcall; + function SetBorderColor(clrBorder: COLORREF): HResult; stdcall; + end; +{$ENDIF} +/////////////////////////////////////////////////////////////////////////////// +// +// Application control and configuration interfaces +// +/////////////////////////////////////////////////////////////////////////////// + +//===================================================================== +// +// IVMRWindowlessControl +// +//===================================================================== + VMR_ASPECT_RATIO_MODE = ( + VMR_ARMODE_NONE, + VMR_ARMODE_LETTER_BOX + ); + {$EXTERNALSYM VMR_ASPECT_RATIO_MODE} + TVMRAspectRatioMode = VMR_ASPECT_RATIO_MODE; + +{$IFDEF ENABLEVMR7} + + {$HPPEMIT 'typedef System::DelphiInterface _di_IVMRWindowlessControl;'} + {$EXTERNALSYM IVMRWindowlessControl} + IVMRWindowlessControl = interface(IUnknown) + ['{0eb1088c-4dcd-46f0-878f-39dae86a51b7}'] + (*** IVMRWindowlessControl methods ***) + ////////////////////////////////////////////////////////// + // Video size and position information + ////////////////////////////////////////////////////////// + function GetNativeVideoSize(out lpWidth, lpHeight, lpARWidth, lpARHeight: LongInt): HResult; stdcall; + function GetMinIdealVideoSize(out lpWidth, lpHeight: longint): HResult; stdcall; + function GetMaxIdealVideoSize(out lpWidth, lpHeight: longint): HResult; stdcall; + function SetVideoPosition(lpSRCRect, lpDSTRect: PRECT): HResult; stdcall; + function GetVideoPosition(out lpSRCRect, lpDSTRect: TRECT): HResult; stdcall; + function GetAspectRatioMode(out lpAspectRatioMode: DWORD): HResult; stdcall; + function SetAspectRatioMode(AspectRatioMode: TVMRAspectRatioMode): HResult; stdcall; + ////////////////////////////////////////////////////////// + // Display and clipping management + ////////////////////////////////////////////////////////// + function SetVideoClippingWindow(hwnd: HWND): HResult; stdcall; + function RepaintVideo(hwnd: HWND; hdc: HDC): HResult; stdcall; + function DisplayModeChanged: HResult; stdcall; + ////////////////////////////////////////////////////////// + // GetCurrentImage + // + // Returns the current image being displayed. This images + // is returned in the form of packed Windows DIB. + // + // GetCurrentImage can be called at any time, also + // the caller is responsible for free the returned memory + // by calling CoTaskMemFree. + // + // Excessive use of this function will degrade video + // playback performed. + ////////////////////////////////////////////////////////// + function GetCurrentImage(out lpDib): HResult; stdcall; + ////////////////////////////////////////////////////////// + // Border Color control + // + // The border color is color used to fill any area of the + // the destination rectangle that does not contain video. + // It is typically used in two instances. When the video + // straddles two monitors and when the VMR is trying + // to maintain the aspect ratio of the movies by letter + // boxing the video to fit within the specified destination + // rectangle. See SetAspectRatioMode above. + ////////////////////////////////////////////////////////// + function SetBorderColor(Clr: COLORREF): HResult; stdcall; + function GetBorderColor(out lpClr: COLORREF): HResult; stdcall; + ////////////////////////////////////////////////////////// + // Color key control only meaningful when the VMR is using + // and overlay + ////////////////////////////////////////////////////////// + function SetColorKey(Clr: COLORREF): HResult; stdcall; + function GetColorKey(out lpClr: COLORREF): HResult; stdcall; + end; +{$ENDIF} +{$IFDEF ENABLEVMR7} +//===================================================================== +// +// IVMRMixerControl +// +//===================================================================== + +// +// Normalized relative rectangle +// Coordinate ranges: x=[0...1) y=[0...1) +// Where the output window goes from 0,0 (closed inclusive lower bound) +// to 1,1 (open exclusive upper bound) +// + +const + MixerPref_NoDecimation = $1; + {$EXTERNALSYM MixerPref_NoDecimation} + MixerPref_DecimateOutput = $2; + {$EXTERNALSYM MixerPref_DecimateOutput} + MixerPref_ARAdjustXorY = $4; // adjust the aspect ratio in x or y + {$EXTERNALSYM MixerPref_ARAdjustXorY} + MixerPref_DecimationReserved = $8; // bits reserved for future use. + {$EXTERNALSYM MixerPref_DecimationReserved} + MixerPref_DecimateMask = $f; + {$EXTERNALSYM MixerPref_DecimateMask} + MixerPref_BiLinearFiltering = $10; + {$EXTERNALSYM MixerPref_BiLinearFiltering} + MixerPref_PointFiltering = $20; + {$EXTERNALSYM MixerPref_PointFiltering} + MixerPref_FilteringMask = $f0; + {$EXTERNALSYM MixerPref_FilteringMask} + MixerPref_RenderTargetRGB = $00000100; // Uses D3D to perform mixing + {$EXTERNALSYM MixerPref_RenderTargetRGB} + MixerPref_RenderTargetYUV = $00001000; // Uses DXVA to perform mixing + {$EXTERNALSYM MixerPref_RenderTargetYUV} + MixerPref_RenderTargetYUV420 = $00000200; // Deprecated render target + {$EXTERNALSYM MixerPref_RenderTargetYUV420} + MixerPref_RenderTargetYUV422 = $00000400; // Deprecated render target + {$EXTERNALSYM MixerPref_RenderTargetYUV422} + MixerPref_RenderTargetYUV444 = $00000800; // Deprecated render target + {$EXTERNALSYM MixerPref_RenderTargetYUV444} + MixerPref_RenderTargetReserved = $0000E000; // 3 bits reserved for future use. + {$EXTERNALSYM MixerPref_RenderTargetReserved} + MixerPref_RenderTargetMask = $ff00; + {$EXTERNALSYM MixerPref_RenderTargetMask} + + // + // Dynamic changes that can be performed when the VMR's mixer is + // configured to use the YUV Render target (see MixerPref_RenderTargetYUV) + // These preferences can be applied while the graph is running and take effect + // when the next frame is composed by the mixer. + // + MixerPref_DynamicSwitchToBOB = $00010000; + {$EXTERNALSYM MixerPref_DynamicSwitchToBOB} + MixerPref_DynamicDecimateBy2 = $00020000; + {$EXTERNALSYM MixerPref_DynamicDecimateBy2} + + MixerPref_DynamicReserved = $000C0000; + {$EXTERNALSYM MixerPref_DynamicReserved} + MixerPref_DynamicMask = $000F0000; + {$EXTERNALSYM MixerPref_DynamicMask} + + +type + PNormalizedRect = ^TNormalizedRect; + _NORMALIZEDRECT = record + left : Single; + top : Single; + right : Single; + bottom : Single; + end; + {$EXTERNALSYM _NORMALIZEDRECT} + NORMALIZEDRECT = _NORMALIZEDRECT; + {$EXTERNALSYM NORMALIZEDRECT} + TNormalizedRect = _NORMALIZEDRECT; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IVMRMixerControl;'} + {$EXTERNALSYM IVMRMixerControl} + IVMRMixerControl = interface(IUnknown) + ['{1c1a17b0-bed0-415d-974b-dc6696131599}'] + (*** IVMRMixerControl methods ***) + //Alpha = Source alpha premultication factor (global alpha for source) + function SetAlpha(dwStreamID: DWORD; Alpha: single): HResult; stdcall; + function GetAlpha(dwStreamID: DWORD; out pAlpha: single): HResult; stdcall; + function SetZOrder(dwStreamID, dwZ: DWORD): HResult; stdcall; + function GetZOrder(dwStreamID: DWORD; out pZ: DWORD): HResult; stdcall; + function SetOutputRect(dwStreamID: DWORD; const pRect: TNORMALIZEDRECT): HResult; stdcall; + function GetOutputRect(dwStreamID: DWORD; out pRect: TNORMALIZEDRECT): HResult; stdcall; + function SetBackgroundClr(ClrBkg: COLORREF): HResult; stdcall; + function GetBackgroundClr(out lpClrBkg: COLORREF): HResult; stdcall; + function SetMixingPrefs(dwMixerPrefs: DWORD): HResult; stdcall; + function GetMixingPrefs(pdwMixerPrefs: DWORD): HResult; stdcall; + end; +{$ENDIF} + +{$IFDEF ENABLEVMR7} +/////////////////////////////////////////////////////////////////////////////// +// +// VMR Multimon configuration interface +// +/////////////////////////////////////////////////////////////////////////////// + tagVMRGUID = record + pGUID : PGUID; // is NULL if the default DDraw device + GUID : TGUID; // otherwise points to this GUID + end; + {$EXTERNALSYM tagVMRGUID} + VMRGUID = tagVMRGUID; + {$EXTERNALSYM VMRGUID} + TVMRGuid = tagVMRGUID; + + tagVMRMONITORINFO = record + guid : VMRGUID; + rcMonitor : TRECT; + hMon : HMONITOR; + dwFlags : DWORD; // described in MONITORINFOEX, currently only MONITORINFOF_PRIMARY + szDevice : array[0..31] of wchar; + szDescription : array[0..255] of wchar; + liDriverVersion : int64; + dwVendorId : DWORD; + dwDeviceId : DWORD; + dwSubSysId : DWORD; + dwRevision : DWORD; + end; + {$EXTERNALSYM tagVMRMONITORINFO} + VMRMONITORINFO = tagVMRMONITORINFO; + {$EXTERNALSYM VMRMONITORINFO} + TVMRMonitorInfo = tagVMRMONITORINFO; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IVMRMonitorConfig;'} + {$EXTERNALSYM IVMRMonitorConfig} + IVMRMonitorConfig = interface(IUnknown) + ['{9cf0b1b6-fbaa-4b7f-88cf-cf1f130a0dce}'] + (*** IVMRMonitorConfig methods ***) + // Use this method on a Multi-Monitor system to specify to the + // mixer filter which Direct Draw driver should be used when connecting + // to an upstream decoder filter. + function SetMonitor(const pGUID: TVMRGUID): HResult; stdcall; + // Use this method to determine the direct draw object that will be used when + // connecting the mixer filter to an upstream decoder filter. + function GetMonitor(out pGUID: TVMRGUID): HResult; stdcall; + // Use this method on a multi-monitor system to specify to the + // mixer filter the default Direct Draw device to use when + // connecting to an upstream filter. The default direct draw device + // can be overriden for a particular connection by SetMonitor method + // described above. + function SetDefaultMonitor(const pGUID: TVMRGUID): HResult; stdcall; + // Use this method on a multi-monitor system to determine which + // is the default direct draw device the overlay mixer filter + // will use when connecting to an upstream filter. + function GetDefaultMonitor(out pGUID: TVMRGUID): HResult; stdcall; + // Use this method to get a list of Direct Draw device GUIDs and thier + // associated monitor information that the mixer can use when + // connecting to an upstream decoder filter. Passing down a NULL pInfo + // parameter allows the app to determine the required array size (returned + // in pdwNumDevices). Otherwise, dwNumDevices returns the actual + // number of devices retrieved. + function GetAvailableMonitors(out pInfo: TVMRMONITORINFO; //if it fail try : "out pInfo" only /hg + dwMaxInfoArraySize: DWORD; // in array members + out pdwNumDevices: DWORD): HResult; stdcall; // actual number of devices retrieved + end; +{$ENDIF} + +{$IFDEF ENABLEVMR7} +//===================================================================== +// +// IVMRImageCompositor +// +//===================================================================== + +type + PVMRVideoStreamInfo = ^TVMRVideoStreamInfo; + _VMRVIDEOSTREAMINFO = record + pddsVideoSurface : IDIRECTDRAWSURFACE7; + dwWidth : DWORD; + dwHeight : DWORD; + dwStrmID : DWORD; + fAlpha : single; + ddClrKey : TDDCOLORKEY; + rNormal : TNORMALIZEDRECT; + end; + {$EXTERNALSYM _VMRVIDEOSTREAMINFO} + VMRVIDEOSTREAMINFO = _VMRVIDEOSTREAMINFO; + {$EXTERNALSYM VMRVIDEOSTREAMINFO} + TVMRVideoStreamInfo = _VMRVIDEOSTREAMINFO; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IVMRImageCompositor;'} + {$EXTERNALSYM IVMRImageCompositor} + IVMRImageCompositor = interface(IUnknown) + ['{7a4fb5af-479f-4074-bb40-ce6722e43c82}'] + (*** IVMRImageCompositor methods ***) + function InitCompositionTarget(pD3DDevice: IUnknown; pddsRenderTarget: IDIRECTDRAWSURFACE7): HResult; stdcall; + function TermCompositionTarget(pD3DDevice: IUnknown; pddsRenderTarget: IDIRECTDRAWSURFACE7): HResult; stdcall; + function SetStreamMediaType(dwStrmID: DWORD; pmt: PAMMediaType; fTexture: BOOL): HResult; stdcall; + function CompositeImage(pD3DDevice: IUnknown; pddsRenderTarget: IDIRECTDRAWSURFACE7; + pmtRenderTarget: PAMMediaType; rtStart, rtEnd: TReferenceTime; + dwClrBkGnd: DWORD; pVideoStreamInfo: PVMRVIDEOSTREAMINFO; cStreams: cardinal): HResult; stdcall; + end; +{$ENDIF} + +{$IFDEF ENABLEVMR7} +/////////////////////////////////////////////////////////////////////////////// +// +// VMR Filter configuration interfaces +// +/////////////////////////////////////////////////////////////////////////////// + +const + RenderPrefs_RestrictToInitialMonitor = $00000000; // not implemented do not use + {$EXTERNALSYM RenderPrefs_RestrictToInitialMonitor} + RenderPrefs_ForceOffscreen = $00000001; + {$EXTERNALSYM RenderPrefs_ForceOffscreen} + RenderPrefs_ForceOverlays = $00000002; // fail if no overlays + {$EXTERNALSYM RenderPrefs_ForceOverlays} + RenderPrefs_AllowOverlays = $00000000; // overlay used by default + {$EXTERNALSYM RenderPrefs_AllowOverlays} + RenderPrefs_AllowOffscreen = $00000000; // offscreen used if no overlay + {$EXTERNALSYM RenderPrefs_AllowOffscreen} + RenderPrefs_DoNotRenderColorKeyAndBorder = $00000008; // app paints color keys + {$EXTERNALSYM RenderPrefs_DoNotRenderColorKeyAndBorder} + RenderPrefs_Reserved = $00000010; // note: used to be RestrictToInitialMonitor + {$EXTERNALSYM RenderPrefs_Reserved} + RenderPrefs_PreferAGPMemWhenMixing = $00000020; + {$EXTERNALSYM RenderPrefs_PreferAGPMemWhenMixing} + RenderPrefs_Mask = $0000003f; // OR of all above flags + {$EXTERNALSYM RenderPrefs_Mask} + + VMRMode_Windowed = $00000001; + {$EXTERNALSYM VMRMode_Windowed} + VMRMode_Windowless = $00000002; + {$EXTERNALSYM VMRMode_Windowless} + VMRMode_Renderless = $00000004; + {$EXTERNALSYM VMRMode_Renderless} + VMRMode_Mask = $00000007; // OR of all above flags + {$EXTERNALSYM VMRMode_Mask} + // not a valid value to pass to SetRenderMode + + MAX_NUMBER_OF_STREAMS = 16; + {$EXTERNALSYM MAX_NUMBER_OF_STREAMS} + +type + {$HPPEMIT 'typedef System::DelphiInterface _di_IVMRFilterConfig;'} + {$EXTERNALSYM IVMRFilterConfig} + IVMRFilterConfig = interface(IUnknown) + ['{9e5530c5-7034-48b4-bb46-0b8a6efc8e36}'] + (*** IVMRFilterConfig methods ***) + function SetImageCompositor(lpVMRImgCompositor: IVMRImageCompositor): HResult; stdcall; + function SetNumberOfStreams(dwMaxStreams: DWORD): HResult; stdcall; + function GetNumberOfStreams(out pdwMaxStreams: DWORD): HResult; stdcall; + function SetRenderingPrefs(dwRenderFlags: DWORD): HResult; stdcall; // a combination of VMRRenderingPrefFlags + function GetRenderingPrefs(out pdwRenderFlags: DWORD): HResult; stdcall; + function SetRenderingMode(Mode: DWORD): HResult; stdcall; // a combination of VMRMode + function GetRenderingMode(out pMode: DWORD): HResult; stdcall; + end; +{$ENDIF} + +{$IFDEF ENABLEVMR7} +//===================================================================== +// +// IVMRAspectRatioControl +// +//===================================================================== + + {$HPPEMIT 'typedef System::DelphiInterface _di_IVMRAspectRatioControl;'} + {$EXTERNALSYM IVMRAspectRatioControl} + IVMRAspectRatioControl = interface(IUnknown) + ['{ede80b5c-bad6-4623-b537-65586c9f8dfd}'] + (*** IVMRAspectRatioControl methods ***) + function GetAspectRatioMode(out lpdwARMode: TVMRAspectRatioMode): HResult; stdcall; + function SetAspectRatioMode(dwARMode: TVMRAspectRatioMode): HResult; stdcall; + end; +{$ENDIF} + +{$IFDEF ENABLEVMR7} +//===================================================================== +// +// IVMRDeinterlaceControl +// +// New interfaced introduced into the WindowsXP SP1 release of the VMR. +// This interface allows applications to control the DX-VA deinterlacing +// support provided by the VMR. +// +// The VMR needs to be set into "mixing" mode for this interface to work. +// +// SetDeinterlaceMode is only effective for new connections made to the +// VMR. It should be noted that the graphics device driver may refuse +// to use the specified deinterlace mode, in which case 3 fallback +// policies are offered by the VMR, these being: +// +// 1. Fallback to the next best mode offered by the driver. +// 2. Fallback to the BOB deinterlace mode. +// 3. Fallback to the WEAVE deinterlace mode (ie. turn deinterlacing off). +// +//===================================================================== +type + VMRDeinterlacePrefs = {$IFDEF TYPE_IDENTITY}type {$ENDIF} LongWord; + {$EXTERNALSYM VMRDeinterlacePrefs} + +const + DeinterlacePref_NextBest = $01; + {$EXTERNALSYM DeinterlacePref_NextBest} + DeinterlacePref_BOB = $02; + {$EXTERNALSYM DeinterlacePref_BOB} + DeinterlacePref_Weave = $04; + {$EXTERNALSYM DeinterlacePref_Weave} + DeinterlacePref_Mask = $07; + {$EXTERNALSYM DeinterlacePref_Mask} + +type + VMRDeinterlaceTech = {$IFDEF TYPE_IDENTITY}type {$ENDIF} LongWord; + {$EXTERNALSYM VMRDeinterlaceTech} + +const + // the algorithm is unknown or proprietary + DeinterlaceTech_Unknown = $0000; + {$EXTERNALSYM DeinterlaceTech_Unknown} + + // the algorithm creates the missing lines by repeating + // the line either above or below it - this method will look very jaggy and + // isn't recommended + DeinterlaceTech_BOBLineReplicate = $0001; + {$EXTERNALSYM DeinterlaceTech_BOBLineReplicate} + + + // the algorithm creates the missing lines by vertically stretching each + // video field by a factor of two, for example by averaging two lines or + // using a [-1, 9, 9, -1]/16 filter across four lines. + // Slight vertical adjustments are made to ensure that the resulting image + // does not "bob" up and down. + DeinterlaceTech_BOBVerticalStretch = $0002; + {$EXTERNALSYM DeinterlaceTech_BOBVerticalStretch} + + // the pixels in the missing line are recreated by a median filtering operation + DeinterlaceTech_MedianFiltering = $0004; + {$EXTERNALSYM DeinterlaceTech_MedianFiltering} + + // the pixels in the missing line are recreated by an edge filter. + // In this process, spatial directional filters are applied to determine + // the orientation of edges in the picture content, and missing + // pixels are created by filtering along (rather than across) the + // detected edges. + DeinterlaceTech_EdgeFiltering = $0010; + {$EXTERNALSYM DeinterlaceTech_EdgeFiltering} + + // the pixels in the missing line are recreated by switching on a field by + // field basis between using either spatial or temporal interpolation + // depending on the amount of motion. + DeinterlaceTech_FieldAdaptive = $0020; + {$EXTERNALSYM DeinterlaceTech_FieldAdaptive} + + // the pixels in the missing line are recreated by switching on a pixel by pixel + // basis between using either spatial or temporal interpolation depending on + // the amount of motion.. + DeinterlaceTech_PixelAdaptive = $0040; + {$EXTERNALSYM DeinterlaceTech_PixelAdaptive} + + // Motion Vector Steering identifies objects within a sequence of video + // fields. The missing pixels are recreated after first aligning the + // movement axes of the individual objects in the scene to make them + // parallel with the time axis. + DeinterlaceTech_MotionVectorSteered = $0080; + {$EXTERNALSYM DeinterlaceTech_MotionVectorSteered} + +type + PVMRFrequency = ^TVMRFrequency; + _VMRFrequency = record + dwNumerator : DWORD; + dwDenominator : DWORD; + end; + {$EXTERNALSYM _VMRFrequency} + VMRFrequency = _VMRFrequency; + {$EXTERNALSYM VMRFrequency} + TVMRFrequency = _VMRFrequency; + + PVMRVideoDesc = ^TVMRVideoDesc; + _VMRVideoDesc = record + dwSize : DWORD; + dwSampleWidth : DWORD; + dwSampleHeight : DWORD; + SingleFieldPerSample : BOOL; + dwFourCC : DWORD; + InputSampleFreq : VMRFrequency; + OutputFrameFreq : VMRFrequency; + end; + {$EXTERNALSYM _VMRVideoDesc} + VMRVideoDesc = _VMRVideoDesc; + {$EXTERNALSYM VMRVideoDesc} + TVMRVideoDesc = _VMRVideoDesc; + + PVMRDeinterlaceCaps = ^TVMRDeinterlaceCaps; + _VMRDeinterlaceCaps = record + dwSize : DWORD; + dwNumPreviousOutputFrames : DWORD; + dwNumForwardRefSamples : DWORD; + dwNumBackwardRefSamples : DWORD; + DeinterlaceTechnology : VMRDeinterlaceTech; + end; + {$EXTERNALSYM _VMRDeinterlaceCaps} + VMRDeinterlaceCaps = _VMRDeinterlaceCaps; + {$EXTERNALSYM VMRDeinterlaceCaps} + TVMRDeinterlaceCaps = _VMRDeinterlaceCaps; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IVMRDeinterlaceControl;'} + {$EXTERNALSYM IVMRDeinterlaceControl} + IVMRDeinterlaceControl = interface(IUnknown) + ['{bb057577-0db8-4e6a-87a7-1a8c9a505a0f}'] + (*** IVMRDeinterlaceControl methods ***) + // For the specified video description returns the + // number of deinterlacing modes available to the VMR. + // The deinterlacing modes are returned in descending + // quality order ie. the best quality mode is at + // lpdwNumDeinterlaceModes[0], the next best at + // lpdwNumDeinterlaceModes[1] and so on. + // + // To determine how big an array of guids to pass to the + // GetNumberOfDeinterlaceModes method call + // GetNumberOfDeinterlaceModes(lpVideoDescription, &dwNumModes, NULL); + // + function GetNumberOfDeinterlaceModes(lpVideoDescription: PVMRVideoDesc; + var lpdwNumDeinterlaceModes: DWORD; lpDeinterlaceModes: PGUID): HResult; stdcall; + // For the given video description get the capabilities of the + // specified de-interlace mode. + function GetDeinterlaceModeCaps(const lpDeinterlaceMode: TGUID; + lpVideoDescription: PVMRVideoDesc; lpDeinterlaceCaps: PVMRDeinterlaceCaps): HResult; stdcall; + // Get/Set the deinterlace mode that you would like the + // VMR to use when de-interlacing the specified stream. + // It should be noted that the VMR may not actually be able + // to use the requested deinterlace mode, in which case the + // the VMR will fall back to other de-interlace modes as specified + // by the de-interlace preferences (see SetDeinterlacePrefs below). + function GetDeinterlaceMode( + dwStreamID: DWORD; + out lpDeinterlaceMode: TGUID // returns GUID_NULL if SetDeinterlaceMode + ): HResult; stdcall; // has not been called yet. + + function SetDeinterlaceMode( + dwStreamID: DWORD; // use $FFFFFFFF to set mode for all streams + const lpDeinterlaceMode: TGUID // GUID_NULL == turn deinterlacing off + ): HResult; stdcall; + + function GetDeinterlacePrefs(out lpdwDeinterlacePrefs: VMRDeinterlacePrefs): HResult; stdcall; + function SetDeinterlacePrefs(dwDeinterlacePrefs: VMRDeinterlacePrefs): HResult; stdcall; + + // Get the DeinterlaceMode currently in use for the specified + // video stream (ie. pin). The returned GUID will be NULL if + // the de-interlacing h/w has not been created by the VMR at the + // time the function is called, or if the VMR determines that + // this stream should not or can be de-interlaced. + function GetActualDeinterlaceMode( + dwStreamID: DWORD; out lpDeinterlaceMode: TGUID): HResult; stdcall; + end; +{$ENDIF} + +{$IFDEF ENABLEVMR7} +//===================================================================== +// +// IVMRMixerBitmap +// +//===================================================================== + PVMRAlphaBitmap = ^TVMRAlphaBitmap; + _VMRALPHABITMAP = record + dwFlags : DWORD; // flags word + hdc : HDC; // DC for the bitmap to copy + pDDS : IDIRECTDRAWSURFACE7; // DirectDraw surface to copy + rSrc : TRECT; // rectangle to copy from the DC/DDS + rDest : NORMALIZEDRECT; // output rectangle in composition space + fAlpha : single; // opacity of the bitmap + clrSrcKey : COLORREF; // src color key + end; + {$EXTERNALSYM _VMRALPHABITMAP} + VMRALPHABITMAP = _VMRALPHABITMAP; + {$EXTERNALSYM VMRALPHABITMAP} + TVMRAlphaBitmap = _VMRALPHABITMAP; + +const + // Disable the alpha bitmap for now + VMRBITMAP_DISABLE = $00000001; + {$EXTERNALSYM VMRBITMAP_DISABLE} + + // Take the bitmap from the HDC rather than the DirectDraw surface + VMRBITMAP_HDC = $00000002; + {$EXTERNALSYM VMRBITMAP_HDC} + + // Take the entire DDraw surface - rSrc is ignored + VMRBITMAP_ENTIREDDS = $00000004; + {$EXTERNALSYM VMRBITMAP_ENTIREDDS} + + // Indicates that the clrTrans value is valid and should be + // used when blending + VMRBITMAP_SRCCOLORKEY = $00000008; + {$EXTERNALSYM VMRBITMAP_SRCCOLORKEY} + + VMRBITMAP_SRCRECT = $00000010; + {$EXTERNALSYM VMRBITMAP_SRCRECT} + +type + {$HPPEMIT 'typedef System::DelphiInterface _di_IVMRMixerBitmap;'} + {$EXTERNALSYM IVMRMixerBitmap} + IVMRMixerBitmap = interface(IUnknown) + ['{1E673275-0257-40aa-AF20-7C608D4A0428}'] + (*** IVMRMixerBitmap methods ***) + // Set bitmap, location to blend it, and blending value + function SetAlphaBitmap(var pBmpParms: TVMRALPHABITMAP): HResult; stdcall; + // Change bitmap location, size and blending value, + // graph must be running for change to take effect. + function UpdateAlphaBitmapParameters(pBmpParms: PVMRALPHABITMAP): HResult; stdcall; + // Get bitmap, location to blend it, and blending value + function GetAlphaBitmapParameters(out pBmpParms: TVMRALPHABITMAP): HResult; stdcall; + end; +{$ENDIF} +{$IFDEF ENABLEVMR7} +//===================================================================== +// +// IVMRVideoStreamControl +// +//===================================================================== + + {$HPPEMIT 'typedef System::DelphiInterface _di_IVMRVideoStreamControl;'} + {$EXTERNALSYM IVMRVideoStreamControl} + IVMRVideoStreamControl = interface(IUnknown) + ['{058d1f11-2a54-4bef-bd54-df706626b727}'] + (*** IVMRVideoStreamControl methods ***) + function SetColorKey(clr: PDDCOLORKEY): HResult; stdcall; // Source color key, set to 0xFFFFFFFF to disable + function GetColorKey(out pclr: TDDCOLORKEY): HResult; stdcall; + function SetStreamActiveState(fActive: BOOL): HResult; stdcall; + function GetStreamActiveState(out lpfActive: BOOL): HResult; stdcall; + end; +{$ENDIF} +{$IFDEF ENABLEVMR7} +//===================================================================== +// +// IVMRSurface +// +//===================================================================== + + {$HPPEMIT 'typedef System::DelphiInterface _di_IVMRSurface;'} + {$EXTERNALSYM IVMRSurface} + IVMRSurface = interface(IUnknown) + ['{a9849bbe-9ec8-4263-b764-62730f0d15d0}'] + (*** IVMRSurface methods ***) + function IsSurfaceLocked: HResult; stdcall; + function LockSurface(out lpSurface: PBYTE): HResult; stdcall; + function UnlockSurface: HResult; stdcall; + function GetSurface(lplpSurface: IDIRECTDRAWSURFACE7): HResult; stdcall; + end; +{$ENDIF} + +{$IFDEF ENABLEVMR7} +//===================================================================== +// +// IVMRImagePresenterConfig +// +//===================================================================== + + {$HPPEMIT 'typedef System::DelphiInterface _di_IVMRImagePresenterConfig;'} + {$EXTERNALSYM IVMRImagePresenterConfig} + IVMRImagePresenterConfig = interface(IUnknown) + ['{9f3a1c85-8555-49ba-935f-be5b5b29d178}'] + (*** IVMRImagePresenterConfig methods ***) + function SetRenderingPrefs(dwRenderFlags: DWORD): HResult; stdcall; + function GetRenderingPrefs(out dwRenderFlags: DWORD): HResult; stdcall; + end; +//===================================================================== +// +// IVMRImagePresenterExclModeConfig +// +//===================================================================== + + {$HPPEMIT 'typedef System::DelphiInterface _di_IVMRImagePresenterExclModeConfig;'} + {$EXTERNALSYM IVMRImagePresenterExclModeConfig} + IVMRImagePresenterExclModeConfig = interface(IVMRImagePresenterConfig) + ['{e6f7ce40-4673-44f1-8f77-5499d68cb4ea}'] + (*** IVMRImagePresenterExclModeConfig methods ***) + function SetXlcModeDDObjAndPrimarySurface(lpDDObj: IDIRECTDRAW7; lpPrimarySurf: IDIRECTDRAWSURFACE7): HResult; stdcall; + function GetXlcModeDDObjAndPrimarySurface(lpDDObj: IDIRECTDRAW7; lpPrimarySurf: IDIRECTDRAWSURFACE7): HResult; stdcall; + end; +{$ENDIF} + +//===================================================================== +// +// IVPManager +// +//===================================================================== + + {$HPPEMIT 'typedef System::DelphiInterface _di_IVPManager;'} + {$EXTERNALSYM IVPManager} + IVPManager = interface(IUnknown) + ['{aac18c18-e186-46d2-825d-a1f8dc8e395a}'] + (*** IVPManager methods ***) + // Use this method on a Multi-Monitor system to specify to the + // video port manager filter which videoport index is used + // to an upstream decoder filter. + function SetVideoPortIndex(dwVideoPortIndex: DWORD): HResult; stdcall; // the video port number that this is connected to + // This method returns the current video port index being used by the VPM. + function GetVideoPortIndex(out pdwVideoPortIndex: DWORD): HResult; stdcall; // the video port number that this is connected to + end; + + +(*==========================================================================; + * + * Copyright (C) 1996-1997 Microsoft Corporation. All Rights Reserved. + * + * File: mmstream.h + * + ***************************************************************************) + +const + IID_IMultiMediaStream: TGUID = '{B502D1BC-9A57-11d0-8FDE-00C04FD9189D}'; + {$EXTERNALSYM IID_IMultiMediaStream} + IID_IMediaStream: TGUID = '{B502D1BD-9A57-11d0-8FDE-00C04FD9189D}'; + {$EXTERNALSYM IID_IMediaStream} + IID_IStreamSample: TGUID = '{B502D1BE-9A57-11d0-8FDE-00C04FD9189D}'; + {$EXTERNALSYM IID_IStreamSample} + +const + MS_S_PENDING = $00040001; + {$EXTERNALSYM MS_S_PENDING} + MS_S_NOUPDATE = $00040002; + {$EXTERNALSYM MS_S_NOUPDATE} + MS_S_ENDOFSTREAM = $00040003; + {$EXTERNALSYM MS_S_ENDOFSTREAM} + MS_E_SAMPLEALLOC = $80040401; + {$EXTERNALSYM MS_E_SAMPLEALLOC} + MS_E_PURPOSEID = $80040402; + {$EXTERNALSYM MS_E_PURPOSEID} + MS_E_NOSTREAM = $80040403; + {$EXTERNALSYM MS_E_NOSTREAM} + MS_E_NOSEEKING = $80040404; + {$EXTERNALSYM MS_E_NOSEEKING} + MS_E_INCOMPATIBLE = $80040405; + {$EXTERNALSYM MS_E_INCOMPATIBLE} + MS_E_BUSY = $80040406; + {$EXTERNALSYM MS_E_BUSY} + MS_E_NOTINIT = $80040407; + {$EXTERNALSYM MS_E_NOTINIT} + MS_E_SOURCEALREADYDEFINED = $80040408; + {$EXTERNALSYM MS_E_SOURCEALREADYDEFINED} + MS_E_INVALIDSTREAMTYPE = $80040409; + {$EXTERNALSYM MS_E_INVALIDSTREAMTYPE} + MS_E_NOTRUNNING = $8004040A; + {$EXTERNALSYM MS_E_NOTRUNNING} + + MSPID_PrimaryVideo: TGUID = (D1:$A35FF56A;D2:$9FDA;D3:$11D0;D4:($8F,$DF,$00,$C0,$4F,$D9,$18,$9D)); + {$EXTERNALSYM MSPID_PrimaryVideo} + MSPID_PrimaryAudio: TGUID = (D1:$A35FF56B;D2:$9FDA;D3:$11D0;D4:($8F,$DF,$00,$C0,$4F,$D9,$18,$9D)); + {$EXTERNALSYM MSPID_PrimaryAudio} + +type + PAPCFUNC = procedure(dwParam: DWORD); stdcall; + {$EXTERNALSYM PAPCFUNC} + + STREAM_TIME = {$IFDEF TYPE_IDENTITY}type {$ENDIF} int64; + {$EXTERNALSYM STREAM_TIME} + + PStreamType = ^TStreamType; + STREAM_TYPE = ( + STREAMTYPE_READ, + STREAMTYPE_WRITE, + STREAMTYPE_TRANSFORM + ); + {$EXTERNALSYM STREAM_TYPE} + TStreamType = STREAM_TYPE; + + STREAM_STATE = ( + STREAMSTATE_STOP, + STREAMSTATE_RUN + ); + {$EXTERNALSYM STREAM_STATE} + TStreamState = STREAM_STATE; + +const + COMPSTAT_NOUPDATEOK = 1; + {$EXTERNALSYM COMPSTAT_NOUPDATEOK} + COMPSTAT_WAIT = 2; + {$EXTERNALSYM COMPSTAT_WAIT} + COMPSTAT_ABORT = 4; + {$EXTERNALSYM COMPSTAT_ABORT} + + MMSSF_HASCLOCK = $1; + {$EXTERNALSYM MMSSF_HASCLOCK} + MMSSF_SUPPORTSEEK = $2; + {$EXTERNALSYM MMSSF_SUPPORTSEEK} + MMSSF_ASYNCHRONOUS = $4; + {$EXTERNALSYM MMSSF_ASYNCHRONOUS} + + SSUPDATE_ASYNC = $1; + {$EXTERNALSYM SSUPDATE_ASYNC} + SSUPDATE_CONTINUOUS = $2; + {$EXTERNALSYM SSUPDATE_CONTINUOUS} + +type + IMediaStream = interface; + IStreamSample = interface; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IMultiMediaStream;'} + {$EXTERNALSYM IMultiMediaStream} + IMultiMediaStream = interface(IUnknown) + ['{B502D1BC-9A57-11d0-8FDE-00C04FD9189D}'] + (*** IMultiMediaStream methods ***) + function GetInformation(pdwFlags: PDWORD; pStreamType: PStreamType): + HResult; stdcall; + function GetMediaStream(const idPurpose: TGUID; + out ppMediaStream: IMediaStream): HResult; stdcall; + function EnumMediaStreams(Index: Longint; out ppMediaStream: IMediaStream): + HResult; stdcall; + function GetState(out pCurrentState: TStreamState): HResult; stdcall; + function SetState(NewState: TStreamState): HResult; stdcall; + function GetTime(out pCurrentTime: STREAM_TIME): HResult; stdcall; + function GetDuration(out pDuration: STREAM_TIME): HResult; stdcall; + function Seek(SeekTime: STREAM_TIME): HResult; stdcall; + function GetEndOfStreamEventHandle(out phEOS: THandle): HResult; stdcall; + end; + + + {$HPPEMIT 'typedef System::DelphiInterface _di_IMediaStream;'} + {$EXTERNALSYM IMediaStream} + IMediaStream = interface(IUnknown) + ['{B502D1BD-9A57-11d0-8FDE-00C04FD9189D}'] + (*** IMediaStream methods ***) + function GetMultiMediaStream(out ppMultiMediaStream: IMultiMediaStream): + HResult; stdcall; + function GetInformation(pPurposeId: PGUID; pType: PStreamType): HResult; stdcall; + function SetSameFormat(pStreamThatHasDesiredFormat: IMediaStream; + dwFlags: DWORD): HResult; stdcall; + function AllocateSample(dwFlags: DWORD; out ppSample: IStreamSample): HResult; stdcall; + function CreateSharedSample(pExistingSample: IStreamSample; dwFlags: DWORD; + out ppNewSample: IStreamSample): HResult; stdcall; + function SendEndOfStream(dwFlags: DWORD): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IStreamSample;'} + {$EXTERNALSYM IStreamSample} + IStreamSample = interface(IUnknown) + ['{B502D1BE-9A57-11d0-8FDE-00C04FD9189D}'] + (*** IStreamSample methods ***) + function GetMediaStream(out ppMediaStream: IMediaStream): HResult; stdcall; + function GetSampleTimes(out pStartTime, pEndTime, + pCurrentTime: STREAM_TIME): HResult; stdcall; + function SetSampleTimes(var pStartTime, pEndTime: STREAM_TIME): HResult; stdcall; + function Update(dwFlags: DWORD; hEvent: THandle; pfnAPC: PAPCFUNC; + dwAPCData: DWORD): HResult; stdcall; + function CompletionStatus(dwFlags: DWORD; dwMilliseconds: DWORD): HResult; stdcall; + end; + +(*==========================================================================; + * + * Copyright (C) 1996-1997 Microsoft Corporation. All Rights Reserved. + * + * File: amstream.h + * + ***************************************************************************) + +const + IID_IDirectShowStream: TGUID = '{7DB01C96-C0C3-11D0-8FF1-00C04FD9189D}'; + {$EXTERNALSYM IID_IDirectShowStream} + IID_IAMMultiMediaStream: TGUID = '{BEBE595C-9A6F-11D0-8FDE-00C04FD9189D}'; + {$EXTERNALSYM IID_IAMMultiMediaStream} + IID_IAMMediaStream: TGUID = '{BEBE595D-9A6F-11D0-8FDE-00C04FD9189D}'; + {$EXTERNALSYM IID_IAMMediaStream} + IID_IMediaStreamFilter: TGUID = '{BEBE595E-9A6F-11D0-8FDE-00C04FD9189D}'; + {$EXTERNALSYM IID_IMediaStreamFilter} + IID_IDirectDrawMediaSampleAllocator: TGUID = '{AB6B4AFC-F6E4-11D0-900D-00C04FD9189D}'; + {$EXTERNALSYM IID_IDirectDrawMediaSampleAllocator} + IID_IDirectDrawMediaSample: TGUID = '{AB6B4AFE-F6E4-11D0-900D-00C04FD9189D}'; + {$EXTERNALSYM IID_IDirectDrawMediaSample} + IID_IAMMediaTypeStream: TGUID = '{AB6B4AFA-F6E4-11D0-900D-00C04FD9189D}'; + {$EXTERNALSYM IID_IAMMediaTypeStream} + IID_IAMMediaTypeSample: TGUID = '{AB6B4AFB-F6E4-11D0-900D-00C04FD9189D}'; + {$EXTERNALSYM IID_IAMMediaTypeSample} + +const + AMMSF_NOGRAPHTHREAD = $1; + {$EXTERNALSYM AMMSF_NOGRAPHTHREAD} + + AMMSF_ADDDEFAULTRENDERER = $1; + {$EXTERNALSYM AMMSF_ADDDEFAULTRENDERER} + AMMSF_CREATEPEER = $2; + {$EXTERNALSYM AMMSF_CREATEPEER} + AMMSF_STOPIFNOSAMPLES = $4; + {$EXTERNALSYM AMMSF_STOPIFNOSAMPLES} + AMMSF_NOSTALL = $8; + {$EXTERNALSYM AMMSF_NOSTALL} + + AMMSF_RENDERTYPEMASK = $3; + {$EXTERNALSYM AMMSF_RENDERTYPEMASK} + AMMSF_RENDERTOEXISTING = 0; + {$EXTERNALSYM AMMSF_RENDERTOEXISTING} + AMMSF_RENDERALLSTREAMS = $1; + {$EXTERNALSYM AMMSF_RENDERALLSTREAMS} + AMMSF_NORENDER = $2; + {$EXTERNALSYM AMMSF_NORENDER} + AMMSF_NOCLOCK = $4; + {$EXTERNALSYM AMMSF_NOCLOCK} + AMMSF_RUN = $8; + {$EXTERNALSYM AMMSF_RUN} + +type + OUTPUT_STATE = ( + Disabled, + ReadData, + RenderData + ); + {$EXTERNALSYM OUTPUT_STATE} + TOutputState = OUTPUT_STATE; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IDirectShowStream;'} + {$EXTERNALSYM IDirectShowStream} + IDirectShowStream = interface(IDispatch) + ['{7DB01C96-C0C3-11D0-8FF1-00C04FD9189D}'] + (*** IDirectShowStream methods ***) + function get_FileName(out pVal: WideString): HResult; stdcall; + function put_FileName(newVal: WideString): HResult; stdcall; + function get_Video(out pVal: TOutputState): HResult; stdcall; + function put_Video(newVal: TOutputState): HResult; stdcall; + function get_Audio(out pVal: TOutputState): HResult; stdcall; + function put_Audio(newVal: TOutputState): HResult; stdcall; + end; + + IMediaStreamFilter = interface; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMMultiMediaStream;'} + {$EXTERNALSYM IAMMultiMediaStream} + IAMMultiMediaStream = interface(IMultiMediaStream) + ['{BEBE595C-9A6F-11D0-8FDE-00C04FD9189D}'] + (*** IAMMultiMediaStream methods ***) + function Initialize(StreamType: TStreamType; dwFlags: DWORD; + pFilterGraph: IGraphBuilder): HResult; stdcall; + function GetFilterGraph(out ppGraphBuilder: IGraphBuilder): HResult; stdcall; + function GetFilter(out ppFilter: IMediaStreamFilter): HResult; stdcall; + function AddMediaStream(pStreamObject: IUnknown; PurposeId: PGUID; + dwFlags: DWORD; out ppNewStream: IMediaStream): HResult; stdcall; + function OpenFile(pszFileName: PWideChar; dwFlags: DWORD): HResult; stdcall; + function OpenMoniker(pCtx: IBindCtx; pMoniker: IMoniker; dwFlags: DWORD): HResult; stdcall; + function Render(dwFlags: DWORD): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMMediaStream;'} + {$EXTERNALSYM IAMMediaStream} + IAMMediaStream = interface(IMediaStream) + ['{BEBE595D-9A6F-11D0-8FDE-00C04FD9189D}'] + (*** IAMMediaStream methods ***) + function Initialize(pSourceObject: IUnknown; dwFlags: DWORD; + PurposeId: PGUID; StreamType: TStreamType): HResult; stdcall; + function SetState(State: TFilterState): HResult; stdcall; + function JoinAMMultiMediaStream(pAMMultiMediaStream: IAMMultiMediaStream): HResult; stdcall; + function JoinFilter(pMediaStreamFilter: IMediaStreamFilter): HResult; stdcall; + function JoinFilterGraph(pFilterGraph: IFilterGraph): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IMediaStreamFilter;'} + {$EXTERNALSYM IMediaStreamFilter} + IMediaStreamFilter = interface(IBaseFilter) + ['{BEBE595E-9A6F-11D0-8FDE-00C04FD9189D}'] + (*** IMediaStreamFilter methods ***) + function AddMediaStream(pAMMediaStream: IAMMediaStream): HResult; stdcall; + function GetMediaStream( var idPurpose: TGUID; + out ppMediaStream: IMediaStream): HResult; stdcall; + function EnumMediaStreams(Index: Longint; out ppMediaStream: IMediaStream): HResult; stdcall; + function SupportSeeking(bRenderer: BOOL): HResult; stdcall; + function ReferenceTimeToStreamTime( var pTime: TReferenceTime): HResult; stdcall; + function GetCurrentStreamTime(out pCurrentStreamTime: TReferenceTime): HResult; stdcall; + function WaitUntil(WaitStreamTime: TReferenceTime): HResult; stdcall; + function Flush(bCancelEOS: BOOL): HResult; stdcall; + function EndOfStream: HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IDirectDrawMediaSampleAllocator;'} + {$EXTERNALSYM IDirectDrawMediaSampleAllocator} + IDirectDrawMediaSampleAllocator = interface(IUnknown) + ['{AB6B4AFC-F6E4-11D0-900D-00C04FD9189D}'] + (*** IDirectDrawMediaSampleAllocator methods ***) + function GetDirectDraw(out ppDirectDraw: IDirectDraw): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IDirectDrawMediaSample;'} + {$EXTERNALSYM IDirectDrawMediaSample} + IDirectDrawMediaSample = interface(IUnknown) + ['{AB6B4AFE-F6E4-11D0-900D-00C04FD9189D}'] + (*** IDirectDrawMediaSample methods ***) + function GetSurfaceAndReleaseLock(out ppDirectDrawSurface: IDirectDrawSurface; + out pRect: TRect): HResult; stdcall; + function LockMediaSamplePointer: HResult; stdcall; + end; + + IAMMediaTypeSample = interface; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMMediaTypeStream;'} + {$EXTERNALSYM IAMMediaTypeStream} + IAMMediaTypeStream = interface(IMediaStream) + ['{AB6B4AFA-F6E4-11D0-900D-00C04FD9189D}'] + (*** IAMMediaTypeStream methods ***) + function GetFormat(out pMediaType: TAMMediaType; dwFlags: DWORD): HResult; stdcall; + function SetFormat(const pMediaType: TAMMediaType; dwFlags: DWORD): HResult; stdcall; + function CreateSample(lSampleSize: Longint; pbBuffer: Pointer; + dwFlags: DWORD; pUnkOuter: IUnknown; out ppAMMediaTypeSample: IAMMediaTypeSample): HResult; stdcall; + function GetStreamAllocatorRequirements(var pProps: TAllocatorProperties): HResult; stdcall; + function SetStreamAllocatorRequirements(const pProps: TAllocatorProperties): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMMediaTypeSample;'} + {$EXTERNALSYM IAMMediaTypeSample} + IAMMediaTypeSample = interface(IStreamSample) + ['{AB6B4AFB-F6E4-11D0-900D-00C04FD9189D}'] + (*** IAMMediaTypeSample methods ***) + function SetPointer(pBuffer: Pointer; lSize: Longint): HResult; stdcall; + function GetPointer(out ppBuffer: Pointer): HResult; stdcall; + function GetSize: Longint; stdcall; + function GetTime(out pTimeStart, pTimeEnd: TReferenceTime): HResult; stdcall; + function SetTime(pTimeStart, pTimeEnd: PReferenceTime): HResult; stdcall; + function IsSyncPoint: HResult; stdcall; + function SetSyncPoint(bIsSyncPoint: BOOL): HResult; stdcall; + function IsPreroll: HResult; stdcall; + function SetPreroll(bIsPreroll: BOOL): HResult; stdcall; + function GetActualDataLength: Longint; stdcall; + function SetActualDataLength(l: Longint): HResult; stdcall; + function GetMediaType(var ppMediaType: PAMMediaType): HResult; stdcall; + function SetMediaType(var pMediaType: TAMMediaType): HResult; stdcall; + function IsDiscontinuity: HResult; stdcall; + function SetDiscontinuity(bDiscontinuity: BOOL): HResult; stdcall; + function GetMediaTime(out pTimeStart, pTimeEnd: int64): HResult; stdcall; + function SetMediaTime(var pTimeStart, pTimeEnd: int64): HResult; stdcall; + end; + +const +{ +EXTERN_C const IID LIBID_DirectShowStreamLib; + +EXTERN_C const CLSID CLSID_AMMultiMediaStream; +} + CLSID_AMMultiMediaStream: TGUID = '{49C47CE5-9BA4-11D0-8212-00C04FC32C45}'; + {$EXTERNALSYM CLSID_AMMultiMediaStream} + + CLSID_AMDirectDrawStream: TGUID = (D1:$49C47CE4;D2:$9BA4;D3:$11D0;D4:($82,$12,$00,$C0,$4F,$C3,$2C,$45)); + {$EXTERNALSYM CLSID_AMDirectDrawStream} + CLSID_AMAudioStream: TGUID = (D1:$8496E040;D2:$AF4C;D3:$11D0;D4:($82,$12,$00,$C0,$4F,$C3,$2C,$45)); + {$EXTERNALSYM CLSID_AMAudioStream} + CLSID_AMAudioData: TGUID = (D1:$F2468580;D2:$AF8A;D3:$11D0;D4:($82,$12,$00,$C0,$4F,$C3,$2C,$45)); + {$EXTERNALSYM CLSID_AMAudioData} + CLSID_AMMediaTypeStream: TGUID = (D1:$CF0F2F7C;D2:$F7BF;D3:$11D0;D4:($90,$0D,$00,$C0,$4F,$D9,$18,$9D)); + {$EXTERNALSYM CLSID_AMMediaTypeStream} + +(*==========================================================================; + * + * Copyright (C) 1996-1997 Microsoft Corporation. All Rights Reserved. + * + * File: ddstream.h + * + ***************************************************************************) + +const + DDSFF_PROGRESSIVERENDER = $1; + {$EXTERNALSYM DDSFF_PROGRESSIVERENDER} + + IID_IDirectDrawMediaStream: TGUID = '{F4104FCE-9A70-11d0-8FDE-00C04FD9189D}'; + {$EXTERNALSYM IID_IDirectDrawMediaStream} + IID_IDirectDrawStreamSample: TGUID = '{F4104FCF-9A70-11d0-8FDE-00C04FD9189D}'; + {$EXTERNALSYM IID_IDirectDrawStreamSample} + +type + IDirectDrawStreamSample = interface; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IDirectDrawMediaStream;'} + {$EXTERNALSYM IDirectDrawMediaStream} + IDirectDrawMediaStream = interface(IMediaStream) + ['{F4104FCE-9A70-11d0-8FDE-00C04FD9189D}'] + (*** IDirectDrawMediaStream methods ***) + function GetFormat(out pDDSDCurrent: TDDSurfaceDesc; + out ppDirectDrawPalette: IDirectDrawPalette; + out pDDSDDesired: TDDSurfaceDesc; out pdwFlags: DWORD): HResult; stdcall; + function SetFormat(const pTDDSurfaceDesc: TDDSurfaceDesc; + pDirectDrawPalette: IDirectDrawPalette): HResult; stdcall; + function GetDirectDraw(out ppDirectDraw: IDirectDraw): HResult; stdcall; + function SetDirectDraw(pDirectDraw: IDirectDraw): HResult; stdcall; + function CreateSample(pSurface: IDirectDrawSurface; const pRect: TRect; + dwFlags: DWORD; out ppSample: IDirectDrawStreamSample): HResult; + stdcall; + function GetTimePerFrame(var pFrameTime: STREAM_TIME): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IDirectDrawStreamSample;'} + {$EXTERNALSYM IDirectDrawStreamSample} + IDirectDrawStreamSample = interface(IStreamSample) + ['{F4104FCF-9A70-11d0-8FDE-00C04FD9189D}'] + (*** IDirectDrawStreamSample methods ***) + function GetSurface(out ppDirectDrawSurface: IDirectDrawSurface; + out pRect: TRect): HResult; stdcall; + function SetRect(const pRect: TRect): HResult; stdcall; + end; + +(*==========================================================================; + * + * Copyright (C) 1996-1997 Microsoft Corporation. All Rights Reserved. + * + * File: austream.h + * + ***************************************************************************) + +const + IID_IAudioMediaStream: TGUID = '{F7537560-A3BE-11D0-8212-00C04FC32C45}'; + {$EXTERNALSYM IID_IAudioMediaStream} + IID_IAudioStreamSample: TGUID = '{345FEE00-ABA5-11D0-8212-00C04FC32C45}'; + {$EXTERNALSYM IID_IAudioStreamSample} + IID_IMemoryData: TGUID = '{327FC560-AF60-11D0-8212-00C04FC32C45}'; + {$EXTERNALSYM IID_IMemoryData} + IID_IAudioData: TGUID = '{54C719C0-AF60-11D0-8212-00C04FC32C45}'; + {$EXTERNALSYM IID_IAudioData} + +type + IAudioStreamSample = interface; + IAudioData = interface; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAudioMediaStream;'} + {$EXTERNALSYM IAudioMediaStream} + IAudioMediaStream = interface(IMediaStream) + ['{F7537560-A3BE-11D0-8212-00C04FC32C45}'] + (*** IAudioMediaStream methods ***) + function GetFormat(out pWaveFormatCurrent: TWaveFormatEx): HResult; stdcall; + function SetFormat(const lpWaveFormat: TWaveFormatEx): HResult; stdcall; + function CreateSample(pAudioData: IAudioData; dwFlags: DWORD; + out ppSample: IAudioStreamSample): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAudioStreamSample;'} + {$EXTERNALSYM IAudioStreamSample} + IAudioStreamSample = interface(IStreamSample) + ['{345FEE00-ABA5-11D0-8212-00C04FC32C45}'] + (*** IAudioStreamSample methods ***) + function GetAudioData(out ppAudio: IAudioData): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IMemoryData;'} + {$EXTERNALSYM IMemoryData} + IMemoryData = interface(IUnknown) + ['{327FC560-AF60-11D0-8212-00C04FC32C45}'] + (*** IMemoryData methods ***) + function SetBuffer(cbSize: DWORD; pbData: pointer; dwFlags: DWORD): HResult; + stdcall; + function GetInfo(out pdwLength: DWORD; out ppbData: pointer; + out pcbActualData: DWORD): HResult; stdcall; + function SetActual(cbDataValid: DWORD): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAudioData;'} + {$EXTERNALSYM IAudioData} + IAudioData = interface(IMemoryData) + ['{54C719C0-AF60-11D0-8212-00C04FC32C45}'] + (*** IAudioData methods ***) + function GetFormat(out pWaveFormatCurrent: TWaveFormatEx): HResult; stdcall; + function SetFormat(const lpWaveFormat: TWaveFormatEx): HResult; stdcall; + end; + +(*==========================================================================; + * + * Copyright (C) 1996-1997 Microsoft Corporation. All Rights Reserved. + * + * File: mpconfig.h + * + ***************************************************************************) + +const + IID_IMixerPinConfig : TGUID = (D1:$593CDDE1;D2:$0759;D3:$11D1;D4:($9E,$69,$00,$C0,$4F,$D7,$C1,$5B)); + {$EXTERNALSYM IID_IMixerPinConfig} + IID_IMixerPinConfig2: TGUID = (D1:$ebf47182;D2:$8764;D3:$11d1;D4:($9e,$69,$00,$c0,$4f,$d7,$c1,$5b)); + {$EXTERNALSYM IID_IMixerPinConfig2} + +type + _AM_ASPECT_RATIO_MODE = ( + AM_ARMODE_STRETCHED, // don't do any aspect ratio correction + AM_ARMODE_LETTER_BOX, // letter box the video, paint background color in the excess region + AM_ARMODE_CROP, // crop the video to the right aspect ratio + AM_ARMODE_STRETCHED_AS_PRIMARY + ); + {$EXTERNALSYM _AM_ASPECT_RATIO_MODE} + AM_ASPECT_RATIO_MODE = _AM_ASPECT_RATIO_MODE; + {$EXTERNALSYM AM_ASPECT_RATIO_MODE} + TAMAspectRatioMode = AM_ASPECT_RATIO_MODE; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IMixerPinConfig;'} + {$EXTERNALSYM IMixerPinConfig} + IMixerPinConfig = interface(IUnknown) + ['{593CDDE1-0759-11D1-9E69-00C04FD7C15B}'] + (*** IMixerPinConfig methods ***) + function SetRelativePosition(dwLeft, dwTop, dwRight, dwBottom: DWORD): HResult; stdcall; + function GetRelativePosition(out dwLeft, dwTop, dwRight, dwBottom: DWORD): HResult; stdcall; + function SetZOrder(dwZOrder: DWORD): HResult; stdcall; + function GetZOrder(out dwZOrder: DWORD): HResult; stdcall; + function SetColorKey(var pColorKey: TColorKey): HResult; stdcall; + function GetColorKey(out pColorKey: TColorKey; out pColor: DWORD): HResult; stdcall; + function SetBlendingParameter(dwBlendingParameter: DWORD): HResult; stdcall; + function GetBlendingParameter(out dwBlendingParameter: DWORD): HResult; stdcall; + function SetAspectRatioMode(amAspectRatioMode: TAMAspectRatioMode): HResult; stdcall; + function GetAspectRatioMode(out amAspectRatioMode: TAMAspectRatioMode): HResult; stdcall; + function SetStreamTransparent(bStreamTransparent: BOOL): HResult; stdcall; + function GetStreamTransparent(out bStreamTransparent: BOOL): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IMixerPinConfig2;'} + {$EXTERNALSYM IMixerPinConfig2} + IMixerPinConfig2 = interface(IMixerPinConfig) + ['{EBF47182-8764-11d1-9E69-00C04FD7C15B}'] + (*** IMixerPinConfig2 methods ***) + function SetOverlaySurfaceColorControls(pColorControl: PDDColorControl): HResult; stdcall; + function GetOverlaySurfaceColorControls(out pColorControl: TDDColorControl): HResult; stdcall; + end; + +(*==========================================================================; + * + * Copyright (C) 1996-1997 Microsoft Corporation. All Rights Reserved. + * + * File: control.h + * + ***************************************************************************) + +const + LIBID_QuartzTypeLib: TGUID = (D1:$56A868B0;D2:$0AD4;D3:$11CE;D4:($B0,$3A,$00,$20,$AF,$0B,$A7,$70)); + {$EXTERNALSYM LIBID_QuartzTypeLib} + + IID_IAMCollection: TGUID = (D1:$56A868B9;D2:$0AD4;D3:$11CE;D4:($B0,$3A,$00,$20,$AF,$0B,$A7,$70)); + {$EXTERNALSYM IID_IAMCollection} + IID_IMediaControl: TGUID = (D1:$56A868B1;D2:$0AD4;D3:$11CE;D4:($B0,$3A,$00,$20,$AF,$0B,$A7,$70)); + {$EXTERNALSYM IID_IMediaControl} + IID_IMediaEvent: TGUID = (D1:$56A868B6;D2:$0AD4;D3:$11CE;D4:($B0,$3A,$00,$20,$AF,$0B,$A7,$70)); + {$EXTERNALSYM IID_IMediaEvent} + IID_IMediaEventEx: TGUID = (D1:$56A868C0;D2:$0AD4;D3:$11CE;D4:($B0,$3A,$00,$20,$AF,$0B,$A7,$70)); + {$EXTERNALSYM IID_IMediaEventEx} + IID_IMediaPosition: TGUID = (D1:$56A868B2;D2:$0AD4;D3:$11CE;D4:($B0,$3A,$00,$20,$AF,$0B,$A7,$70)); + {$EXTERNALSYM IID_IMediaPosition} + IID_IBasicAudio: TGUID = (D1:$56A868B3;D2:$0AD4;D3:$11CE;D4:($B0,$3A,$00,$20,$AF,$0B,$A7,$70)); + {$EXTERNALSYM IID_IBasicAudio} + IID_IVideoWindow: TGUID = (D1:$56A868B4;D2:$0AD4;D3:$11CE;D4:($B0,$3A,$00,$20,$AF,$0B,$A7,$70)); + {$EXTERNALSYM IID_IVideoWindow} + IID_IBasicVideo: TGUID = (D1:$56A868B5;D2:$0AD4;D3:$11CE;D4:($B0,$3A,$00,$20,$AF,$0B,$A7,$70)); + {$EXTERNALSYM IID_IBasicVideo} + IID_IBasicVideo2: TGUID = (D1:$329bb360;D2:$f6ea;D3:$11d1;D4:($90,$38,$00,$a0,$c9,$69,$72,$98)); + {$EXTERNALSYM IID_IBasicVideo2} + IID_IDeferredCommand: TGUID = (D1:$56A868B8;D2:$0AD4;D3:$11CE;D4:($B0,$3A,$00,$20,$AF,$0B,$A7,$70)); + {$EXTERNALSYM IID_IDeferredCommand} + IID_IQueueCommand: TGUID = (D1:$56A868B7;D2:$0AD4;D3:$11CE;D4:($B0,$3A,$00,$20,$AF,$0B,$A7,$70)); + {$EXTERNALSYM IID_IQueueCommand} + + CLSID_FilgraphManager: TGUID = (D1:$E436EBB3;D2:$524F;D3:$11CE;D4:($9F,$53,$00,$20,$AF,$0B,$A7,$70)); + {$EXTERNALSYM CLSID_FilgraphManager} + + IID_IFilterInfo: TGUID = (D1:$56A868BA;D2:$0AD4;D3:$11CE;D4:($B0,$3A,$00,$20,$AF,$0B,$A7,$70)); + {$EXTERNALSYM IID_IFilterInfo} + IID_IRegFilterInfo: TGUID = (D1:$56A868BB;D2:$0AD4;D3:$11CE;D4:($B0,$3A,$00,$20,$AF,$0B,$A7,$70)); + {$EXTERNALSYM IID_IRegFilterInfo} + IID_IMediaTypeInfo: TGUID = (D1:$56A868BC;D2:$0AD4;D3:$11CE;D4:($B0,$3A,$00,$20,$AF,$0B,$A7,$70)); + {$EXTERNALSYM IID_IMediaTypeInfo} + IID_IPinInfo: TGUID = (D1:$56A868BD;D2:$0AD4;D3:$11CE;D4:($B0,$3A,$00,$20,$AF,$0B,$A7,$70)); + {$EXTERNALSYM IID_IPinInfo} + IID_IAMStats: TGUID = (D1:$bc9bcf80;D2:$dcd2;D3:$11d2;D4:($ab,$f6,$00,$a0,$c9,$05,$f3,$75)); + {$EXTERNALSYM IID_IAMStats} +type + OAEVENT = {$IFDEF TYPE_IDENTITY}type {$ENDIF} Longint; + {$EXTERNALSYM OAEVENT} + OAHWND = {$IFDEF TYPE_IDENTITY}type {$ENDIF} Longint; + {$EXTERNALSYM OAHWND} + OAFilterState = {$IFDEF TYPE_IDENTITY}type {$ENDIF} Longint; + {$EXTERNALSYM OAFilterState} + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMCollection;'} + {$EXTERNALSYM IAMCollection} + IAMCollection = interface(IDispatch) + ['{56A868B9-0AD4-11CE-B03A-0020AF0BA770}'] + (*** IAMCollection methods ***) + function get_Count(out plCount: Longint): HResult; stdcall; + function Item(lItem: Longint; out ppUnk: IUnknown): HResult; stdcall; + function get__NewEnum(out ppUnk: IUnknown): HResult; stdcall; + + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IMediaControl;'} + {$EXTERNALSYM IMediaControl} + IMediaControl = interface(IDispatch) + ['{56A868B1-0AD4-11CE-B03A-0020AF0BA770}'] + (*** IMediaControl methods ***) + function Run: HResult; stdcall; + function Pause: HResult; stdcall; + function Stop: HResult; stdcall; + function GetState(msTimeout: DWORD; out pfs: TFilterState): HResult; stdcall; + function RenderFile(strFilename: WideString): HResult; stdcall; + function AddSourceFilter(strFilename: WideString; out ppUnk: IDispatch): HResult; stdcall; + function get_FilterCollection(out ppUnk: IDispatch): HResult; stdcall; + function get_RegFilterCollection(out ppUnk: IDispatch): HResult; stdcall; + function StopWhenReady: HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IMediaEvent;'} + {$EXTERNALSYM IMediaEvent} + IMediaEvent = interface(IDispatch) + ['{56A868B6-0AD4-11CE-B03A-0020AF0BA770}'] + (*** IMediaEvent methods ***) + function GetEventHandle(out hEvent: OAEVENT): HResult; stdcall; + function GetEvent(out lEventCode: Longint; out lParam1, lParam2: Longint; + msTimeout: DWORD): HResult; stdcall; + function WaitForCompletion(msTimeout: DWORD; out pEvCode: Longint): + HResult; stdcall; + function CancelDefaultHandling(lEvCode: Longint): HResult; stdcall; + function RestoreDefaultHandling(lEvCode: Longint): HResult; stdcall; + function FreeEventParams(lEvCode: Longint; lParam1, lParam2: Longint): + HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IMediaEventEx;'} + {$EXTERNALSYM IMediaEventEx} + IMediaEventEx = interface(IMediaEvent) + ['{56A868C0-0AD4-11CE-B03A-0020AF0BA770}'] + (*** IMediaEventEx methods ***) + function SetNotifyWindow(hwnd: OAHWND; lMsg: Longint; + lInstanceData: Longint): HResult; stdcall; + function SetNotifyFlags(lNoNotifyFlags: Longint): HResult; stdcall; + function GetNotifyFlags(out lplNoNotifyFlags): HResult; stdcall; //longint + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IMediaPosition;'} + {$EXTERNALSYM IMediaPosition} + IMediaPosition = interface(IDispatch) + ['{56A868B2-0AD4-11CE-B03A-0020AF0BA770}'] + (*** IMediaPosition methods ***) + function get_Duration(out plength: TRefTime): HResult; stdcall; + function put_CurrentPosition(llTime: TRefTime): HResult; stdcall; + function get_CurrentPosition(out pllTime: TRefTime): HResult; stdcall; + function get_StopTime(out pllTime: TRefTime): HResult; stdcall; + function put_StopTime(llTime: TRefTime): HResult; stdcall; + function get_PrerollTime(out pllTime: TRefTime): HResult; stdcall; + function put_PrerollTime(llTime: TRefTime): HResult; stdcall; + function put_Rate(dRate: double): HResult; stdcall; + function get_Rate(out pdRate: double): HResult; stdcall; + function CanSeekForward(out pCanSeekForward: Longint): HResult; stdcall; + function CanSeekBackward(out pCanSeekBackward: Longint): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IBasicAudio;'} + {$EXTERNALSYM IBasicAudio} + IBasicAudio = interface(IDispatch) + ['{56A868B3-0AD4-11CE-B03A-0020AF0BA770}'] + (*** IBasicAudio methods ***) + function put_Volume(lVolume: Longint): HResult; stdcall; + function get_Volume(out plVolume: Longint): HResult; stdcall; + function put_Balance(lBalance: Longint): HResult; stdcall; + function get_Balance(out plBalance: Longint): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IVideoWindow;'} + {$EXTERNALSYM IVideoWindow} + IVideoWindow = interface(IDispatch) + ['{56A868B4-0AD4-11CE-B03A-0020AF0BA770}'] + (*** IVideoWindow methods ***) + function put_Caption(strCaption: WideString): HResult; stdcall; + function get_Caption(out strCaption: WideString): HResult; stdcall; + function put_WindowStyle(WindowStyle: Longint): HResult; stdcall; + function get_WindowStyle(out WindowStyle: Longint): HResult; stdcall; + function put_WindowStyleEx(WindowStyleEx: Longint): HResult; stdcall; + function get_WindowStyleEx(out WindowStyleEx: Longint): HResult; stdcall; + function put_AutoShow(AutoShow: LongBool): HResult; stdcall; + function get_AutoShow(out AutoShow: LongBool): HResult; stdcall; + function put_WindowState(WindowState: Longint): HResult; stdcall; + function get_WindowState(out WindowState: Longint): HResult; stdcall; + function put_BackgroundPalette(BackgroundPalette: Longint): HResult; stdcall; + function get_BackgroundPalette(out pBackgroundPalette: Longint): HResult; stdcall; + function put_Visible(Visible: LongBool): HResult; stdcall; + function get_Visible(out pVisible: LongBool): HResult; stdcall; + function put_Left(Left: Longint): HResult; stdcall; + function get_Left(out pLeft: Longint): HResult; stdcall; + function put_Width(Width: Longint): HResult; stdcall; + function get_Width(out pWidth: Longint): HResult; stdcall; + function put_Top(Top: Longint): HResult; stdcall; + function get_Top(out pTop: Longint): HResult; stdcall; + function put_Height(Height: Longint): HResult; stdcall; + function get_Height(out pHeight: Longint): HResult; stdcall; + function put_Owner(Owner: OAHWND): HResult; stdcall; + function get_Owner(out Owner: OAHWND): HResult; stdcall; + function put_MessageDrain(Drain: OAHWND): HResult; stdcall; + function get_MessageDrain(out Drain: OAHWND): HResult; stdcall; + function get_BorderColor(out Color: Longint): HResult; stdcall; + function put_BorderColor(Color: Longint): HResult; stdcall; + function get_FullScreenMode(out FullScreenMode: LongBool): HResult; stdcall; + function put_FullScreenMode(FullScreenMode: LongBool): HResult; stdcall; + function SetWindowForeground(Focus: Longint): HResult; stdcall; + function NotifyOwnerMessage(hwnd: Longint; uMsg, wParam, lParam: Longint): HResult; stdcall; + function SetWindowPosition(Left, Top, Width, Height: Longint): HResult; stdcall; + function GetWindowPosition(out pLeft, pTop, pWidth, pHeight: Longint): HResult; stdcall; + function GetMinIdealImageSize(out pWidth, pHeight: Longint): HResult; stdcall; + function GetMaxIdealImageSize(out pWidth, pHeight: Longint): HResult; stdcall; + function GetRestorePosition(out pLeft, pTop, pWidth, pHeight: Longint): HResult; stdcall; + function HideCursor(HideCursor: LongBool): HResult; stdcall; + function IsCursorHidden(out CursorHidden: LongBool): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IBasicVideo;'} + {$EXTERNALSYM IBasicVideo} + IBasicVideo = interface(IDispatch) + ['{56A868B5-0AD4-11CE-B03A-0020AF0BA770}'] + (*** IBasicVideo methods ***) + function get_AvgTimePerFrame(out pAvgTimePerFrame: TRefTime): HResult; stdcall; + function get_BitRate(out pBitRate: Longint): HResult; stdcall; + function get_BitErrorRate(out pBitErrorRate: Longint): HResult; stdcall; + function get_VideoWidth(out pVideoWidth: Longint): HResult; stdcall; + function get_VideoHeight(out pVideoHeight: Longint): HResult; stdcall; + function put_SourceLeft(SourceLeft: Longint): HResult; stdcall; + function get_SourceLeft(out pSourceLeft: Longint): HResult; stdcall; + function put_SourceWidth(SourceWidth: Longint): HResult; stdcall; + function get_SourceWidth(out pSourceWidth: Longint): HResult; stdcall; + function put_SourceTop(SourceTop: Longint): HResult; stdcall; + function get_SourceTop(out pSourceTop: Longint): HResult; stdcall; + function put_SourceHeight(SourceHeight: Longint): HResult; stdcall; + function get_SourceHeight(out pSourceHeight: Longint): HResult; stdcall; + function put_DestinationLeft(DestinationLeft: Longint): HResult; stdcall; + function get_DestinationLeft(out pDestinationLeft: Longint): HResult; stdcall; + function put_DestinationWidth(DestinationWidth: Longint): HResult; stdcall; + function get_DestinationWidth(out pDestinationWidth: Longint): HResult; stdcall; + function put_DestinationTop(DestinationTop: Longint): HResult; stdcall; + function get_DestinationTop(out pDestinationTop: Longint): HResult; stdcall; + function put_DestinationHeight(DestinationHeight: Longint): HResult; stdcall; + function get_DestinationHeight(out pDestinationHeight: Longint): HResult; stdcall; + function SetSourcePosition(Left, Top, Width, Height: Longint): HResult; stdcall; + function GetSourcePosition(out pLeft, pTop, pWidth, pHeight: Longint): HResult; stdcall; + function SetDefaultSourcePosition: HResult; stdcall; + function SetDestinationPosition(Left, Top, Width, Height: Longint): HResult; stdcall; + function GetDestinationPosition(out pLeft, pTop, pWidth, pHeight: Longint): HResult; stdcall; + function SetDefaultDestinationPosition: HResult; stdcall; + function GetVideoSize(out pWidth, Height: Longint): HResult; stdcall; + function GetVideoPaletteEntries(StartIndex, Entries: Longint; + out pRetrieved: Longint; out pPalette): HResult; stdcall; + function GetCurrentImage(var BufferSize: Longint; var pDIBImage): HResult; stdcall; + function IsUsingDefaultSource: HResult; stdcall; + function IsUsingDefaultDestination: HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IBasicVideo2;'} + {$EXTERNALSYM IBasicVideo2} + IBasicVideo2 = interface(IBasicVideo) + ['{329bb360-f6ea-11d1-9038-00a0c9697298}'] + (*** IBasicVideo2 methods ***) + function GetPreferredAspectRatio(out plAspectX, plAspectY: Longint): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IDeferredCommand;'} + {$EXTERNALSYM IDeferredCommand} + IDeferredCommand = interface(IDispatch) + ['{56A868B8-0AD4-11CE-B03A-0020AF0BA770}'] + (*** IDeferredCommand methods ***) + function Cancel: HResult; stdcall; + function Confidence(out pConfidence: Longint): HResult; stdcall; + function Postpone(newtime: TRefTime): HResult; stdcall; + function GetHResult(out phrResult: HResult): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IQueueCommand;'} + {$EXTERNALSYM IQueueCommand} + IQueueCommand = interface(IUnknown) + ['{56A868B7-0AD4-11CE-B03A-0020AF0BA770}'] + (*** IQueueCommand methods ***) + function InvokeAtStreamTime(out pCmd: IDeferredCommand; time: TRefTime; + const iid: TGUID; dispidMethod: Longint; wFlags: SmallInt; + cArgs: Longint; const pDispParams: OleVariant; var pvarResult: OleVariant; + out puArgErr: SmallInt): HResult; stdcall; + function InvokeAtPresentationTime(out pCmd: IDeferredCommand; + time: TRefTime; const iid: TGUID; dispidMethod: Longint; + wFlags: SmallInt; cArgs: Longint; const pDispParams: OleVariant; + var pvarResult: OleVariant; out puArgErr: SmallInt): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IFilterInfo;'} + {$EXTERNALSYM IFilterInfo} + IFilterInfo = interface(IDispatch) + ['{56A868BA-0AD4-11CE-B03A-0020AF0BA770}'] + (*** IFilterInfo methods ***) + function FindPin(strPinID: WideString; out ppUnk: IDispatch): HResult; stdcall; + function get_Name(out strName: WideString): HResult; stdcall; + function get_VendorInfo(out strVendorInfo: WideString): HResult; stdcall; + function get_Filter(out ppUnk: IUnknown): HResult; stdcall; + function get_Pins(out ppUnk: IDispatch): HResult; stdcall; + function get_IsFileSource(out pbIsSource: LongBool): HResult; stdcall; + function get_Filename(out pstrFilename: WideString): HResult; stdcall; + function put_Filename(strFilename: WideString): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IRegFilterInfo;'} + {$EXTERNALSYM IRegFilterInfo} + IRegFilterInfo = interface(IDispatch) + ['{56A868BB-0AD4-11CE-B03A-0020AF0BA770}'] + (*** IRegFilterInfo methods ***) + function get_Name(out strName: WideString): HResult; stdcall; + function Filter(out ppUnk: IDispatch): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IMediaTypeInfo;'} + {$EXTERNALSYM IMediaTypeInfo} + IMediaTypeInfo = interface(IDispatch) + ['{56A868BC-0AD4-11CE-B03A-0020AF0BA770}'] + (*** IMediaTypeInfo methods ***) + function Get_Type(out strType: WideString): HResult; stdcall; + function Get_Subtype(out strType: WideString): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IPinInfo;'} + {$EXTERNALSYM IPinInfo} + IPinInfo = interface(IDispatch) + ['{56A868BD-0AD4-11CE-B03A-0020AF0BA770}'] + (*** IPinInfo methods ***) + function get_Pin(out ppUnk: IUnknown): HResult; stdcall; + function get_ConnectedTo(out ppUnk: IDispatch): HResult; stdcall; + function get_ConnectionMediaType(out ppUnk: IDispatch): HResult; stdcall; + function get_FilterInfo(out ppUnk: IDispatch): HResult; stdcall; + function get_Name(out ppUnk: WideString): HResult; stdcall; + function get_Direction(out ppDirection: Longint): HResult; stdcall; + function get_PinID(out strPinID: WideString): HResult; stdcall; + function get_MediaTypes(out ppUnk: IDispatch): HResult; stdcall; + function Connect(pPin: IUnknown): HResult; stdcall; + function ConnectDirect(pPin: IUnknown): HResult; stdcall; + function ConnectWithType(pPin: IUnknown; pMediaType: IDispatch): HResult; stdcall; + function Disconnect: HResult; stdcall; + function Render: HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMStats;'} + {$EXTERNALSYM IAMStats} + IAMStats = interface(IDispatch) + ['{bc9bcf80-dcd2-11d2-abf6-00a0c905f375}'] + (*** IAMStats methods ***) + function Reset: HResult; stdcall; + function get_Count(out plCount: Longint): HResult; stdcall; + function GetValueByIndex(lIndex: longint; out szName: WideString; out lCount: longint; + out dLast, dAverage, dStdDev, dMin, dMax: double): HResult; stdcall; + function GetValueByName(szName: WideString; out lIndex, lCount: Longint; + out dLast, dAverage, dStdDev, dMin, dMax: double): HResult; stdcall; + function GetIndex(szName: WideString; lCreate: longint; out plIndex: longint): HResult; stdcall; + function AddValue(lIndex: longint; dValue: double): HResult; stdcall; + end; + +(*==========================================================================; + * + * Copyright (C) 1996-1997 Microsoft Corporation. All Rights Reserved. + * + * File: qnetwork.h + * + ***************************************************************************) + +const + LIBID_QuartzNetTypeLib: TGUID = (D1:$56A868B1;D2:$0AD4;D3:$11CE;D4:($B0,$3A,$00,$20,$AF,$0B,$A7,$70)); + {$EXTERNALSYM LIBID_QuartzNetTypeLib} + + IID_IAMNetShowConfig: TGUID = (D1:$FA2AA8F1;D2:$8B62;D3:$11D0;D4:($A5,$20,$00,$00,$00,$00,$00,$00)); + {$EXTERNALSYM IID_IAMNetShowConfig} + IID_IAMChannelInfo: TGUID = (D1:$FA2AA8F2;D2:$8B62;D3:$11D0;D4:($A5,$20,$00,$00,$00,$00,$00,$00)); + {$EXTERNALSYM IID_IAMChannelInfo} + IID_IAMNetworkStatus: TGUID = (D1:$FA2AA8F3;D2:$8B62;D3:$11D0;D4:($A5,$20,$00,$00,$00,$00,$00,$00)); + {$EXTERNALSYM IID_IAMNetworkStatus} + IID_IAMExtendedSeeking: TGUID = (D1:$FA2AA8F9;D2:$8B62;D3:$11D0;D4:($A5,$20,$00,$00,$00,$00,$00,$00)); + {$EXTERNALSYM IID_IAMExtendedSeeking} + IID_IAMNetShowExProps: TGUID = (D1:$FA2AA8F5;D2:$8B62;D3:$11D0;D4:($A5,$20,$00,$00,$00,$00,$00,$00)); + {$EXTERNALSYM IID_IAMNetShowExProps} + IID_IAMExtendedErrorInfo: TGUID = (D1:$FA2AA8F6;D2:$8B62;D3:$11D0;D4:($A5,$20,$00,$00,$00,$00,$00,$00)); + {$EXTERNALSYM IID_IAMExtendedErrorInfo} + IID_IAMMediaContent: TGUID = (D1:$FA2AA8F4;D2:$8B62;D3:$11D0;D4:($A5,$20,$00,$00,$00,$00,$00,$00)); + {$EXTERNALSYM IID_IAMMediaContent} + IID_IAMMediaContent2 : TGUID = (D1:$CE8F78C1;D2:$74D9;D3:$11D2;D4:($B0,$9D,$00,$A0,$C9,$A8,$11,$17)); + {$EXTERNALSYM IID_IAMMediaContent2} + IID_IAMNetShowPreroll: TGUID = (D1:$AAE7E4E2;D2:$6388;D3:$11D1;D4:($8D,$93,$00,$60,$97,$C9,$A2,$B2)); + {$EXTERNALSYM IID_IAMNetShowPreroll} + IID_IDShowPlugin : TGUID = (D1:$4746B7C8;D2:$700E;D3:$11D1;D4:($BE,$CC,$00,$C0,$4F,$B6,$E9,$37)); + {$EXTERNALSYM IID_IDShowPlugin} + +//AMExtendedSeekingCapabilities +const + AM_EXSEEK_CANSEEK = 1; + {$EXTERNALSYM AM_EXSEEK_CANSEEK} + AM_EXSEEK_CANSCAN = 2; + {$EXTERNALSYM AM_EXSEEK_CANSCAN} + AM_EXSEEK_MARKERSEEK = 4; + {$EXTERNALSYM AM_EXSEEK_MARKERSEEK} + AM_EXSEEK_SCANWITHOUTCLOCK = 8; + {$EXTERNALSYM AM_EXSEEK_SCANWITHOUTCLOCK} + AM_EXSEEK_NOSTANDARDREPAINT = 16; + {$EXTERNALSYM AM_EXSEEK_NOSTANDARDREPAINT} + AM_EXSEEK_BUFFERING = 32; + {$EXTERNALSYM AM_EXSEEK_BUFFERING} + AM_EXSEEK_SENDS_VIDEOFRAMEREADY = 64; + {$EXTERNALSYM AM_EXSEEK_SENDS_VIDEOFRAMEREADY} + +type + DATE = record + da_year: Integer; // Year - 1980 + da_day : Byte; // Day of the month + da_mon : Byte; // Month (1 = Jan) + end; + {$EXTERNALSYM DATE} + //TDate = DATE; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMNetShowConfig;'} + {$EXTERNALSYM IAMNetShowConfig} + IAMNetShowConfig = interface(IDispatch) + ['{FA2AA8F1-8B62-11D0-A520-000000000000}'] + (*** IAMNetShowConfig methods ***) + function get_BufferingTime(var pBufferingTime: double): HResult; stdcall; + function put_BufferingTime(BufferingTime: double): HResult; stdcall; + function get_UseFixedUDPPort(var pUseFixedUDPPort: WordBool): HResult; stdcall; + function put_UseFixedUDPPort(UseFixedUDPPort: WordBool): HResult; stdcall; + function get_FixedUDPPort(var pFixedUDPPort: Longint): HResult; stdcall; + function put_FixedUDPPort(FixedUDPPort: Longint): HResult; stdcall; + function get_UseHTTPProxy(var pUseHTTPProxy: WordBool): HResult; stdcall; + function put_UseHTTPProxy(UseHTTPProxy: WordBool): HResult; stdcall; + function get_EnableAutoProxy(var pEnableAutoProxy: WordBool): HResult; stdcall; + function put_EnableAutoProxy(EnableAutoProxy: WordBool): HResult; stdcall; + function get_HTTPProxyHost(var pbstrHTTPProxyHost: TBSTR): HResult; stdcall; + function put_HTTPProxyHost(bstrHTTPProxyHost: TBSTR): HResult; stdcall; + function get_HTTPProxyPort(var pHTTPProxyPort: Longint): HResult; stdcall; + function put_HTTPProxyPort(HTTPProxyPort: Longint): HResult; stdcall; + function get_EnableMulticast(var pEnableMulticast: WordBool): HResult; stdcall; + function put_EnableMulticast(EnableMulticast: WordBool): HResult; stdcall; + function get_EnableUDP(var pEnableUDP: WordBool): HResult; stdcall; + function put_EnableUDP(EnableUDP: WordBool): HResult; stdcall; + function get_EnableTCP(var pEnableTCP: WordBool): HResult; stdcall; + function put_EnableTCP(EnableTCP: WordBool): HResult; stdcall; + function get_EnableHTTP(var pEnableHTTP: WordBool): HResult; stdcall; + function put_EnableHTTP(EnableHTTP: WordBool): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMChannelInfo;'} + {$EXTERNALSYM IAMChannelInfo} + IAMChannelInfo = interface(IDispatch) + ['{FA2AA8F2-8B62-11D0-A520-000000000000}'] + (*** IAMChannelInfo methods ***) + function get_ChannelName(var pbstrChannelName: TBSTR): HResult; stdcall; + function get_ChannelDescription(var pbstrChannelDescription: TBSTR): HResult; stdcall; + function get_ChannelURL(var pbstrChannelURL: TBSTR): HResult; stdcall; + function get_ContactAddress(var pbstrContactAddress: TBSTR): HResult; stdcall; + function get_ContactPhone(var pbstrContactPhone: TBSTR): HResult; stdcall; + function get_ContactEmail(var pbstrContactEmail: TBSTR): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMNetworkStatus;'} + {$EXTERNALSYM IAMNetworkStatus} + IAMNetworkStatus = interface(IDispatch) + ['{FA2AA8F3-8B62-11D0-A520-000000000000}'] + (*** IAMNetworkStatus methods ***) + function get_ReceivedPackets(var pReceivedPackets: Longint): HResult; stdcall; + function get_RecoveredPackets(var pRecoveredPackets: Longint): HResult; stdcall; + function get_LostPackets(var pLostPackets: Longint): HResult; stdcall; + function get_ReceptionQuality(var pReceptionQuality: Longint): HResult; stdcall; + function get_BufferingCount(var pBufferingCount: Longint): HResult; stdcall; + function get_IsBroadcast(var pIsBroadcast: WordBool): HResult; stdcall; + function get_BufferingProgress(var pBufferingProgress: Longint): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMExtendedSeeking;'} + {$EXTERNALSYM IAMExtendedSeeking} + IAMExtendedSeeking = interface(IDispatch) + ['{FA2AA8F9-8B62-11D0-A520-000000000000}'] + (*** IAMExtendedSeeking methods ***) + function get_ExSeekCapabilities(var pExCapabilities: Longint): HResult; stdcall; + function get_MarkerCount(var pMarkerCount: Longint): HResult; stdcall; + function get_CurrentMarker(var pCurrentMarker: Longint): HResult; stdcall; + function GetMarkerTime(MarkerNum: Longint; var pMarkerTime: double): HResult; stdcall; + function GetMarkerName(MarkerNum: Longint; var pbstrMarkerName: TBSTR): HResult; stdcall; + function put_PlaybackSpeed(Speed: double): HResult; stdcall; + function get_PlaybackSpeed(var pSpeed: double): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMNetShowExProps;'} + {$EXTERNALSYM IAMNetShowExProps} + IAMNetShowExProps = interface(IDispatch) + ['{FA2AA8F5-8B62-11D0-A520-000000000000}'] + (*** IAMNetShowExProps methods ***) + function get_SourceProtocol(var pSourceProtocol: Longint): HResult; stdcall; + function get_Bandwidth(var pBandwidth: Longint): HResult; stdcall; + function get_ErrorCorrection(var pbstrErrorCorrection: TBSTR): HResult; stdcall; + function get_CodecCount(var pCodecCount: Longint): HResult; stdcall; + function GetCodecInstalled(CodecNum: Longint; var pCodecInstalled: WordBool): HResult; stdcall; + function GetCodecDescription(CodecNum: Longint; var pbstrCodecDescription: TBSTR): HResult; stdcall; + function GetCodecURL(CodecNum: Longint; var pbstrCodecURL: TBSTR): HResult; stdcall; + function get_CreationDate(var pCreationDate: Date): HResult; stdcall; + function get_SourceLink(var pbstrSourceLink: TBSTR): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMExtendedErrorInfo;'} + {$EXTERNALSYM IAMExtendedErrorInfo} + IAMExtendedErrorInfo = interface(IDispatch) + ['{FA2AA8F6-8B62-11D0-A520-000000000000}'] + (*** IAMExtendedErrorInfo methods ***) + function get_HasError(var pHasError: WordBool): HResult; stdcall; + function get_ErrorDescription(var pbstrErrorDescription: TBSTR): HResult; stdcall; + function get_ErrorCode(var pErrorCode: Longint): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMMediaContent;'} + {$EXTERNALSYM IAMMediaContent} + IAMMediaContent = interface(IDispatch) + ['{FA2AA8F4-8B62-11D0-A520-000000000000}'] + (*** IAMMediaContent methods ***) + function get_AuthorName(var pbstrAuthorName: TBSTR): HResult; stdcall; + function get_Title(var pbstrTitle: TBSTR): HResult; stdcall; + function get_Rating(var pbstrRating: TBSTR): HResult; stdcall; + function get_Description(var pbstrDescription: TBSTR): HResult; stdcall; + function get_Copyright(var pbstrCopyright: TBSTR): HResult; stdcall; + function get_BaseURL(var pbstrBaseURL: TBSTR): HResult; stdcall; + function get_LogoURL(var pbstrLogoURL: TBSTR): HResult; stdcall; + function get_LogoIconURL(var pbstrLogoURL: TBSTR): HResult; stdcall; + function get_WatermarkURL(var pbstrWatermarkURL: TBSTR): HResult; stdcall; + function get_MoreInfoURL(var pbstrMoreInfoURL: TBSTR): HResult; stdcall; + function get_MoreInfoBannerImage(var pbstrMoreInfoBannerImage: TBSTR): HResult; stdcall; + function get_MoreInfoBannerURL(var pbstrMoreInfoBannerURL: TBSTR): HResult; stdcall; + function get_MoreInfoText(var pbstrMoreInfoText: TBSTR): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMMediaContent2;'} + {$EXTERNALSYM IAMMediaContent2} + IAMMediaContent2 = interface(IDispatch) + ['{CE8F78C1-74D9-11D2-B09D-00A0C9A81117}'] + (*** IAMMediaContent2 methods ***) + function get_MediaParameter(var EntryNum: longint; var bstrName, pbstrValue: TBSTR): HResult; stdcall; + function get_MediaParameterName(var EntryNum, Index: longint; var pbstrName: TBSTR): HResult; stdcall; + function get_PlaylistCount(var pNumberEntries: longint): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMNetShowPreroll;'} + {$EXTERNALSYM IAMNetShowPreroll} + IAMNetShowPreroll = interface(IDispatch) + ['{AAE7E4E2-6388-11D1-8D93-006097C9A2B2}'] + (*** IAMNetShowPreroll methods ***) + function put_Preroll(var fPreroll : WordBool): HResult; stdcall; + function get_Preroll(var pfPreroll: WordBool): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IDShowPlugin;'} + {$EXTERNALSYM IDShowPlugin} + IDShowPlugin = interface(IUnknown) + ['{4746B7C8-700E-11D1-BECC-00C04FB6E937}'] + (*** IDShowPlugin methods ***) + function get_URL(var pURL: TBSTR): HResult; stdcall; + function get_UserAgent(var pUserAgent: TBSTR): HResult; stdcall; + end; + +(*==========================================================================; + * + * Copyright (C) 1996-1997 Microsoft Corporation. All Rights Reserved. + * + * File: playlist.h + * + ***************************************************************************) + +const + IID_IAMPlayListItem: TGUID = (D1:$56A868FF;D2:$0AD4;D3:$11CE;D4:($B0,$A3,$00,$20,$AF,$0B,$A7,$70)); + {$EXTERNALSYM IID_IAMPlayListItem} + IID_IAMPlayList: TGUID = (D1:$56A868FE;D2:$0AD4;D3:$11CE;D4:($B0,$A3,$00,$20,$AF,$0B,$A7,$70)); + {$EXTERNALSYM IID_IAMPlayList} + IID_ISpecifyParticularPages : TGUID = '{4C437B91-6E9E-11d1-A704-006097C4E476}'; + {$EXTERNALSYM IID_ISpecifyParticularPages} + IID_IAMRebuild: TGUID = '{02EF04DD-7580-11d1-BECE-00C04FB6E937}'; + {$EXTERNALSYM IID_IAMRebuild} + SPECIFYPAGES_STATISTICS: TGUID = (D1:$4c437b92;D2:$6e9e;D3:$11d1;D4:($a7,$4,$0,$60,$97,$c4,$e4,$76)); + {$EXTERNALSYM SPECIFYPAGES_STATISTICS} + + AMPLAYLISTITEM_CANSKIP = 1; + {$EXTERNALSYM AMPLAYLISTITEM_CANSKIP} + AMPLAYLISTITEM_CANBIND = 2; + {$EXTERNALSYM AMPLAYLISTITEM_CANBIND} + +type + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMPlayListItem;'} + {$EXTERNALSYM IAMPlayListItem} + IAMPlayListItem = interface(IUnknown) + ['{56A868FF-0AD4-11CE-B0A3-0020AF0BA770}'] + (*** IAMPlayListItem methods ***) + function GetFlags(out pdwFlags: DWORD): HResult; stdcall; + function GetSourceCount(out pdwSources: DWORD): HResult; stdcall; + function GetSourceURL(dwSourceIndex: DWORD; out pbstrURL: WideChar): HResult; stdcall; + function GetSourceStart(dwSourceIndex: DWORD; out prtStart: TReferenceTime): HResult; stdcall; + function GetSourceDuration(dwSourceIndex: DWORD; + out prtDuration: TReferenceTime): HResult; stdcall; + function GetSourceStartMarker(dwSourceIndex: DWORD; + out pdwMarker: DWORD): HResult; stdcall; + function GetSourceEndMarker(dwSourceIndex: DWORD; + out pdwMarker: DWORD): HResult; stdcall; + function GetSourceStartMarkerName(dwSourceIndex: DWORD; + out pbstrStartMarker: WideChar): HResult; stdcall; + function GetSourceEndMarkerName(dwSourceIndex: DWORD; + out pbstrEndMarker: WideChar): HResult; stdcall; + function GetLinkURL(out pbstrURL: WideChar): HResult; stdcall; + function GetScanDuration(dwSourceIndex: DWORD; + out prtScanDuration: TReferenceTime): HResult; stdcall; + end; + +const + AMPLAYLIST_STARTINSCANMODE = 1; + {$EXTERNALSYM AMPLAYLIST_STARTINSCANMODE} + AMPLAYLIST_FORCEBANNER = 2; + {$EXTERNALSYM AMPLAYLIST_FORCEBANNER} + + AMPLAYLISTEVENT_RESUME = $0; + {$EXTERNALSYM AMPLAYLISTEVENT_RESUME} + AMPLAYLISTEVENT_BREAK = $1; + {$EXTERNALSYM AMPLAYLISTEVENT_BREAK} + AMPLAYLISTEVENT_NEXT = $2; + {$EXTERNALSYM AMPLAYLISTEVENT_NEXT} + AMPLAYLISTEVENT_MASK = $f; + {$EXTERNALSYM AMPLAYLISTEVENT_MASK} + AMPLAYLISTEVENT_REFRESH = $10; + {$EXTERNALSYM AMPLAYLISTEVENT_REFRESH} + +type + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMPlayList;'} + {$EXTERNALSYM IAMPlayList} + IAMPlayList = interface(IUnknown) + ['{56A868FE-0AD4-11CE-B0A3-0020AF0BA770}'] + (*** IAMPlayList methods ***) + function GetFlags(out pdwFlags: DWORD): HResult; stdcall; + function GetItemCount(out pdwItems: DWORD): HResult; stdcall; + function GetItem(dwItemIndex: DWORD; out ppItem: IAMPlayListItem): HResult; stdcall; + function GetNamedEvent(var pwszEventName: WideChar; dwItemIndex: DWORD; + out ppItem: IAMPlayListItem; out pdwFlags: DWORD): HResult; stdcall; + function GetRepeatInfo(out pdwRepeatCount, pdwRepeatStart, + pdwRepeatEnd: DWORD): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_ISpecifyParticularPages;'} + {$EXTERNALSYM ISpecifyParticularPages} + ISpecifyParticularPages = interface(IUnknown) + ['{4C437B91-6E9E-11d1-A704-006097C4E476}'] + (*** ISpecifyParticularPages methods ***) + function GetPages(const guidWhatPages: TGUID; out pPages: PGUID): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMRebuild;'} + {$EXTERNALSYM IAMRebuild} + IAMRebuild = interface(IUnknown) + ['{02EF04DD-7580-11d1-BECE-00C04FB6E937}'] + (*** IAMRebuild methods ***) + function RebuildNow: HResult; stdcall; + end; + +(*==========================================================================; + * + * Copyright (C) 1996-1997 Microsoft Corporation. All Rights Reserved. + * + * File: amvideo.h + * + ***************************************************************************) + +const + IID_IDirectDrawVideo: TGUID = (D1:$36D39EB0;D2:$DD75;D3:$11CE;D4:($BF,$0E,$00,$AA,$00,$55,$59,$5A)); + {$EXTERNALSYM IID_IDirectDrawVideo} + IID_IQualProp: TGUID = (D1:$1BD0ECB0;D2:$F8E2;D3:$11CE;D4:($AA,$C6,$00,$20,$AF,$0B,$99,$A3)); + {$EXTERNALSYM IID_IQualProp} + IID_IFullScreenVideo: TGUID = (D1:$DD1D7110;D2:$7836;D3:$11CF;D4:($BF,$47,$00,$AA,$00,$55,$59,$5A)); + {$EXTERNALSYM IID_IFullScreenVideo} + IID_IFullScreenVideoEx: TGUID = (D1:$53479470;D2:$F1DD;D3:$11CF;D4:($BC,$42,$00,$AA,$00,$AC,$74,$F6)); + {$EXTERNALSYM IID_IFullScreenVideoEx} + IID_IBaseVideoMixer: TGUID = (D1:$61DED640;D2:$E912;D3:$11CE;D4:($A0,$99,$00,$AA,$00,$47,$9A,$58)); + {$EXTERNALSYM IID_IBaseVideoMixer} + +const + AMDDS_NONE = $00; // No use for DCI/DirectDraw + {$EXTERNALSYM AMDDS_NONE} + AMDDS_DCIPS = $01; // Use DCI primary surface + {$EXTERNALSYM AMDDS_DCIPS} + AMDDS_PS = $02; // Use DirectDraw primary + {$EXTERNALSYM AMDDS_PS} + AMDDS_RGBOVR = $04; // RGB overlay surfaces + {$EXTERNALSYM AMDDS_RGBOVR} + AMDDS_YUVOVR = $08; // YUV overlay surfaces + {$EXTERNALSYM AMDDS_YUVOVR} + AMDDS_RGBOFF = $10; // RGB offscreen surfaces + {$EXTERNALSYM AMDDS_RGBOFF} + AMDDS_YUVOFF = $20; // YUV offscreen surfaces + {$EXTERNALSYM AMDDS_YUVOFF} + AMDDS_RGBFLP = $40; // RGB flipping surfaces + {$EXTERNALSYM AMDDS_RGBFLP} + AMDDS_YUVFLP = $80; // YUV flipping surfaces + {$EXTERNALSYM AMDDS_YUVFLP} + AMDDS_ALL = $FF; // ALL the previous flags + {$EXTERNALSYM AMDDS_ALL} + AMDDS_DEFAULT = AMDDS_ALL; // Use all available surfaces + {$EXTERNALSYM AMDDS_DEFAULT} + + AMDDS_YUV = AMDDS_YUVOFF or AMDDS_YUVOVR or AMDDS_YUVFLP; + {$EXTERNALSYM AMDDS_YUV} + AMDDS_RGB = AMDDS_RGBOFF or AMDDS_RGBOVR or AMDDS_RGBFLP; + {$EXTERNALSYM AMDDS_RGB} + AMDDS_PRIMARY = AMDDS_DCIPS or AMDDS_PS; + {$EXTERNALSYM AMDDS_PRIMARY} + +type + {$HPPEMIT 'typedef System::DelphiInterface _di_IDirectDrawVideo;'} + {$EXTERNALSYM IDirectDrawVideo} + IDirectDrawVideo = interface(IUnknown) + ['{36D39EB0-DD75-11CE-BF0E-00AA0055595A}'] + (*** IDirectDrawVideo methods ***) + function GetSwitches(out pSwitches: DWORD): HResult; stdcall; + function SetSwitches(pSwitches: DWORD): HResult; stdcall; + function GetCaps(out pCaps: TDDCaps): HResult; stdcall; + function GetEmulatedCaps(out pCaps: TDDCaps): HResult; stdcall; + function GetSurfaceDesc(out pSurfaceDesc: TDDSurfaceDesc): HResult; stdcall; + function GetFourCCCodes(out pCount, pCodes: DWORD): HResult; stdcall; + function SetDirectDraw(pDirectDraw: IDirectDraw): HResult; stdcall; + function GetDirectDraw(out ppDirectDraw: IDirectDraw): HResult; stdcall; + function GetSurfaceType(out pSurfaceType: DWORD): HResult; stdcall; + function SetDefault: HResult; stdcall; + function UseScanLine(UseScanLine: LongBool): HResult; stdcall; + function CanUseScanLine(var UseScanLine: LongBool): HResult; stdcall; + function UseOverlayStretch(UseOverlayStretch: LongBool): HResult; stdcall; + function CanUseOverlayStretch(var UseOverlayStretch: LongBool): HResult; + stdcall; + function UseWhenFullScreen(UseWhenFullScreen: LongBool): HResult; stdcall; + function WillUseFullScreen(var UseWhenFullScreen: LongBool): HResult; + stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IQualProp;'} + {$EXTERNALSYM IQualProp} + IQualProp = interface(IUnknown) + ['{1BD0ECB0-F8E2-11CE-AAC6-0020AF0B99A3}'] + (*** IQualProp methods ***) + // Compare these with the functions in class CGargle in gargle.h + function get_FramesDroppedInRenderer(var pcFrames: Integer): HResult; stdcall; + function get_FramesDrawn(out pcFrames: Integer): HResult; stdcall; + function get_AvgFrameRate(out piAvgFrameRate: Integer): HResult; stdcall; + function get_Jitter(out iJitter: Integer): HResult; stdcall; + function get_AvgSyncOffset(out piAvg: Integer): HResult; stdcall; + function get_DevSyncOffset(out piDev: Integer): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IFullScreenVideo;'} + {$EXTERNALSYM IFullScreenVideo} + IFullScreenVideo = interface(IUnknown) + ['{DD1D7110-7836-11CF-BF47-00AA0055595A}'] + (*** IFullScreenVideo methods ***) + function CountModes(out pModes: Longint): HResult; stdcall; + function GetModeInfo(Mode: Longint; out pWidth, pHeight, pDepth: Longint): + HResult; stdcall; + function GetCurrentMode(out pMode: Longint): HResult; stdcall; + function IsModeAvailable(Mode: Longint): HResult; stdcall; + function IsModeEnabled(Mode: Longint): HResult; stdcall; + function SetEnabled(Mode: Longint; bEnabled: Longint): HResult; stdcall; + function GetClipFactor(out pClipFactor: Longint): HResult; stdcall; + function SetClipFactor(ClipFactor: Longint): HResult; stdcall; + function SetMessageDrain(hwnd: HWND): HResult; stdcall; + function GetMessageDrain(out hwnd: HWND): HResult; stdcall; + function SetMonitor(Monitor: Longint): HResult; stdcall; + function GetMonitor(out Monitor: Longint): HResult; stdcall; + function HideOnDeactivate(Hide: LongBool): HResult; stdcall; + function IsHideOnDeactivate: HResult; stdcall; + function SetCaption(strCaption: TBStr): HResult; stdcall; + function GetCaption(out pstrCaption: TBStr): HResult; stdcall; + function SetDefault: HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IFullScreenVideoEx;'} + {$EXTERNALSYM IFullScreenVideoEx} + IFullScreenVideoEx = interface(IFullScreenVideo) + ['{53479470-F1DD-11CF-BC42-00AA00AC74F6}'] + (*** IFullScreenVideoEx methods ***) + // IFullScreenVideoEx + function SetAcceleratorTable(hwnd: HWND; hAccel: HACCEL): HResult; stdcall; + function GetAcceleratorTable(var hwnd: HWND; var hAccel: HACCEL): HResult; + stdcall; + function KeepPixelAspectRatio(KeepAspect: LongBool): HResult; stdcall; + function IsKeepPixelAspectRatio(var pKeepAspect: LongBool): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IBaseVideoMixer;'} + {$EXTERNALSYM IBaseVideoMixer} + IBaseVideoMixer = interface(IUnknown) + ['{61DED640-E912-11CE-A099-00AA00479A58}'] + (*** IBaseVideoMixer methods ***) + function SetLeadPin(iPin: Integer): HResult; stdcall; + function GetLeadPin(out iPin: Integer): HResult; stdcall; + function GetInputPinCount(out piPinCount: Integer): HResult; stdcall; + function IsUsingClock(out pbValue: Integer): HResult; stdcall; + function SetUsingClock(bValue: Integer): HResult; stdcall; + function GetClockPeriod(out pbValue: Integer): HResult; stdcall; + function SetClockPeriod(bValue: Integer): HResult; stdcall; + end; + +const + iPALETTE_COLORS = 256; // Maximum colours in palette + {$EXTERNALSYM iPALETTE_COLORS} + iEGA_COLORS = 16; // Number colours in EGA palette + {$EXTERNALSYM iEGA_COLORS} + iMASK_COLORS = 3; // Maximum three components + {$EXTERNALSYM iMASK_COLORS} + iTRUECOLOR = 16; // Minimum true colour device + {$EXTERNALSYM iTRUECOLOR} + iRED = 0; // Index position for RED mask + {$EXTERNALSYM iRED} + iGREEN = 1; // Index position for GREEN mask + {$EXTERNALSYM iGREEN} + iBLUE = 2; // Index position for BLUE mask + {$EXTERNALSYM iBLUE} + iPALETTE = 8; // Maximum colour depth using a palette + {$EXTERNALSYM iPALETTE} + iMAXBITS = 8; // Maximum bits per colour component + {$EXTERNALSYM iMAXBITS} + +type + // Used for true colour images that also have a palette + tag_TRUECOLORINFO = record + dwBitMasks: array[0..iMASK_COLORS-1] of DWORD; + bmiColors: array[0..iPALETTE_COLORS-1] of TRGBQuad; + end; + {$EXTERNALSYM tag_TRUECOLORINFO} + TRUECOLORINFO = tag_TRUECOLORINFO; + {$EXTERNALSYM TRUECOLORINFO} + TTrueColorInfo = tag_TRUECOLORINFO; + + PVideoInfoHeader = ^TVideoInfoHeader; + tagVIDEOINFOHEADER = record + rcSource: TRect; // The bit we really want to use + rcTarget: TRect; // Where the video should go + dwBitRate: DWORD; // Approximate bit data rate + dwBitErrorRate: DWORD; // Bit error rate for this stream + AvgTimePerFrame: TReferenceTime; // Average time per frame (100ns units) + + bmiHeader: TBitmapInfoHeader; + end; + {$EXTERNALSYM tagVIDEOINFOHEADER} + VIDEOINFOHEADER = tagVIDEOINFOHEADER; + {$EXTERNALSYM VIDEOINFOHEADER} + TVideoInfoHeader = tagVIDEOINFOHEADER; + +// make sure the pbmi is initialized before using these macros +{function TRUECOLOR(pbmi: PBitmapInfo): Pointer; +function COLORS(pbmi: PBitmapInfo): Pointer; +function BITMASKS(pbmi: PBitmapInfo): Pointer; +{ +#define TRUECOLOR(pbmi) ((TRUECOLORINFO *)(((LPBYTE)&((pbmi)->bmiHeader)) \ + + (pbmi)->bmiHeader.biSize)) +#define COLORS(pbmi) ((RGBQUAD *)(((LPBYTE)&((pbmi)->bmiHeader)) \ + + (pbmi)->bmiHeader.biSize)) +#define BITMASKS(pbmi) ((DWORD *)(((LPBYTE)&((pbmi)->bmiHeader)) \ + + (pbmi)->bmiHeader.biSize)) + } +// All the image based filters use this to communicate their media types. It's +// centred principally around the BITMAPINFO. This structure always contains a +// BITMAPINFOHEADER followed by a number of other fields depending on what the +// BITMAPINFOHEADER contains. If it contains details of a palettised format it +// will be followed by one or more RGBQUADs defining the palette. If it holds +// details of a true colour format then it may be followed by a set of three +// DWORD bit masks that specify where the RGB data can be found in the image +// (For more information regarding BITMAPINFOs see the Win32 documentation) + +// The rcSource and rcTarget fields are not for use by filters supplying the +// data. The destination (target) rectangle should be set to all zeroes. The +// source may also be zero filled or set with the dimensions of the video. So +// if the video is 352x288 pixels then set it to (0,0,352,288). These fields +// are mainly used by downstream filters that want to ask the source filter +// to place the image in a different position in an output buffer. So when +// using for example the primary surface the video renderer may ask a filter +// to place the video images in a destination position of (100,100,452,388) +// on the display since that's where the window is positioned on the display + +// !!! WARNING !!! +// DO NOT use this structure unless you are sure that the BITMAPINFOHEADER +// has a normal biSize == sizeof(BITMAPINFOHEADER) ! +// !!! WARNING !!! + +type + PVideoInfo = ^TVideoInfo; + tagVIDEOINFO = record + rcSource: TRect; // The bit we really want to use + rcTarget: TRect; // Where the video should go + dwBitRate: DWORD; // Approximate bit data rate + dwBitErrorRate: DWORD; // Bit error rate for this stream + AvgTimePerFrame: TReferenceTime; // Average time per frame (100ns units) + + bmiHeader: TBitmapInfoHeader; + + case Integer of + 0: ( + bmiColors: array[0..iPALETTE_COLORS-1] of TRGBQuad // Colour palette + ); + 1: ( + dwBitMasks: array[0..iMASK_COLORS-1] of DWORD // True colour masks + ); + 2: ( + TrueColorInfo: TTrueColorInfo // Both of the above + ); + end; + {$EXTERNALSYM tagVIDEOINFO} + VIDEOINFO = tagVIDEOINFO; + {$EXTERNALSYM VIDEOINFO} + TVideoInfo = tagVIDEOINFO; + +// These macros define some standard bitmap format sizes + +const + SIZE_EGA_PALETTE = iEGA_COLORS * SizeOf(TRGBQuad); + {$EXTERNALSYM SIZE_EGA_PALETTE} + SIZE_PALETTE = iPALETTE_COLORS * SizeOf(TRGBQuad); + {$EXTERNALSYM SIZE_PALETTE} + SIZE_MASKS = iMASK_COLORS * SizeOf(DWORD); + {$EXTERNALSYM SIZE_MASKS} + + SIZE_PREHEADER = 48; // offset TVideoInfoHeader.bmiHeader + {$EXTERNALSYM SIZE_PREHEADER} + SIZE_VIDEOHEADER = SizeOf(TVideoInfoHeader); + {$EXTERNALSYM SIZE_VIDEOHEADER} + +// !!! for abnormal biSizes +// #define SIZE_VIDEOHEADER(pbmi) ((pbmi)->bmiHeader.biSize + SIZE_PREHEADER) + +// DIBSIZE calculates the number of bytes required by an image +{ +function WIDTHBYTES(bits: Integer): DWORD; +function DIBWIDTHBYTES(const bhi: TBitmapInfoHeader): DWORD; +function _DIBSIZE(const bmi: TBitmapInfoHeader): DWORD; +function DIBSIZE(const bmi: TBitmapInfoHeader): DWORD; +{ +#define WIDTHBYTES(bits) ((DWORD)(((bits)+31) & (~31)) / 8) +#define DIBWIDTHBYTES(bi) (DWORD)WIDTHBYTES((DWORD)(bi).biWidth * (DWORD)(bi).biBitCount) +#define _DIBSIZE(bi) (DIBWIDTHBYTES(bi) * (DWORD)(bi).biHeight) +#define DIBSIZE(bi) ((bi).biHeight < 0 ? (-1)*(_DIBSIZE(bi)) : _DIBSIZE(bi)) +} +// This compares the bit masks between two VIDEOINFOHEADERs +{ +function BIT_MASKS_MATCH(const bmi1, bmi2: TBitmapInfo): Boolean; +{ +#define BIT_MASKS_MATCH(pbmi1,pbmi2) \ + (((pbmi1)->dwBitMasks[iRED] == (pbmi2)->dwBitMasks[iRED]) && \ + ((pbmi1)->dwBitMasks[iGREEN] == (pbmi2)->dwBitMasks[iGREEN]) && \ + ((pbmi1)->dwBitMasks[iBLUE] == (pbmi2)->dwBitMasks[iBLUE])) +} +// These zero fill different parts of the VIDEOINFOHEADER structure + +// Only use these macros for pbmi's with a normal BITMAPINFOHEADER biSize +{procedure RESET_MASKS(var bmi: TBitmapInfo); +procedure RESET_HEADER(var bmi: TBitmapInfo); +procedure RESET_PALETTE(var bmi: TBitmapInfo); +{ +#define RESET_MASKS(pbmi) (ZeroMemory((PVOID)(pbmi)->dwBitFields,SIZE_MASKS)) +#define RESET_HEADER(pbmi) (ZeroMemory((PVOID)(pbmi),SIZE_VIDEOHEADER)) +#define RESET_PALETTE(pbmi) (ZeroMemory((PVOID)(pbmi)->bmiColors,SIZE_PALETTE)); +} +{ +// !!! This is the right way to do it, but may break existing code +#define RESET_MASKS(pbmi) (ZeroMemory((PVOID)(((LPBYTE)(pbmi)->bmiHeader) + \ + (pbmi)->bmiHeader.biSize,SIZE_MASKS))) +#define RESET_HEADER(pbmi) (ZeroMemory((PVOID)(pbmi), SIZE_PREHEADER + \ + sizeof(BITMAPINFOHEADER))) +#define RESET_PALETTE(pbmi) (ZeroMemory((PVOID)(((LPBYTE)(pbmi)->bmiHeader) + \ + (pbmi)->bmiHeader.biSize,SIZE_PALETTE)) +} + +// Other (hopefully) useful bits and bobs +{ +#define PALETTISED(pbmi) ((pbmi)->bmiHeader.biBitCount <= iPALETTE) +#define PALETTE_ENTRIES(pbmi) ((DWORD) 1 << (pbmi)->bmiHeader.biBitCount) + +// Returns the address of the BITMAPINFOHEADER from the VIDEOINFOHEADER +#define HEADER(pVideoInfo) (&(((VIDEOINFOHEADER *) (pVideoInfo))->bmiHeader)) + } + +// MPEG variant - includes a DWORD length followed by the +// video sequence header after the video header. +// +// The sequence header includes the sequence header start code and the +// quantization matrices associated with the first sequence header in the +// stream so is a maximum of 140 bytes long. +type + PMPEG1VideoInfo = ^TMPEG1VideoInfo; + tagMPEG1VIDEOINFO = record + hdr: TVideoInfoHeader; // Compatible with VIDEOINFO + dwStartTimeCode: DWORD; // 25-bit Group of pictures time code + // at start of data + cbSequenceHeader: DWORD; // Length in bytes of bSequenceHeader + bSequenceHeader: array[0..0] of Byte; // Sequence header including + // quantization matrices if any + end; + {$EXTERNALSYM tagMPEG1VIDEOINFO} + MPEG1VIDEOINFO = tagMPEG1VIDEOINFO; + {$EXTERNALSYM MPEG1VIDEOINFO} + TMPEG1VideoInfo = tagMPEG1VIDEOINFO; + +const + MAX_SIZE_MPEG1_SEQUENCE_INFO = 140; + {$EXTERNALSYM MAX_SIZE_MPEG1_SEQUENCE_INFO} +{ +#define SIZE_MPEG1VIDEOINFO(pv) (FIELD_OFFSET(MPEG1VIDEOINFO, bSequenceHeader[0]) + (pv)->cbSequenceHeader) +#define MPEG1_SEQUENCE_INFO(pv) ((const BYTE *)(pv)->bSequenceHeader) +} + +// Analog video variant - Use this when the format is FORMAT_AnalogVideo +// +// rcSource defines the portion of the active video signal to use +// rcTarget defines the destination rectangle +// both of the above are relative to the dwActiveWidth and dwActiveHeight fields +// dwActiveWidth is currently set to 720 for all formats (but could change for HDTV) +// dwActiveHeight is 483 for NTSC and 575 for PAL/SECAM (but could change for HDTV) +type + tagAnalogVideoInfo = record + rcSource: TRect; // Width max is 720, height varies w/ TransmissionS + rcTarget: TRect; // Where the video should go + dwBitRate: DWORD; // Always 720 (CCIR-601 active samples per line) + dwBitErrorRate: DWORD; // 483 for NTSC, 575 for PAL/SECAM + AvgTimePerFrame: TReferenceTime; // Normal ActiveMovie units (100 nS) + end; + {$EXTERNALSYM tagAnalogVideoInfo} + ANALOGVIDEOINFO = tagAnalogVideoInfo; + {$EXTERNALSYM ANALOGVIDEOINFO} + TAnalogVideoInfo = tagAnalogVideoInfo; + + +// +// AM_KSPROPSETID_FrameStep property set definitions +// + + AM_PROPERTY_FRAMESTEP = ( + {$IFNDEF COMPILER6_UP} + AM_PROPERTY_FRAMESTEP_INVALID_O, + // Step + AM_PROPERTY_FRAMESTEP_STEP, + AM_PROPERTY_FRAMESTEP_CANCEL, + // S_OK for these 2 means we can - S_FALSE if we can't + AM_PROPERTY_FRAMESTEP_CANSTEP, + AM_PROPERTY_FRAMESTEP_CANSTEPMULTIPLE + {$ELSE} + // Step + AM_PROPERTY_FRAMESTEP_STEP = 1, + AM_PROPERTY_FRAMESTEP_CANCEL = 2 , + // S_OK for these 2 means we can - S_FALSE if we can't + AM_PROPERTY_FRAMESTEP_CANSTEP = 3, + AM_PROPERTY_FRAMESTEP_CANSTEPMULTIPLE = 4 + {$ENDIF} + ); + {$EXTERNALSYM AM_PROPERTY_FRAMESTEP} + TAMPropertyFramesStep = AM_PROPERTY_FRAMESTEP; + + + _AM_FRAMESTEP_STEP = record + // 1 means step 1 frame forward + // 0 is invalid + // n (n > 1) means skip n - 1 frames and show the nth + dwFramesToStep: DWORD; + end; + {$EXTERNALSYM _AM_FRAMESTEP_STEP} + AM_FRAMESTEP_STEP = _AM_FRAMESTEP_STEP; + {$EXTERNALSYM AM_FRAMESTEP_STEP} + TAMFramestepStep = _AM_FRAMESTEP_STEP; + +(*==========================================================================; + * + * Copyright (C) 1996-1997 Microsoft Corporation. All Rights Reserved. + * + * File: amaudio.h + * + ***************************************************************************) + +const + IID_IAMDirectSound: TGUID = (D1:$546F4260;D2:$D53E;D3:$11CF;D4:($B3,$F0,$00,$AA,$00,$37,$61,$C5)); + {$EXTERNALSYM IID_IAMDirectSound} + +// This is the interface the audio renderer supports to give the application +// access to the direct sound object and buffers it is using, to allow the +// application to use things like the 3D features of Direct Sound for the +// soundtrack of a movie being played with Active Movie + +// be nice to our friends in C +type + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMDirectSound;'} + {$EXTERNALSYM IAMDirectSound} + IAMDirectSound = interface(IUnknown) + ['{546F4260-D53E-11CF-B3F0-00AA003761C5}'] + (*** IAMDirectSound methods ***) + function GetDirectSoundInterface(out lplpds: IDirectSound): HResult; + stdcall; + function GetPrimaryBufferInterface(out lplpdsb: IDirectSoundBuffer): + HResult; stdcall; + function GetSecondaryBufferInterface(out lplpdsb: IDirectSoundBuffer): + HResult; stdcall; + function ReleaseDirectSoundInterface(lpds: IDirectSound): HResult; stdcall; + function ReleasePrimaryBufferInterface(lpdsb: IDirectSoundBuffer): HResult; + stdcall; + function ReleaseSecondaryBufferInterface(lpdsb: IDirectSoundBuffer): + HResult; stdcall; + function SetFocusWindow(hwnd: HWND; b: BOOL): HResult; stdcall; + function GetFocusWindow(var hwnd: HWND; var b: BOOL): HResult; stdcall; + end; + +(*==========================================================================; + * + * Copyright (C) 1996-1997 Microsoft Corporation. All Rights Reserved. + * + * File: vptype.h + * + ***************************************************************************) + +type + // enum to specify the criterion, which the vpmixer is supposed to use + // in order to select the video format + _AMVP_SELECT_FORMAT_BY = ( + AMVP_DO_NOT_CARE, + AMVP_BEST_BANDWIDTH, + AMVP_INPUT_SAME_AS_OUTPUT + ); + {$EXTERNALSYM _AMVP_SELECT_FORMAT_BY} + AMVP_SELECT_FORMAT_BY = _AMVP_SELECT_FORMAT_BY; + {$EXTERNALSYM AMVP_SELECT_FORMAT_BY} + TAMVPSelectFormatBy = AMVP_SELECT_FORMAT_BY; + + // enum to specify the various mode + _AMVP_MODE = ( + AMVP_MODE_WEAVE, + AMVP_MODE_BOBINTERLEAVED, + AMVP_MODE_BOBNONINTERLEAVED, + AMVP_MODE_SKIPEVEN, + AMVP_MODE_SKIPODD + ); + {$EXTERNALSYM _AMVP_MODE} + AMVP_MODE = _AMVP_MODE; + {$EXTERNALSYM AMVP_MODE} + TAMVPMode = AMVP_MODE; + + // struct to specify the width and height. The context could be anything + // such as scaling cropping etc. + PAMVPSize = ^TAMVPSize; + _AMVPSIZE = record + dwWidth : DWORD; // the width + dwHeight : DWORD; // the height + end; + {$EXTERNALSYM _AMVPSIZE} + AMVPSIZE = _AMVPSIZE; + {$EXTERNALSYM AMVPSIZE} + LPAMVPSIZE = ^AMVPSIZE; + {$EXTERNALSYM LPAMVPSIZE} + TAMVPSize = _AMVPSIZE; + + // struct to specify the dimensional characteristics of the input stream + PAMVPDimInfo = ^TAMVPDimInfo; + _AMVPDIMINFO = record + {$EXTERNALSYM _AMVPDIMINFO} + dwFieldWidth : DWORD; // Field height of the data + dwFieldHeight : DWORD; // Field width of the data + dwVBIWidth : DWORD; // Width of the VBI data + dwVBIHeight : DWORD; // Height of the VBI data + rcValidRegion : TRect; // The vaild rectangle, used for cropping + end; + AMVPDIMINFO = _AMVPDIMINFO; + {$EXTERNALSYM AMVPDIMINFO} + LPAMVPDIMINFO = ^AMVPDIMINFO; + {$EXTERNALSYM LPAMVPDIMINFO} + TAMVPDimInfo = _AMVPDIMINFO; + + // struct to specify the various data specific characteristics of the input stream + PAMVPDataInfo = ^TAMVPDataInfo; + _AMVPDATAINFO = record + dwSize : DWORD; // Size of the struct + dwMicrosecondsPerField : DWORD; // Time taken by each field + amvpDimInfo : TAMVPDIMInfo; // Dimensional Information + dwPictAspectRatioX : DWORD; // X dimension of Picture Aspect Ratio + dwPictAspectRatioY : DWORD; // Y dimension of Picture Aspect Ratio + bEnableDoubleClock : BOOL; // Videoport should enable double clocking + bEnableVACT : BOOL; // Videoport should use an external VACT signal + bDataIsInterlaced : BOOL; // Indicates that the signal is interlaced + lHalfLinesOdd : Longint; // number of halflines in the odd field + bFieldPolarityInverted : BOOL; // Device inverts the polarity by default + dwNumLinesInVREF : DWORD; // Number of lines of data in VREF + lHalfLinesEven : Longint; // number of halflines in the even field + dwReserved1 : DWORD; // Reserved for future use + end; + {$EXTERNALSYM _AMVPDATAINFO} + AMVPDATAINFO = _AMVPDATAINFO; + {$EXTERNALSYM AMVPDATAINFO} + LPAMVPDATAINFO = ^AMVPDATAINFO; + {$EXTERNALSYM LPAMVPDATAINFO} + TAMVPDataInfo = _AMVPDATAINFO; + +(*==========================================================================; + * + * Copyright (C) 1996-1997 Microsoft Corporation. All Rights Reserved. + * + * File: vpconfig.h + * + ***************************************************************************) + +const + IID_IVPConfig: TGUID = (D1:$BC29A660;D2:$30E3;D3:$11D0;D4:($9E,$69,$00,$C0,$4F,$D7,$C1,$5B)); + {$EXTERNALSYM IID_IVPConfig} + IID_IVPVBIConfig: TGUID = (D1:$EC529B00;D2:$1A1F;D3:$11D1;D4:($BA,$D9,$00,$60,$97,$44,$11,$1A)); + {$EXTERNALSYM IID_IVPVBIConfig} + +type + {$HPPEMIT 'typedef System::DelphiInterface _di_IVPBaseConfig;'} + {$EXTERNALSYM IVPBaseConfig} + IVPBaseConfig = interface(IUnknown) + (*** IVPBaseConfig methods ***) + // gets the various connection information structures (guid, portwidth) + // in an array of structures. If the pointer to the array is NULL, first + // parameter returns the total number of formats supported. + function GetConnectInfo(var pdwNumConnectInfo: PDWORD; + var pddVPConnectInfo: PDDVideoPortConnect): HResult; stdcall; + + // sets the connection entry chosen (0, 1, .. ,(dwNumProposedEntries-1)) + function SetConnectInfo(dwChosenEntry: DWORD): HResult; stdcall; + + // gets various data parameters, includes dimensionnal info + function GetVPDataInfo(var pamvpDataInfo: PAMVPDataInfo): HResult; stdcall; + + // retrives maximum pixels per second rate expected for a given + // format and a given scaling factor. If decoder does not support + // those scaling factors, then it gives the rate and the nearest + // scaling factors. + function GetMaxPixelRate(var pamvpSize: PAMVPSize; + out pdwMaxPixelsPerSecond: PDWORD): HResult; stdcall; + + // informs the callee of the videoformats supported by the videoport + function InformVPInputFormats(dwNumFormats: DWORD; + pTDDPixelFormats: PDDPixelFormat): HResult; stdcall; + + // gets the various formats supported by the decoder in an array + // of structures. If the pointer to the array is NULL, first parameter + // returns the total number of formats supported. + function GetVideoFormats(var pdwNumFormats: PDWORD; + var pTDDPixelFormats: PDDPixelFormat): HResult; stdcall; + + // sets the format entry chosen (0, 1, .. ,(dwNumProposedEntries-1)) + function SetVideoFormat(dwChosenEntry: DWORD): HResult; stdcall; + + // asks the decoder to treat even fields like odd fields and visa versa + function SetInvertPolarity: HResult; stdcall; + + // the mixer uses this function to determine if the callee wants + // the vpmixer to use its overlay surface and if so to get a pointer to it + function GetOverlaySurface(out ppddOverlaySurface: IDirectDrawSurface): + HResult; stdcall; + + // sets the direct draw kernel handle + function SetDirectDrawKernelHandle(dwDDKernelHandle: THandle): HResult; + stdcall; + + // sets the video port id + function SetVideoPortID(dwVideoPortID: DWORD): HResult; stdcall; + + // sets the direct draw surface kernel handle + function SetDDSurfaceKernelHandles(cHandles: DWORD; + var rgDDKernelHandles: THandle): HResult; stdcall; + + // Tells driver about surface created on its behalf by ovmixer/vbisurf and + // returned from videoport/ddraw. Should always return NOERROR or E_NOIMPL. + // dwPitch is the pitch of the surface (distance in pixels between the start + // pixels of two consecutive lines of the surface). (dwXOrigin, dwYOrigin) + // are the (X, Y) coordinates of the pixel at which valid data starts. + function SetSurfaceParameters(dwPitch, dwXOrigin, dwYOrigin: DWORD): + HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IVPConfig;'} + {$EXTERNALSYM IVPConfig} + IVPConfig = interface(IVPBaseConfig) + ['{BC29A660-30E3-11D0-9E69-00C04FD7C15B}'] + (*** IVPConfig methods ***) + // the mixer uses this function to determine if the callee wants + // the mixer to decimate VIDEO data at its own descrition + function IsVPDecimationAllowed(out pbIsDecimationAllowed: PBOOL): HResult; + stdcall; + + // sets the scaling factors. If decoder does not support these, + // then it sets the values to the nearest factors it can support + function SetScalingFactors(pamvpSize: PAMVPSize): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IVPVBIConfig;'} + {$EXTERNALSYM IVPVBIConfig} + IVPVBIConfig = interface(IVPBaseConfig) + ['{EC529B00-1A1F-11D1-BAD9-00609744111A}'] + (*** IVPVBIConfig methods ***) + end; + +(*==========================================================================; + * + * Copyright (C) 1996-1997 Microsoft Corporation. All Rights Reserved. + * + * File: vpnotify.h + * + ***************************************************************************) + +const + IID_IVPNotify: TGUID = (D1:$C76794A1;D2:$D6C5;D3:$11D0;D4:($9E,$69,$00,$C0,$4F,$D7,$C1,$5B)); + {$EXTERNALSYM IID_IVPNotify} + IID_IVPVBINotify: TGUID = (D1:$EC529B01;D2:$1A1F;D3:$11D1;D4:($BA,$D9,$00,$60,$97,$44,$11,$1A)); + {$EXTERNALSYM IID_IVPVBINotify} + IID_IVPNotify2: TGUID = (D1:$ebf47183;D2:$8764;D3:$11d1;D4:($9e,$69,$00,$c0,$4f,$d7,$c1,$5b)); + {$EXTERNALSYM IID_IVPNotify2} + +type + {$HPPEMIT 'typedef System::DelphiInterface _di_IVPBaseNotify;'} + {$EXTERNALSYM IVPBaseNotify} + IVPBaseNotify = interface(IUnknown) + (*** IVPBaseNotify methods ***) + // this function initializes the reconnection to the decoder. + function RenegotiateVPParameters: HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IVPNotify;'} + {$EXTERNALSYM IVPNotify} + IVPNotify = interface(IVPBaseNotify) + ['{C76794A1-D6C5-11D0-9E69-00C04FD7C15B}'] + (*** IVPNotify methods ***) + // function to set the mode (bob, weave etc) + function SetDeinterlaceMode(mode: TAMVPMode): HResult; stdcall; + // function to get the mode (bob, weave etc) + function GetDeinterlaceMode(out pMode: TAMVPMode): HResult; stdcall; + end; + +// 4 functions have been removed from dxmedia!! + {$HPPEMIT 'typedef System::DelphiInterface _di_IVPNotify2;'} + {$EXTERNALSYM IVPNotify2} + IVPNotify2 = interface(IVPNotify) + ['{EBF47183-8764-11d1-9E69-00C04FD7C15B}'] + (*** IVPNotify2 methods ***) + // function to set the mode (bob, weave etc) + function SetVPSyncMaster(bVPSyncMaster: BOOL): HResult; stdcall; + // function to get the mode (bob, weave etc) + function GetVPSyncMaster(OUT pbVPSyncMaster: BOOL): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IVPVBINotify;'} + {$EXTERNALSYM IVPVBINotify} + IVPVBINotify = interface(IVPBaseNotify) + ['{EC529B01-1A1F-11D1-BAD9-00609744111A}'] + (*** IVPVBINotify methods ***) + end; + +(*==========================================================================; + * + * Copyright (C) 1996-1997 Microsoft Corporation. All Rights Reserved. + * + * File: mpegtype.h + * + ***************************************************************************) + +const + IID_IMpegAudioDecoder: TGUID = (D1:$B45DD570;D2:$3C77;D3:$11D1;D4:($AB,$E1,$00,$A0,$C9,$05,$F3,$75)); + {$EXTERNALSYM IID_IMpegAudioDecoder} + +type +// +// AM_MPEGSYSTEMTYPE defines the format block contents for +// data of type MEDIATYPE_MPEG1System when the format +// block GUID is FORMAT_MPEG1System +// +// The format block consists of elements of type +// AM_MPEGSYSTEMTYPE up to the length of the format block +// Each format block is 8-byte aligned from the start of +// the format block +// + + tagAM_MPEGSTREAMTYPE = record + dwStreamId: DWORD; // Stream id of stream to process + dwReserved: DWORD; // 8-byte alignment + mt: TAMMediaType; // Type for substream - pbFormat is NULL + bFormat: array[0..0] of Byte; // Format data + end; + {$EXTERNALSYM tagAM_MPEGSTREAMTYPE} + AM_MPEGSTREAMTYPE = tagAM_MPEGSTREAMTYPE; + {$EXTERNALSYM AM_MPEGSTREAMTYPE} + TAMMPEGStreamType = tagAM_MPEGSTREAMTYPE; + + tagAM_MPEGSYSTEMTYPE = record + dwBitRate: DWORD; // Bits per second + cStreams: DWORD; // Number of streams + Streams: array[0..0] of TAMMPEGStreamType; + end; + {$EXTERNALSYM tagAM_MPEGSYSTEMTYPE} + AM_MPEGSYSTEMTYPE = tagAM_MPEGSYSTEMTYPE; + {$EXTERNALSYM AM_MPEGSYSTEMTYPE} + TAMMPEGSystemType = tagAM_MPEGSYSTEMTYPE; +{ +// +// Helper macros for AM_MPEGSTREAMTYPE +// +#define AM_MPEGSTREAMTYPE_ELEMENTLENGTH(pStreamType) \ + FIELD_OFFSET(AM_MPEGSTREAMTYPE, bFormat[(pStreamType)->mt.cbFormat]) +#define AM_MPEGSTREAMTYPE_NEXT(pStreamType) \ + ((AM_MPEGSTREAMTYPE *)((PBYTE)(pStreamType) + \ + ((AM_MPEGSTREAMTYPE_ELEMENTLENGTH(pStreamType) + 7) & ~7))) + } +// +// IMpegAudioDecoder +// + +// Values for DualMode +const + AM_MPEG_AUDIO_DUAL_MERGE = 0; + {$EXTERNALSYM AM_MPEG_AUDIO_DUAL_MERGE} + AM_MPEG_AUDIO_DUAL_LEFT = 1; + {$EXTERNALSYM AM_MPEG_AUDIO_DUAL_LEFT} + AM_MPEG_AUDIO_DUAL_RIGHT = 2; + {$EXTERNALSYM AM_MPEG_AUDIO_DUAL_RIGHT} + +type +// +// +// Microsoft MPEG audio WAV definition +// +(* MPEG-1 audio wave format (audio layer only). (0x0050) *) + + MPEG1WAVEFORMAT = record + wfx: TWaveFormatEx; + fwHeadLayer: Word; + dwHeadBitrate: DWORD; + fwHeadMode: Word; + fwHeadModeExt: Word; + wHeadEmphasis: Word; + fwHeadFlags: Word; + dwPTSLow: DWORD; + dwPTSHigh: DWORD; + end; + {$EXTERNALSYM MPEG1WAVEFORMAT} + TMPEG1WaveFormat = MPEG1WAVEFORMAT; + +const + ACM_MPEG_LAYER1 = $0001; + {$EXTERNALSYM ACM_MPEG_LAYER1} + ACM_MPEG_LAYER2 = $0002; + {$EXTERNALSYM ACM_MPEG_LAYER2} + ACM_MPEG_LAYER3 = $0004; + {$EXTERNALSYM ACM_MPEG_LAYER3} + ACM_MPEG_STEREO = $0001; + {$EXTERNALSYM ACM_MPEG_STEREO} + ACM_MPEG_JOINTSTEREO = $0002; + {$EXTERNALSYM ACM_MPEG_JOINTSTEREO} + ACM_MPEG_DUALCHANNEL = $0004; + {$EXTERNALSYM ACM_MPEG_DUALCHANNEL} + ACM_MPEG_SINGLECHANNEL = $0008; + {$EXTERNALSYM ACM_MPEG_SINGLECHANNEL} + ACM_MPEG_PRIVATEBIT = $0001; + {$EXTERNALSYM ACM_MPEG_PRIVATEBIT} + ACM_MPEG_COPYRIGHT = $0002; + {$EXTERNALSYM ACM_MPEG_COPYRIGHT} + ACM_MPEG_ORIGINALHOME = $0004; + {$EXTERNALSYM ACM_MPEG_ORIGINALHOME} + ACM_MPEG_PROTECTIONBIT = $0008; + {$EXTERNALSYM ACM_MPEG_PROTECTIONBIT} + ACM_MPEG_ID_MPEG1 = $0010; + {$EXTERNALSYM ACM_MPEG_ID_MPEG1} + +type + {$HPPEMIT 'typedef System::DelphiInterface _di_IMpegAudioDecoder;'} + {$EXTERNALSYM IMpegAudioDecoder} + IMpegAudioDecoder = interface(IUnknown) + ['{B45DD570-3C77-11D1-ABE1-00A0C905F375}'] + (*** IMpegAudioDecoder methods ***) + function get_FrequencyDivider(out pDivider: LongWord): HResult; stdcall; + function put_FrequencyDivider(Divider: LongWord): HResult; stdcall; + function get_DecoderAccuracy(out pAccuracy: LongWord): HResult; stdcall; + function put_DecoderAccuracy(Accuracy: LongWord): HResult; stdcall; + function get_Stereo(out pStereo: LongWord): HResult; stdcall; + function put_Stereo(Stereo: LongWord): HResult; stdcall; + function get_DecoderWordSize(out pWordSize: LongWord): HResult; stdcall; + function put_DecoderWordSize(WordSize: LongWord): HResult; stdcall; + function get_IntegerDecode(out pIntDecode: LongWord): HResult; stdcall; + function put_IntegerDecode(IntDecode: LongWord): HResult; stdcall; + function get_DualMode(out pIntDecode: LongWord): HResult; stdcall; + function put_DualMode(IntDecode: LongWord): HResult; stdcall; + function get_AudioFormat(out lpFmt: TMPEG1WaveFormat): HResult; stdcall; + end; + +(*==========================================================================; + * + * Copyright (C) 1996-1997 Microsoft Corporation. All Rights Reserved. + * + * File: il21dec.h + * + ***************************************************************************) +// Line 21 Decoder related definitions and interfaces for ActiveMovie + +const + IID_IAMLine21Decoder: TGUID = (D1:$6E8D4A21;D2:$310C;D3:$11D0;D4:($B7,$9A,$00,$AA,$00,$37,$67,$A7)); + {$EXTERNALSYM IID_IAMLine21Decoder} + +type +// +// Some enum data types used as line 21 decoder params by the interface +// + _AM_LINE21_CCLEVEL = ( // should we use TC1, TC2 in stead? + AM_L21_CCLEVEL_TC2 + ); + {$EXTERNALSYM _AM_LINE21_CCLEVEL} + AM_LINE21_CCLEVEL = _AM_LINE21_CCLEVEL; + {$EXTERNALSYM AM_LINE21_CCLEVEL} + PAM_LINE21_CCLEVEL = ^AM_LINE21_CCLEVEL; + {$EXTERNALSYM PAM_LINE21_CCLEVEL} + TAMLine21CCLevel = AM_LINE21_CCLEVEL; + + _AM_LINE21_CCSERVICE = ( + {$IFNDEF COMPILER6_UP} + AM_L21_CCSERVICE_None, + AM_L21_CCSERVICE_Caption1, + AM_L21_CCSERVICE_Caption2, + AM_L21_CCSERVICE_Text1, + AM_L21_CCSERVICE_Text2, + AM_L21_CCSERVICE_XDS, + AM_L21_CCSERVICE_INVALID_6, + AM_L21_CCSERVICE_INVALID_7, + AM_L21_CCSERVICE_INVALID_8, + AM_L21_CCSERVICE_INVALID_9, + AM_L21_CCSERVICE_DefChannel, + AM_L21_CCSERVICE_Invalid + {$ELSE} + AM_L21_CCSERVICE_None = 0, + AM_L21_CCSERVICE_Caption1 = 1, + AM_L21_CCSERVICE_Caption2 = 2, + AM_L21_CCSERVICE_Text1 = 3, + AM_L21_CCSERVICE_Text2 = 4, + AM_L21_CCSERVICE_XDS = 5, + AM_L21_CCSERVICE_DefChannel = 10, + AM_L21_CCSERVICE_Invalid = 11 + {$ENDIF} + ); + {$EXTERNALSYM _AM_LINE21_CCSERVICE} + AM_LINE21_CCSERVICE = _AM_LINE21_CCSERVICE; + {$EXTERNALSYM AM_LINE21_CCSERVICE} + PAM_LINE21_CCSERVICE = ^AM_LINE21_CCSERVICE; + {$EXTERNALSYM PAM_LINE21_CCSERVICE} + TAMLine21CCService = AM_LINE21_CCSERVICE; + + _AM_LINE21_CCSTATE = ( + AM_L21_CCSTATE_Off, + AM_L21_CCSTATE_On + ); + {$EXTERNALSYM _AM_LINE21_CCSTATE} + AM_LINE21_CCSTATE = _AM_LINE21_CCSTATE; + {$EXTERNALSYM AM_LINE21_CCSTATE} + PAM_LINE21_CCSTATE = ^AM_LINE21_CCSTATE; + {$EXTERNALSYM PAM_LINE21_CCSTATE} + TAMLine21CCState = AM_LINE21_CCSTATE; + + _AM_LINE21_CCSTYLE = ( + AM_L21_CCSTYLE_None, + AM_L21_CCSTYLE_PopOn, + AM_L21_CCSTYLE_PaintOn, + AM_L21_CCSTYLE_RollUp + ); + {$EXTERNALSYM _AM_LINE21_CCSTYLE} + AM_LINE21_CCSTYLE = _AM_LINE21_CCSTYLE; + {$EXTERNALSYM AM_LINE21_CCSTYLE} + PAM_LINE21_CCSTYLE = ^AM_LINE21_CCSTYLE; + {$EXTERNALSYM PAM_LINE21_CCSTYLE} + TAMLine21CCStyle = AM_LINE21_CCSTYLE; + + _AM_LINE21_DRAWBGMODE = ( + AM_L21_DRAWBGMODE_Opaque, + AM_L21_DRAWBGMODE_Transparent + ); + {$EXTERNALSYM _AM_LINE21_DRAWBGMODE} + AM_LINE21_DRAWBGMODE = _AM_LINE21_DRAWBGMODE; + {$EXTERNALSYM AM_LINE21_DRAWBGMODE} + PAM_LINE21_DRAWBGMODE = ^AM_LINE21_DRAWBGMODE; + {$EXTERNALSYM PAM_LINE21_DRAWBGMODE} + TAMLine21DrawBGMode = AM_LINE21_DRAWBGMODE; + +// +// Line 21 Decoder standard COM interface +// + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMLine21Decoder;'} + {$EXTERNALSYM IAMLine21Decoder} + IAMLine21Decoder = interface(IUnknown) + ['{6E8D4A21-310C-11D0-B79A-00AA003767A7}'] + (*** IAMLine21Decoder methods ***) + // + // Decoder options to be used by apps + // + + // What is the decoder's level + function GetDecoderLevel(var lpLevel: TAMLine21CCLevel): HResult; stdcall; + // supported level value is AM_L21Level_TC2 only + // skipping the SetDecoderLevel( ) + + // Which of the services is being currently used + function GetCurrentService(var lpService: TAMLine21CCService): HResult; + stdcall; + function SetCurrentService(Service: TAMLine21CCService): HResult; + stdcall; + // supported service values are AM_L21Service_Caption1, + // AM_L21Service_Caption2, AM_L21Service_Text1, AM_L21Service_Text2, + // AM_L21Service_XDS, AM_L21Service_None) + + // Query/Set the service state (On/Off) + // supported state values are AM_L21State_On and AM_L21State_Off + function GetServiceState(var lpState: TAMLine21CCState): HResult; + stdcall; + function SetServiceState(State: TAMLine21CCState): HResult; + stdcall; + + // + // Output options to be used by downstream filters + // + + // What size, bitdepth etc should the output video be + function GetOutputFormat(lpbmih: PBitmapInfoHeader): HResult; stdcall; + // GetOutputFormat() method, if successful, returns + // 1. S_FALSE if no output format has so far been defined by downstream filters + // 2. S_OK if an output format has already been defined by downstream filters + function SetOutputFormat(lpbmih: PBitmapInfoHeader): HResult; + stdcall; + + // Specify physical color to be used in colorkeying the background + // for overlay mixing + function GetBackgroundColor(var pdwPhysColor: DWORD): HResult; stdcall; + function SetBackgroundColor(dwPhysColor: DWORD): HResult; stdcall; + + // Specify if whole output bitmap should be redrawn for each sample + function GetRedrawAlways(lpbOption: PBOOL): HResult; stdcall; + function SetRedrawAlways(bOption: BOOL): HResult; stdcall; + + // Specify if the caption text background should be opaque/transparent + function GetDrawBackgroundMode(var lpMode: TAMLine21DrawBGMode): HResult; + stdcall; + function SetDrawBackgroundMode(Mode: TAMLine21DrawBGMode): HResult; + stdcall; + // supported mode values are AM_L21_DrawBGMode_Opaque and + // AM_L21_DrawBGMode_Transparent + end; + +(*==========================================================================; + * + * Copyright (C) 1996-1997 Microsoft Corporation. All Rights Reserved. + * + * File: dvdevcod.h + * + ***************************************************************************) +// list of standard DVD-Video event codes and the expected params + +const + EC_DVDBASE = $0100; + {$EXTERNALSYM EC_DVDBASE} + +type + _tagDVD_ERROR = ( + {$IFNDEF COMPILER6_UP} + DVD_ERROR_INVALID_0, + DVD_ERROR_Unexpected, // Something unexpected happened, perhaps content + // is incorrectly authored. Playback is stopped. + DVD_ERROR_CopyProtectFail, // Key exchange for DVD copy protection failed. + // Playback is stopped. + DVD_ERROR_InvalidDVD1_0Disc, // DVD-Video disc is incorrectly authored for v1.0 + // of spec. Playback is stopped. + DVD_ERROR_InvalidDiscRegion, // The Disc is not approved for playback by decoders + // from this DVD region. + DVD_ERROR_LowParentalLevel, // Player parental level is lower than the lowest parental + // level available in the DVD content. Playback is stopped. + DVD_ERROR_MacrovisionFail, // Macrovision Distribution Failed. + // Playback is stopped. + DVD_ERROR_IncompatibleSystemAndDecoderRegions, + // No discs can be played because the system region + // does not match the decoder region. + DVD_ERROR_IncompatibleDiscAndDecoderRegions + // The disc cannot be played because the disc is + // not authored to be played in the decoder's region + {$ELSE} + DVD_ERROR_Unexpected = 1, // Something unexpected happened, perhaps content + // is incorrectly authored. Playback is stopped. + DVD_ERROR_CopyProtectFail = 2, // Key exchange for DVD copy protection failed. + // Playback is stopped. + DVD_ERROR_InvalidDVD1_0Disc = 3, // DVD-Video disc is incorrectly authored for v1.0 + // of spec. Playback is stopped. + DVD_ERROR_InvalidDiscRegion = 4, // The Disc is not approved for playback by decoders + // from this DVD region. + DVD_ERROR_LowParentalLevel = 5, // Player parental level is lower than the lowest parental + // level available in the DVD content. Playback is stopped. + DVD_ERROR_MacrovisionFail = 6, // Macrovision Distribution Failed. + // Playback is stopped. + DVD_ERROR_IncompatibleSystemAndDecoderRegions = 7, + // No discs can be played because the system region + // does not match the decoder region. + DVD_ERROR_IncompatibleDiscAndDecoderRegions = 8 + // The disc cannot be played because the disc is + // not authored to be played in the decoder's region + {$ENDIF} + ); + {$EXTERNALSYM _tagDVD_ERROR} + DVD_ERROR = _tagDVD_ERROR; + {$EXTERNALSYM DVD_ERROR} + TDVDError = DVD_ERROR; + + _tagDVD_WARNING = ( + {$IFNDEF COMPILER6_UP} + DVD_WARNING_INVALID_0, + DVD_WARNING_InvalidDVD1_0Disc, // DVD-Video disc is incorrectly authored. Playback + // can continue, but unexpected behavior may occur. + DVD_WARNING_FormatNotSupported, // A decoder would not support the current format. Playback + // of a stream (audio, video of SP) may not function. + // lParam2 contains the stream type (see AM_DVD_STREAM_FLAGS) -> Windows XP + DVD_WARNING_IllegalNavCommand, // The internal DVD navigation command processor attempted to + // process an illegal command. + DVD_WARNING_Open, // File Open Failed + DVD_WARNING_Seek, // File Seek Failed + DVD_WARNING_Read // File Read Failed + {$ELSE} + DVD_WARNING_InvalidDVD1_0Disc = 1, // DVD-Video disc is incorrectly authored. Playback + // can continue, but unexpected behavior may occur. + DVD_WARNING_FormatNotSupported = 2, // A decoder would not support the current format. Playback + // of a stream (audio, video of SP) may not function. + // lParam2 contains the stream type (see AM_DVD_STREAM_FLAGS) -> Windows XP + DVD_WARNING_IllegalNavCommand = 3, // The internal DVD navigation command processor attempted to + // process an illegal command. + DVD_WARNING_Open = 4, // File Open Failed + DVD_WARNING_Seek = 5, // File Seek Failed + DVD_WARNING_Read = 6 // File Read Failed + {$ENDIF} + ); + {$EXTERNALSYM _tagDVD_WARNING} + DVD_WARNING = _tagDVD_WARNING; + {$EXTERNALSYM DVD_WARNING} + TDVDWarning = DVD_WARNING; + + _tagDVD_PB_STOPPED = ( + DVD_PB_STOPPED_Other, // The navigator stopped the playback (no reason available). + DVD_PB_STOPPED_NoBranch, // The nav completed the current pgc and there was no more video and + // did not find any other branching instruction for subsequent playback. + DVD_PB_STOPPED_NoFirstPlayDomain, // The disc does not contain an initial startup program. + DVD_PB_STOPPED_StopCommand, // The app issued a stop() command or a stop command was authored on the disc. + DVD_PB_STOPPED_Reset, // The navigator was reset to the start of the disc (using ResetOnStop). + DVD_PB_STOPPED_DiscEjected, // The disc was ejected. + DVD_PB_STOPPED_IllegalNavCommand, // An illegal nav command prevented playback from continuing. + DVD_PB_STOPPED_PlayPeriodAutoStop, // PlayPeriod completed + DVD_PB_STOPPED_PlayChapterAutoStop, // PlayChapter completed + DVD_PB_STOPPED_ParentalFailure, // A parental level failure prevented playback + DVD_PB_STOPPED_RegionFailure, // A region failure prevented playback + DVD_PB_STOPPED_MacrovisionFailure, // A Macrovision failure prevented playback. + DVD_PB_STOPPED_DiscReadError, // A read error prevented playback. + DVD_PB_STOPPED_CopyProtectFailure // Copy protection failure. + ); + {$EXTERNALSYM _tagDVD_PB_STOPPED} + DVD_PB_STOPPED = _tagDVD_PB_STOPPED; + {$EXTERNALSYM DVD_PB_STOPPED} + TDVDPBStopped = DVD_PB_STOPPED; + +const + +// DVD-Video event codes +// ====================== +// +// All DVD-Video event are always passed on to the application, and are +// never processed by the filter graph + + + EC_DVD_DOMAIN_CHANGE = (EC_DVDBASE + $01); + {$EXTERNALSYM EC_DVD_DOMAIN_CHANGE} +// Parameters: ( DWORD, void ) +// lParam1 is enum DVD_DOMAIN, and indicates the player's new domain +// +// Raised from following domains: all +// +// Signaled when ever the DVD player changes domains. + + + EC_DVD_TITLE_CHANGE = (EC_DVDBASE + $02); + {$EXTERNALSYM EC_DVD_TITLE_CHANGE} +// Parameters: ( DWORD, void ) +// lParam1 is the new title number. +// +// Raised from following domains: DVD_DOMAIN_Title +// +// Indicates when the current title number changes. Title numbers +// range 1 to 99. This indicates the TTN, which is the title number +// with respect to the whole disc, not the VTS_TTN which is the title +// number with respect to just a current VTS. + + + EC_DVD_CHAPTER_START = (EC_DVDBASE + $03); + {$EXTERNALSYM EC_DVD_CHAPTER_START} +// Parameters: ( DWORD, void ) +// lParam1 is the new chapter number (which is the program number for +// One_Sequential_PGC_Titles). +// +// Raised from following domains: DVD_DOMAIN_Title +// +// Signales that DVD player started playback of a new program in the Title +// domain. This is only signaled for One_Sequential_PGC_Titles. + + + EC_DVD_AUDIO_STREAM_CHANGE = (EC_DVDBASE + $04); + {$EXTERNALSYM EC_DVD_AUDIO_STREAM_CHANGE} +// Parameters: ( DWORD, void ) +// lParam1 is the new user audio stream number. +// +// Raised from following domains: all +// +// Signaled when ever the current user audio stream number changes for the main +// title. This can be changed automatically with a navigation command on disc +// as well as through IDVDAnnexJ. +// Audio stream numbers range from 0 to 7. Stream $ffffffff +// indicates that no stream is selected. + + EC_DVD_SUBPICTURE_STREAM_CHANGE = (EC_DVDBASE + $05); + {$EXTERNALSYM EC_DVD_SUBPICTURE_STREAM_CHANGE} +// Parameters: ( DWORD, BOOL ) -> WindowsXP +// Parameters: ( DWORD, void ) +// lParam1 is the new user subpicture stream number. +// lParam2 is the subpicture's on/off state (TRUE if on) -> WindowsXP + +// Raised from following domains: all +// +// Signaled when ever the current user subpicture stream number changes for the main +// title. This can be changed automatically with a navigation command on disc +// as well as through IDVDAnnexJ. +// Subpicture stream numbers range from 0 to 31. Stream $ffffffff +// indicates that no stream is selected. + + EC_DVD_ANGLE_CHANGE = (EC_DVDBASE + $06); + {$EXTERNALSYM EC_DVD_ANGLE_CHANGE} +// Parameters: ( DWORD, DWORD ) +// lParam1 is the number of available angles. +// lParam2 is the current user angle number. +// +// Raised from following domains: all +// +// Signaled when ever either +// a) the number of available angles changes, or +// b) the current user angle number changes. +// Current angle number can be changed automatically with navigation command +// on disc as well as through IDVDAnnexJ. +// When the number of available angles is 1, the current video is not multiangle. +// Angle numbers range from 1 to 9. + + + EC_DVD_BUTTON_CHANGE = (EC_DVDBASE + $07); + {$EXTERNALSYM EC_DVD_BUTTON_CHANGE} +// Parameters: ( DWORD, DWORD ) +// lParam1 is the number of available buttons. +// lParam2 is the current selected button number. +// +// Raised from following domains: all +// +// Signaled when ever either +// a) the number of available buttons changes, or +// b) the current selected button number changes. +// The current selected button can be changed automatically with navigation +// commands on disc as well as through IDVDAnnexJ. +// Button numbers range from 1 to 36. Selected button number 0 implies that +// no button is selected. Note that these button numbers enumerate all +// available button numbers, and do not always correspond to button numbers +// used for IDVDAnnexJ::ButtonSelectAndActivate since only a subset of buttons +// may be activated with ButtonSelectAndActivate. + + + EC_DVD_VALID_UOPS_CHANGE = (EC_DVDBASE + $08); + {$EXTERNALSYM EC_DVD_VALID_UOPS_CHANGE} +// Parameters: ( DWORD, void ) +// lParam1 is a VALID_UOP_SOMTHING_OR_OTHER bit-field stuct which indicates +// which IDVDAnnexJ commands are explicitly disable by the DVD disc. +// +// Raised from following domains: all +// +// Signaled when ever the available set of IDVDAnnexJ methods changes. This +// only indicates which operations are explicited disabled by the content on +// the DVD disc, and does not guarentee that it is valid to call methods +// which are not disabled. For example, if no buttons are currently present, +// IDVDAnnexJ::ButtonActivate() won't work, even though the buttons are not +// explicitly disabled. + + + EC_DVD_STILL_ON = (EC_DVDBASE + $09); + {$EXTERNALSYM EC_DVD_STILL_ON} +// Parameters: ( BOOL, DWORD ) +// lParam1 == 0 --> buttons are available, so StillOff won't work +// lParam1 == 1 --> no buttons available, so StillOff will work +// lParam2 indicates the number of seconds the still will last, with $ffffffff +// indicating an infinite still (wait till button or StillOff selected). +// +// Raised from following domains: all +// +// Signaled at the beginning of any still: PGC still, Cell Still, or VOBU Still. +// Note that all combinations of buttons and still are possible (buttons on with +// still on, buttons on with still off, button off with still on, button off +// with still off). + + EC_DVD_STILL_OFF = (EC_DVDBASE + $0a); + {$EXTERNALSYM EC_DVD_STILL_OFF} +// Parameters: ( void, void ) +// +// Indicating that any still that is currently active +// has been released. +// +// Raised from following domains: all +// +// Signaled at the end of any still: PGC still, Cell Still, or VOBU Still. +// + + EC_DVD_CURRENT_TIME = (EC_DVDBASE + $0b); + {$EXTERNALSYM EC_DVD_CURRENT_TIME} +// Parameters: ( DWORD, BOOL ) +// lParam1 is a DVD_TIMECODE which indicates the current +// playback time code in a BCD HH:MM:SS:FF format. +// lParam2 == 0 --> time code is 25 frames/sec +// lParam2 == 1 --> time code is 30 frames/sec (non-drop). +// +// Raised from following domains: DVD_DOMAIN_Title +// +// Signaled at the beginning of every VOBU, which occurs every .4 to 1.0 sec. +// This is only signaled for One_Sequential_PGC_Titles. + + + EC_DVD_ERROR = (EC_DVDBASE + $0c); + {$EXTERNALSYM EC_DVD_ERROR} +// Parameters: ( DWORD, void) +// lParam1 is an enum DVD_ERROR which notifies the app of some error condition. +// +// Raised from following domains: all +// + + EC_DVD_WARNING = (EC_DVDBASE + $0d); + {$EXTERNALSYM EC_DVD_WARNING} +// Parameters: ( DWORD, DWORD) -> WindowsXP +// Parameters: ( DWORD, void) +// lParam1 is an enum DVD_WARNING which notifies the app of some warning condition. +// lParam2 contains more specific information about the warning (warning dependent) -> WindowsXP + +// Raised from following domains: all +// + + EC_DVD_CHAPTER_AUTOSTOP = (EC_DVDBASE + $0e); + {$EXTERNALSYM EC_DVD_CHAPTER_AUTOSTOP} +// Parameters: (void, void) +// +// Indicating that playback is stopped as a result of a call +// to IDVDControl::ChapterPlayAutoStop() +// +// Raised from following domains : DVD_DOMAIN_TITLE +// + + EC_DVD_NO_FP_PGC = (EC_DVDBASE + $0f); + {$EXTERNALSYM EC_DVD_NO_FP_PGC} +// Parameters : (void, void) +// +// Raised from the following domains : FP_DOM +// +// Indicates that the DVD disc does not have a FP_PGC (First Play Program Chain) +// and the DVD Navigator will not automatically load any PGC and start playback. +// + + EC_DVD_PLAYBACK_RATE_CHANGE = (EC_DVDBASE + $10); + {$EXTERNALSYM EC_DVD_PLAYBACK_RATE_CHANGE} +// Parameters : (LONG, void) +// lParam1 is a LONG indicating the new playback rate. +// lParam1 < 0 indicates reverse playback mode. +// lParam1 > 0 indicates forward playback mode +// Value of lParam1 is the actual playback rate multiplied by 10000. +// i.e. lParam1 = rate * 10000 +// +// Raised from the following domains : TT_DOM +// +// Indicates that a rate change in playback has been initiated and the parameter +// lParam1 indicates the new playback rate that is being used. +// + + EC_DVD_PARENTAL_LEVEL_CHANGE = (EC_DVDBASE + $11); + {$EXTERNALSYM EC_DVD_PARENTAL_LEVEL_CHANGE} +// Parameters : (LONG, void) +// lParam1 is a LONG indicating the new parental level. +// +// Raised from the following domains : VMGM_DOM +// +// Indicates that an authored Nav command has changed the parental level +// setting in the player. +// + + EC_DVD_PLAYBACK_STOPPED = (EC_DVDBASE + $12); + {$EXTERNALSYM EC_DVD_PLAYBACK_STOPPED} +// Parameters : (DWORD, void) +// +// Raised from the following domains : All Domains +// +// Indicates that playback has been stopped as the Navigator has completed +// playback of the pgc and did not find any other branching instruction for +// subsequent playback. +// +// The DWORD returns the reason for the completion of the playback. See +// The DVD_PB_STOPPED enumeration for details. +// + + EC_DVD_ANGLES_AVAILABLE = (EC_DVDBASE + $13); + {$EXTERNALSYM EC_DVD_ANGLES_AVAILABLE} +// Parameters : (BOOL, void) +// lParam1 == 0 indicates that playback is not in an angle block and angles are +// not available +// lParam1 == 1 indicates that an angle block is being played back and angle changes +// can be performed. +// +// Indicates whether an angle block is being played and if angle changes can be +// performed. However, angle changes are not restricted to angle blocks and the +// manifestation of the angle change can be seen only in an angle block. + + EC_DVD_PLAYPERIOD_AUTOSTOP = (EC_DVDBASE + $14); + {$EXTERNALSYM EC_DVD_PLAYPERIOD_AUTOSTOP} +// Parameters: (void, void) +// Sent when the PlayPeriodInTitle completes or is cancelled +// +// Raised from following domains : DVD_DOMAIN_TITLE +// + + EC_DVD_BUTTON_AUTO_ACTIVATED = (EC_DVDBASE + $15); + {$EXTERNALSYM EC_DVD_BUTTON_AUTO_ACTIVATED} +// Parameters: (DWORD button, void) +// Sent when a button is automatically activated +// +// Raised from following domains : DVD_DOMAIN_MENU +// + + EC_DVD_CMD_START = (EC_DVDBASE + $16); + {$EXTERNALSYM EC_DVD_CMD_START} +// Parameters: (CmdID, HResult) +// Sent when a command begins +// + + EC_DVD_CMD_END = (EC_DVDBASE + $17); + {$EXTERNALSYM EC_DVD_CMD_END} +// Parameters: (CmdID, HResult) +// Sent when a command completes +// + + EC_DVD_DISC_EJECTED = (EC_DVDBASE + $18); + {$EXTERNALSYM EC_DVD_DISC_EJECTED} +// Parameters: none +// Sent when the nav detects that a disc was ejected and stops the playback +// The app does not need to take any action to stop the playback. +// + + EC_DVD_DISC_INSERTED = (EC_DVDBASE + $19); + {$EXTERNALSYM EC_DVD_DISC_INSERTED} +// Parameters: none +// Sent when the nav detects that a disc was inserted and the nav begins playback +// The app does not need to take any action to start the playback. +// + + EC_DVD_CURRENT_HMSF_TIME = (EC_DVDBASE + $1a); + {$EXTERNALSYM EC_DVD_CURRENT_HMSF_TIME} +// Parameters: ( ULONG, ULONG ) +// lParam2 contains a union of the DVD_TIMECODE_FLAGS +// lParam1 contains a DVD_HMSF_TIMECODE. Assign lParam1 to a ULONG then cast the +// ULONG as a DVD_HMSF_TIMECODE to use its values. +// +// Raised from following domains: DVD_DOMAIN_Title +// +// Signaled at the beginning of every VOBU, which occurs every .4 to 1.0 sec. + + EC_DVD_KARAOKE_MODE = (EC_DVDBASE + $1b); + {$EXTERNALSYM EC_DVD_KARAOKE_MODE} +// Parameters: ( BOOL, reserved ) +// lParam1 is either TRUE (a karaoke track is being played) or FALSE (no karaoke data is being played). +// + +(*==========================================================================; + * + * Copyright (C) 1996-1997 Microsoft Corporation. All Rights Reserved. + * + * File: dvdmedia.h + * + ***************************************************************************) + +type +// ----------------------------------------------------------------------- +// AC-3 definition for the AM_KSPROPSETID_AC3 property set +// ----------------------------------------------------------------------- + AM_PROPERTY_AC3 = ( + AM_PROPERTY_AC3_INVALID_0, + AM_PROPERTY_AC3_ERROR_CONCEALMENT, + AM_PROPERTY_AC3_ALTERNATE_AUDIO, + AM_PROPERTY_AC3_DOWNMIX, + AM_PROPERTY_AC3_BIT_STREAM_MODE, + AM_PROPERTY_AC3_DIALOGUE_LEVEL, + AM_PROPERTY_AC3_LANGUAGE_CODE, + AM_PROPERTY_AC3_ROOM_TYPE + ); + {$EXTERNALSYM AM_PROPERTY_AC3} + TAMPropertyAC3 = AM_PROPERTY_AC3; + + AM_AC3_ERROR_CONCEALMENT = record + fRepeatPreviousBlock: BOOL; + fErrorInCurrentBlock: BOOL; + end; + {$EXTERNALSYM AM_AC3_ERROR_CONCEALMENT} + PAM_AC3_ERROR_CONCEALMENT = ^AM_AC3_ERROR_CONCEALMENT; + {$EXTERNALSYM PAM_AC3_ERROR_CONCEALMENT} + TAMAC3ErrorConcelment = AM_AC3_ERROR_CONCEALMENT; + + AM_AC3_ALTERNATE_AUDIO = record + fStereo: BOOL; + DualMode: ULONG; + end; + {$EXTERNALSYM AM_AC3_ALTERNATE_AUDIO} + PAM_AC3_ALTERNATE_AUDIO = ^AM_AC3_ALTERNATE_AUDIO; + {$EXTERNALSYM PAM_AC3_ALTERNATE_AUDIO} + TAMAC3AlteranateAudio = AM_AC3_ALTERNATE_AUDIO; + +const + AM_AC3_ALTERNATE_AUDIO_1 = 1; + {$EXTERNALSYM AM_AC3_ALTERNATE_AUDIO_1} + AM_AC3_ALTERNATE_AUDIO_2 = 2; + {$EXTERNALSYM AM_AC3_ALTERNATE_AUDIO_2} + AM_AC3_ALTERNATE_AUDIO_BOTH = 3; + {$EXTERNALSYM AM_AC3_ALTERNATE_AUDIO_BOTH} + +type + AM_AC3_DOWNMIX = record + fDownMix : BOOL; + fDolbySurround : BOOL; + end; + {$EXTERNALSYM AM_AC3_DOWNMIX} + PAM_AC3_DOWNMIX = ^AM_AC3_DOWNMIX; + {$EXTERNALSYM PAM_AC3_DOWNMIX} + TAMAC3DownMix = AM_AC3_DOWNMIX; + + AM_AC3_BIT_STREAM_MODE = record + BitStreamMode: Longint; + end; + {$EXTERNALSYM AM_AC3_BIT_STREAM_MODE} + PAM_AC3_BIT_STREAM_MODE = ^AM_AC3_BIT_STREAM_MODE; + {$EXTERNALSYM PAM_AC3_BIT_STREAM_MODE} + TAMAC3BitStreamMode = AM_AC3_BIT_STREAM_MODE; +const + AM_AC3_SERVICE_MAIN_AUDIO = 0; + {$EXTERNALSYM AM_AC3_SERVICE_MAIN_AUDIO} + AM_AC3_SERVICE_NO_DIALOG = 1; + {$EXTERNALSYM AM_AC3_SERVICE_NO_DIALOG} + AM_AC3_SERVICE_VISUALLY_IMPAIRED = 2; + {$EXTERNALSYM AM_AC3_SERVICE_VISUALLY_IMPAIRED} + AM_AC3_SERVICE_HEARING_IMPAIRED = 3; + {$EXTERNALSYM AM_AC3_SERVICE_HEARING_IMPAIRED} + AM_AC3_SERVICE_DIALOG_ONLY = 4; + {$EXTERNALSYM AM_AC3_SERVICE_DIALOG_ONLY} + AM_AC3_SERVICE_COMMENTARY = 5; + {$EXTERNALSYM AM_AC3_SERVICE_COMMENTARY} + AM_AC3_SERVICE_EMERGENCY_FLASH = 6; + {$EXTERNALSYM AM_AC3_SERVICE_EMERGENCY_FLASH} + AM_AC3_SERVICE_VOICE_OVER = 7; + {$EXTERNALSYM AM_AC3_SERVICE_VOICE_OVER} + +type + AM_AC3_DIALOGUE_LEVEL = record + DialogueLevel: ULONG; + end; + {$EXTERNALSYM AM_AC3_DIALOGUE_LEVEL} + PAM_AC3_DIALOGUE_LEVEL = ^AM_AC3_DIALOGUE_LEVEL; + {$EXTERNALSYM PAM_AC3_DIALOGUE_LEVEL} + TAMAC3DialogueLevel = AM_AC3_DIALOGUE_LEVEL; + + AM_AC3_ROOM_TYPE = record + fLargeRoom: BOOL; + end; + {$EXTERNALSYM AM_AC3_ROOM_TYPE} + PAM_AC3_ROOM_TYPE = ^AM_AC3_ROOM_TYPE; + {$EXTERNALSYM PAM_AC3_ROOM_TYPE} + TAMAC3RoomType = AM_AC3_ROOM_TYPE; + +// ----------------------------------------------------------------------- +// subpicture definition for the AM_KSPROPSETID_DvdSubPic property set +// ----------------------------------------------------------------------- + + AM_PROPERTY_DVDSUBPIC = ( + AM_PROPERTY_DVDSUBPIC_PALETTE, + AM_PROPERTY_DVDSUBPIC_HLI, + AM_PROPERTY_DVDSUBPIC_COMPOSIT_ON // TRUE for subpicture is displayed + ); + {$EXTERNALSYM AM_PROPERTY_DVDSUBPIC} + TAM_Property_DVDSubpic = AM_PROPERTY_DVDSUBPIC; + + _AM_DVD_YUV = record + Reserved: Byte; + Y: byte; + U: Byte; + V: Byte; + end; + {$EXTERNALSYM _AM_DVD_YUV} + AM_DVD_YUV = _AM_DVD_YUV; + {$EXTERNALSYM AM_DVD_YUV} + TAMDVDYUV = _AM_DVD_YUV; + + _AM_PROPERTY_SPPAL = record + sppal: array[0..15] of TAMDVDYUV; + end; + {$EXTERNALSYM _AM_PROPERTY_SPPAL} + AM_PROPERTY_SPPAL = _AM_PROPERTY_SPPAL; + {$EXTERNALSYM AM_PROPERTY_SPPAL} + PAM_PROPERTY_SPPAL = ^AM_PROPERTY_SPPAL; + {$EXTERNALSYM PAM_PROPERTY_SPPAL} + TAMPropertySPPAL = _AM_PROPERTY_SPPAL; + + _AM_COLCON = record + emph1col : Byte; + emph2col : Byte; + backcol : Byte; + patcol : Byte; + emph1con : Byte; + emph2con : Byte; + backcon : Byte; + patcon : Byte; + end; + {$EXTERNALSYM _AM_COLCON} + AM_COLCON = _AM_COLCON; + {$EXTERNALSYM AM_COLCON} + PAM_COLCON = ^AM_COLCON; + {$EXTERNALSYM PAM_COLCON} + TAMColcon = _AM_COLCON; + + _AM_PROPERTY_SPHLI = record + HLISS : Word; // + Reserved : Word; + StartPTM : ULONG; // start presentation time in x/90000 + EndPTM : ULONG; // end PTM in x/90000 + StartX : Word; + StartY : Word; + StopX : Word; + StopY : Word; + ColCon : TAMColCon; // color contrast description (4 bytes as given in HLI) + end; + {$EXTERNALSYM _AM_PROPERTY_SPHLI} + AM_PROPERTY_SPHLI = _AM_PROPERTY_SPHLI; + {$EXTERNALSYM AM_PROPERTY_SPHLI} + TAMPropertySPHLI = _AM_PROPERTY_SPHLI; + + AM_PROPERTY_COMPOSIT_ON = {$IFDEF TYPE_IDENTITY}type {$ENDIF} BOOL; + {$EXTERNALSYM AM_PROPERTY_COMPOSIT_ON} + PAM_PROPERTY_COMPOSIT_ON = ^AM_PROPERTY_COMPOSIT_ON; + {$EXTERNALSYM PAM_PROPERTY_COMPOSIT_ON} + +// ----------------------------------------------------------------------- +// copy protection definitions +// ----------------------------------------------------------------------- + +// AM_UseNewCSSKey for the dwTypeSpecificFlags in IMediaSample2 to indicate +// the exact point in a stream after which to start applying a new CSS key. +// This is typically sent on an empty media sample just before attempting +// to renegotiate a CSS key. +const + AM_UseNewCSSKey = $1; + {$EXTERNALSYM AM_UseNewCSSKey} + +// +// AM_KSPROPSETID_CopyProt property set definitions +// + AM_PROPERTY_DVDCOPY_CHLG_KEY = $01; + {$EXTERNALSYM AM_PROPERTY_DVDCOPY_CHLG_KEY} + AM_PROPERTY_DVDCOPY_DVD_KEY1 = $02; + {$EXTERNALSYM AM_PROPERTY_DVDCOPY_DVD_KEY1} + AM_PROPERTY_DVDCOPY_DEC_KEY2 = $03; + {$EXTERNALSYM AM_PROPERTY_DVDCOPY_DEC_KEY2} + AM_PROPERTY_DVDCOPY_TITLE_KEY = $04; + {$EXTERNALSYM AM_PROPERTY_DVDCOPY_TITLE_KEY} + AM_PROPERTY_COPY_MACROVISION = $05; + {$EXTERNALSYM AM_PROPERTY_COPY_MACROVISION} + AM_PROPERTY_DVDCOPY_REGION = $06; + {$EXTERNALSYM AM_PROPERTY_DVDCOPY_REGION} + AM_PROPERTY_DVDCOPY_SET_COPY_STATE = $07; + {$EXTERNALSYM AM_PROPERTY_DVDCOPY_SET_COPY_STATE} + AM_PROPERTY_DVDCOPY_DISC_KEY = $80; + {$EXTERNALSYM AM_PROPERTY_DVDCOPY_DISC_KEY} + +type + _AM_DVDCOPY_CHLGKEY = record + ChlgKey: array[0..9] of Byte; + Reserved: array[0..1] of Byte; + end; + {$EXTERNALSYM _AM_DVDCOPY_CHLGKEY} + AM_DVDCOPY_CHLGKEY = _AM_DVDCOPY_CHLGKEY; + {$EXTERNALSYM AM_DVDCOPY_CHLGKEY} + PAM_DVDCOPY_CHLGKEY = ^AM_DVDCOPY_CHLGKEY; + {$EXTERNALSYM PAM_DVDCOPY_CHLGKEY} + TAMDVDCopyCHLGKey = _AM_DVDCOPY_CHLGKEY; + + _AM_DVDCOPY_BUSKEY = record + BusKey: array[0..4] of Byte; + Reserved: array[0..0] of Byte; + end; + {$EXTERNALSYM _AM_DVDCOPY_BUSKEY} + AM_DVDCOPY_BUSKEY = _AM_DVDCOPY_BUSKEY; + {$EXTERNALSYM AM_DVDCOPY_BUSKEY} + PAM_DVDCOPY_BUSKEY = ^AM_DVDCOPY_BUSKEY; + {$EXTERNALSYM PAM_DVDCOPY_BUSKEY} + TAMDVDCopyBusKey = _AM_DVDCOPY_BUSKEY; + + _AM_DVDCOPY_DISCKEY = record + DiscKey: array[0..2047] of Byte; + end; + {$EXTERNALSYM _AM_DVDCOPY_DISCKEY} + AM_DVDCOPY_DISCKEY = _AM_DVDCOPY_DISCKEY; + {$EXTERNALSYM AM_DVDCOPY_DISCKEY} + PAM_DVDCOPY_DISCKEY = ^AM_DVDCOPY_DISCKEY; + {$EXTERNALSYM PAM_DVDCOPY_DISCKEY} + TAMDVDCopyDiscKey = _AM_DVDCOPY_DISCKEY; + + AM_DVDCOPY_TITLEKEY = record + KeyFlags: ULONG; + Reserved1: array[0..1] of ULONG; + TitleKey: array[0..5] of Byte; + Reserved2: array[0..1] of Byte; + end; + {$EXTERNALSYM AM_DVDCOPY_TITLEKEY} + PAM_DVDCOPY_TITLEKEY = AM_DVDCOPY_TITLEKEY; + {$EXTERNALSYM PAM_DVDCOPY_TITLEKEY} + TAMDVDCopyTitleKey = AM_DVDCOPY_TITLEKEY; + + _AM_COPY_MACROVISION = record + MACROVISIONLevel: ULONG; + end; + {$EXTERNALSYM _AM_COPY_MACROVISION} + AM_COPY_MACROVISION = _AM_COPY_MACROVISION; + {$EXTERNALSYM AM_COPY_MACROVISION} + PAM_COPY_MACROVISION = ^AM_COPY_MACROVISION; + {$EXTERNALSYM PAM_COPY_MACROVISION} + TAMCopyMacroVision = _AM_COPY_MACROVISION; + + AM_DVDCOPY_SET_COPY_STATE = record + DVDCopyState: ULONG; + end; + {$EXTERNALSYM AM_DVDCOPY_SET_COPY_STATE} + PAM_DVDCOPY_SET_COPY_STATE = ^AM_DVDCOPY_SET_COPY_STATE; + {$EXTERNALSYM PAM_DVDCOPY_SET_COPY_STATE} + TAMDVDCopySetCopyState = AM_DVDCOPY_SET_COPY_STATE; + + AM_DVDCOPYSTATE = ( + AM_DVDCOPYSTATE_INITIALIZE, + AM_DVDCOPYSTATE_INITIALIZE_TITLE, // indicates we are starting a title + // key copy protection sequence + AM_DVDCOPYSTATE_AUTHENTICATION_NOT_REQUIRED, + AM_DVDCOPYSTATE_AUTHENTICATION_REQUIRED, + AM_DVDCOPYSTATE_DONE + ); + {$EXTERNALSYM AM_DVDCOPYSTATE} + TAMDVDCopyState = AM_DVDCOPYSTATE; + + AM_COPY_MACROVISION_LEVEL = ( + AM_MACROVISION_DISABLED, + AM_MACROVISION_LEVEL1, + AM_MACROVISION_LEVEL2, + AM_MACROVISION_LEVEL3 + ); + {$EXTERNALSYM AM_COPY_MACROVISION_LEVEL} + PAM_COPY_MACROVISION_LEVEL = ^AM_COPY_MACROVISION_LEVEL; + {$EXTERNALSYM PAM_COPY_MACROVISION_LEVEL} + TAMCopyMacroVisionLevel = AM_COPY_MACROVISION_LEVEL; + + // CSS region stucture + _DVD_REGION = record + CopySystem: Byte; + RegionData: Byte; + SystemRegion: Byte; + Reserved: Byte; + end; + {$EXTERNALSYM _DVD_REGION} + DVD_REGION = _DVD_REGION; + {$EXTERNALSYM DVD_REGION} + PDVD_REGION = ^DVD_REGION; + {$EXTERNALSYM PDVD_REGION} + TDVDRegion = _DVD_REGION; + +// +// CGMS Copy Protection Flags +// + +const + AM_DVD_CGMS_RESERVED_MASK = $00000078; + {$EXTERNALSYM AM_DVD_CGMS_RESERVED_MASK} + + AM_DVD_CGMS_COPY_PROTECT_MASK = $00000018; + {$EXTERNALSYM AM_DVD_CGMS_COPY_PROTECT_MASK} + AM_DVD_CGMS_COPY_PERMITTED = $00000000; + {$EXTERNALSYM AM_DVD_CGMS_COPY_PERMITTED} + AM_DVD_CGMS_COPY_ONCE = $00000010; + {$EXTERNALSYM AM_DVD_CGMS_COPY_ONCE} + AM_DVD_CGMS_NO_COPY = $00000018; + {$EXTERNALSYM AM_DVD_CGMS_NO_COPY} + + AM_DVD_COPYRIGHT_MASK = $00000040; + {$EXTERNALSYM AM_DVD_COPYRIGHT_MASK} + AM_DVD_NOT_COPYRIGHTED = $00000000; + {$EXTERNALSYM AM_DVD_NOT_COPYRIGHTED} + AM_DVD_COPYRIGHTED = $00000040; + {$EXTERNALSYM AM_DVD_COPYRIGHTED} + + AM_DVD_SECTOR_PROTECT_MASK = $00000020; + {$EXTERNALSYM AM_DVD_SECTOR_PROTECT_MASK} + AM_DVD_SECTOR_NOT_PROTECTED = $00000000; + {$EXTERNALSYM AM_DVD_SECTOR_NOT_PROTECTED} + AM_DVD_SECTOR_PROTECTED = $00000020; + {$EXTERNALSYM AM_DVD_SECTOR_PROTECTED} + + +// ----------------------------------------------------------------------- +// video format blocks +// ----------------------------------------------------------------------- + +type + AM_MPEG2Level = ( + {$IFNDEF COMPILER6_UP} + AM_MPEG2Level_INVALID_0, + AM_MPEG2Level_Low, + AM_MPEG2Level_Main, + AM_MPEG2Level_High1440, + AM_MPEG2Level_High + {$ELSE} + AM_MPEG2Level_Low = 1, + AM_MPEG2Level_Main = 2, + AM_MPEG2Level_High1440 = 3, + AM_MPEG2Level_High = 4 + {$ENDIF} + ); + {$EXTERNALSYM AM_MPEG2Level} + TAMMPEG2Level = AM_MPEG2Level; + + AM_MPEG2Profile = ( + {$IFNDEF COMPILER6_UP} + AM_MPEG2Profile_0, + AM_MPEG2Profile_Simple, + AM_MPEG2Profile_Main, + AM_MPEG2Profile_SNRScalable, + AM_MPEG2Profile_SpatiallyScalable, + AM_MPEG2Profile_High + {$ELSE} + AM_MPEG2Profile_Simple = 1, + AM_MPEG2Profile_Main = 2, + AM_MPEG2Profile_SNRScalable = 3, + AM_MPEG2Profile_SpatiallyScalable = 4, + AM_MPEG2Profile_High = 5 + {$ENDIF} + ); + {$EXTERNALSYM AM_MPEG2Profile} + TAMMPEG2Profile = AM_MPEG2Profile; + +const + AMINTERLACE_IsInterlaced = $00000001; // if 0, other interlace bits are irrelevent + {$EXTERNALSYM AMINTERLACE_IsInterlaced} + AMINTERLACE_1FieldPerSample = $00000002; // else 2 fields per media sample + {$EXTERNALSYM AMINTERLACE_1FieldPerSample} + AMINTERLACE_Field1First = $00000004; // else Field 2 is first; top field in PAL is field 1, top field in NTSC is field 2? + {$EXTERNALSYM AMINTERLACE_Field1First} + AMINTERLACE_UNUSED = $00000008; // + {$EXTERNALSYM AMINTERLACE_UNUSED} + AMINTERLACE_FieldPatternMask = $00000030; // use this mask with AMINTERLACE_FieldPat* + {$EXTERNALSYM AMINTERLACE_FieldPatternMask} + AMINTERLACE_FieldPatField1Only = $00000000; // stream never contains a Field2 + {$EXTERNALSYM AMINTERLACE_FieldPatField1Only} + AMINTERLACE_FieldPatField2Only = $00000010; // stream never contains a Field1 + {$EXTERNALSYM AMINTERLACE_FieldPatField2Only} + AMINTERLACE_FieldPatBothRegular = $00000020; // There will be a Field2 for every Field1 (required for Weave?) + {$EXTERNALSYM AMINTERLACE_FieldPatBothRegular} + AMINTERLACE_FieldPatBothIrregular = $00000030; // Random pattern of Field1s and Field2s + {$EXTERNALSYM AMINTERLACE_FieldPatBothIrregular} + AMINTERLACE_DisplayModeMask = $000000c0; + {$EXTERNALSYM AMINTERLACE_DisplayModeMask} + AMINTERLACE_DisplayModeBobOnly = $00000000; + {$EXTERNALSYM AMINTERLACE_DisplayModeBobOnly} + AMINTERLACE_DisplayModeWeaveOnly = $00000040; + {$EXTERNALSYM AMINTERLACE_DisplayModeWeaveOnly} + AMINTERLACE_DisplayModeBobOrWeave = $00000080; + {$EXTERNALSYM AMINTERLACE_DisplayModeBobOrWeave} + + AMCOPYPROTECT_RestrictDuplication = $00000001; // duplication of this stream should be restricted + {$EXTERNALSYM AMCOPYPROTECT_RestrictDuplication} + + AMMPEG2_DoPanScan = $00000001; //if set, the MPEG-2 video decoder should crop output image + {$EXTERNALSYM AMMPEG2_DoPanScan} // based on pan-scan vectors in picture_display_extension + // and change the picture aspect ratio accordingly. + AMMPEG2_DVDLine21Field1 = $00000002; //if set, the MPEG-2 decoder must be able to produce an output + {$EXTERNALSYM AMMPEG2_DVDLine21Field1} // pin for DVD style closed caption data found in GOP layer of field 1 + AMMPEG2_DVDLine21Field2 = $00000004; //if set, the MPEG-2 decoder must be able to produce an output + {$EXTERNALSYM AMMPEG2_DVDLine21Field2} // pin for DVD style closed caption data found in GOP layer of field 2 + AMMPEG2_SourceIsLetterboxed = $00000008; //if set, indicates that black bars have been encoded in the top + {$EXTERNALSYM AMMPEG2_SourceIsLetterboxed} // and bottom of the video. + AMMPEG2_FilmCameraMode = $00000010; //if set, indicates "film mode" used for 625/50 content. If cleared, + {$EXTERNALSYM AMMPEG2_FilmCameraMode} // indicates that "camera mode" was used. + AMMPEG2_LetterboxAnalogOut = $00000020; //if set and this stream is sent to an analog output, it should + {$EXTERNALSYM AMMPEG2_LetterboxAnalogOut} // be letterboxed. Streams sent to VGA should be letterboxed only by renderers. + AMMPEG2_DSS_UserData = $00000040; //if set, the MPEG-2 decoder must process DSS style user data + {$EXTERNALSYM AMMPEG2_DSS_UserData} + AMMPEG2_DVB_UserData = $00000080; //if set, the MPEG-2 decoder must process DVB style user data + {$EXTERNALSYM AMMPEG2_DVB_UserData} + AMMPEG2_27MhzTimebase = $00000100; //if set, the PTS,DTS timestamps advance at 27MHz rather than 90KHz + {$EXTERNALSYM AMMPEG2_27MhzTimebase} + + AMMPEG2_WidescreenAnalogOut = $00000200; //if set and this stream is sent to an analog output, it should + {$EXTERNALSYM AMMPEG2_WidescreenAnalogOut} + // be in widescreen format (4x3 content should be centered on a 16x9 output). + // Streams sent to VGA should be widescreened only by renderers. + +// PRESENT in dwReserved1 field in VIDEOINFOHEADER2 + AMCONTROL_USED = $00000001; // Used to test if these flags are supported. Set and test for AcceptMediaType. + {$EXTERNALSYM AMCONTROL_USED} // If rejected, then you cannot use the AMCONTROL flags (send 0 for dwReserved1) + AMCONTROL_PAD_TO_4x3 = $00000002; // if set means display the image in a 4x3 area + {$EXTERNALSYM AMCONTROL_PAD_TO_4x3} + AMCONTROL_PAD_TO_16x9 = $00000004; // if set means display the image in a 16x9 area + {$EXTERNALSYM AMCONTROL_PAD_TO_16x9} + +type + TVideoInfoHeader2ControlFlags = record + case byte of + 0: (dwControlFlags : DWORD); // use AMCONTROL_* defines, use this from now on + 1: (dwReserved1 : DWORD); // for backward compatiblity (was "must be 0"; connection rejected otherwise) + end; + {$EXTERNALSYM TVideoInfoHeader2ControlFlags} + + PVideoInfoHeader2 = ^TVideoInfoHeader2; + tagVIDEOINFOHEADER2 = record + rcSource: TRect; + rcTarget: TRect; + dwBitRate: DWORD; + dwBitErrorRate: DWORD; + AvgTimePerFrame: TReferenceTime; + dwInterlaceFlags: DWORD; // use AMINTERLACE_* defines. Reject connection if undefined bits are not 0 + dwCopyProtectFlags: DWORD; // use AMCOPYPROTECT_* defines. Reject connection if undefined bits are not 0 + dwPictAspectRatioX: DWORD; // X dimension of picture aspect ratio, e.g. 16 for 16x9 display + dwPictAspectRatioY: DWORD; // Y dimension of picture aspect ratio, e.g. 9 for 16x9 display + ControlFlags: TVideoInfoHeader2ControlFlags; + dwReserved2: DWORD; // must be 0; reject connection otherwise + bmiHeader: TBitmapInfoHeader; + end; + {$EXTERNALSYM tagVIDEOINFOHEADER2} + VIDEOINFOHEADER2 = tagVIDEOINFOHEADER2; + {$EXTERNALSYM VIDEOINFOHEADER2} + TVideoInfoHeader2 = tagVIDEOINFOHEADER2; + + PMPEG2VideoInfo = ^TMPEG2VideoInfo; + tagMPEG2VIDEOINFO = record + hdr: TVIDEOINFOHEADER2; + dwStartTimeCode: DWORD; // ?? not used for DVD ?? + cbSequenceHeader: DWORD; // is 0 for DVD (no sequence header) + dwProfile: DWORD; // use enum MPEG2Profile + dwLevel: DWORD; // use enum MPEG2Level + dwFlags: DWORD; // use AMMPEG2_* defines. Reject connection if undefined bits are not 0 + dwSequenceHeader: array[0..0] of DWORD; // DWORD instead of Byte for alignment purposes + // For MPEG-2, if a sequence_header is included, the sequence_extension + // should also be included + end; + {$EXTERNALSYM tagMPEG2VIDEOINFO} + MPEG2VIDEOINFO = tagMPEG2VIDEOINFO; + {$EXTERNALSYM MPEG2VIDEOINFO} + TMPEG2VideoInfo = tagMPEG2VIDEOINFO; +{ +#define SIZE_MPEG2VIDEOINFO(pv) (FIELD_OFFSET(MPEG2VIDEOINFO, bSequenceHeader[0]) + (pv)->cbSequenceHeader) +#define MPEG1_SEQUENCE_INFO(pv) ((const BYTE *)(pv)->bSequenceHeader) +// use this macro instead, the previous only works for MPEG1VIDEOINFO structures +#define MPEG2_SEQUENCE_INFO(pv) ((const BYTE *)(pv)->dwSequenceHeader) + } + +//=================================================================================== +// flags for dwTypeSpecificFlags in AM_SAMPLE2_PROPERTIES which define type specific +// data in IMediaSample2 +//=================================================================================== + +const + AM_VIDEO_FLAG_FIELD_MASK = $0003; // use this mask to check whether the sample is field1 or field2 or frame + {$EXTERNALSYM AM_VIDEO_FLAG_FIELD_MASK} + AM_VIDEO_FLAG_INTERLEAVED_FRAME = $0000; // the sample is a frame (remember to use AM_VIDEO_FLAG_FIELD_MASK when using this) + {$EXTERNALSYM AM_VIDEO_FLAG_INTERLEAVED_FRAME} + AM_VIDEO_FLAG_FIELD1 = $0001; // the sample is field1 (remember to use AM_VIDEO_FLAG_FIELD_MASK when using this) + {$EXTERNALSYM AM_VIDEO_FLAG_FIELD1} + AM_VIDEO_FLAG_FIELD2 = $0002; // the sample is the field2 (remember to use AM_VIDEO_FLAG_FIELD_MASK when using this) + {$EXTERNALSYM AM_VIDEO_FLAG_FIELD2} + AM_VIDEO_FLAG_FIELD1FIRST = $0004; // if set means display field1 first, else display field2 first. + {$EXTERNALSYM AM_VIDEO_FLAG_FIELD1FIRST} + // this bit is irrelavant for 1FieldPerSample mode + AM_VIDEO_FLAG_WEAVE = $0008; // if set use bob display mode else weave + {$EXTERNALSYM AM_VIDEO_FLAG_WEAVE} + AM_VIDEO_FLAG_IPB_MASK = $0030; // use this mask to check whether the sample is I, P or B + {$EXTERNALSYM AM_VIDEO_FLAG_IPB_MASK} + AM_VIDEO_FLAG_I_SAMPLE = $0000; // I Sample (remember to use AM_VIDEO_FLAG_IPB_MASK when using this) + {$EXTERNALSYM AM_VIDEO_FLAG_I_SAMPLE} + AM_VIDEO_FLAG_P_SAMPLE = $0010; // P Sample (remember to use AM_VIDEO_FLAG_IPB_MASK when using this) + {$EXTERNALSYM AM_VIDEO_FLAG_P_SAMPLE} + AM_VIDEO_FLAG_B_SAMPLE = $0020; // B Sample (remember to use AM_VIDEO_FLAG_IPB_MASK when using this) + {$EXTERNALSYM AM_VIDEO_FLAG_B_SAMPLE} + AM_VIDEO_FLAG_REPEAT_FIELD = $0040; // if set means display the field which has been displayed first again after displaying + {$EXTERNALSYM AM_VIDEO_FLAG_REPEAT_FIELD} + // both fields first. This bit is irrelavant for 1FieldPerSample mode +// ----------------------------------------------------------------------- +// AM_KSPROPSETID_DvdKaraoke property set definitions +// ----------------------------------------------------------------------- +type + tagAM_DvdKaraokeData = record + dwDownmix : DWORD; // bitwise OR of AM_DvdKaraoke_Downmix flags + dwSpeakerAssignment : DWORD; // AM_DvdKaraoke_SpeakerAssignment + end; + {$EXTERNALSYM tagAM_DvdKaraokeData} + AM_DvdKaraokeData = tagAM_DvdKaraokeData; + {$EXTERNALSYM AM_DvdKaraokeData} + TAMDvdKaraokeData = tagAM_DvdKaraokeData; + + AM_PROPERTY_DVDKARAOKE = ( + AM_PROPERTY_DVDKARAOKE_ENABLE, // BOOL + AM_PROPERTY_DVDKARAOKE_DATA + ); + {$EXTERNALSYM AM_PROPERTY_DVDKARAOKE} + TAMPropertyDVDKaraoke = AM_PROPERTY_DVDKARAOKE; + +// ----------------------------------------------------------------------- +// AM_KSPROPSETID_TSRateChange property set definitions for time stamp +// rate changes. +// ----------------------------------------------------------------------- +type + AM_PROPERTY_TS_RATE_CHANGE = ( + {$IFNDEF COMPILER6_UP} + AM_RATE_INVALID_0, + AM_RATE_SimpleRateChange, // rw, use AM_SimpleRateChange + AM_RATE_ExactRateChange, // rw, use AM_ExactRateChange + AM_RATE_MaxFullDataRate, // r, use AM_MaxFullDataRate + AM_RATE_Step, // w, use AM_Step + AM_RATE_UseRateVersion, // w, use WORD + AM_RATE_QueryFullFrameRate, // r, use AM_QueryRate + AM_RATE_QueryLastRateSegPTS, // r, use REFERENCE_TIME + AM_RATE_CorrectTS // w, use LONG + {$ELSE} + AM_RATE_SimpleRateChange = 1, // rw, use AM_SimpleRateChange + AM_RATE_ExactRateChange = 2, // rw, use AM_ExactRateChange + AM_RATE_MaxFullDataRate = 3, // r, use AM_MaxFullDataRate + AM_RATE_Step = 4, // w, use AM_Step + AM_RATE_UseRateVersion = 5, // w, use WORD + AM_RATE_QueryFullFrameRate = 6, // r, use AM_QueryRate + AM_RATE_QueryLastRateSegPTS = 7, // r, use REFERENCE_TIME + AM_RATE_CorrectTS = 8 // w, use LONG + {$ENDIF} + ); + {$EXTERNALSYM AM_PROPERTY_TS_RATE_CHANGE} + TAMPropertyTSRateChange = AM_PROPERTY_TS_RATE_CHANGE; + +// ------------------------------------------------------------------- +// AM_KSPROPSETID_DVD_RateChange property set definitions for new DVD +// rate change scheme. +// ------------------------------------------------------------------- + + AM_PROPERTY_DVD_RATE_CHANGE = ( + {$IFNDEF COMPILER6_UP} + AM_RATE_INVALID__0, + AM_RATE_ChangeRate, // w, use AM_DVD_ChangeRate + AM_RATE_FullDataRateMax, // r, use AM_MaxFullDataRate + AM_RATE_ReverseDecode, // r, use LONG + AM_RATE_DecoderPosition, // r, use AM_DVD_DecoderPosition + AM_RATE_DecoderVersion // r, use LONG + {$ELSE} + AM_RATE_ChangeRate = 1, // w, use AM_DVD_ChangeRate + AM_RATE_FullDataRateMax = 2, // r, use AM_MaxFullDataRate + AM_RATE_ReverseDecode = 3, // r, use LONG + AM_RATE_DecoderPosition = 4, // r, use AM_DVD_DecoderPosition + AM_RATE_DecoderVersion = 5 // r, use LONG + {$ENDIF} + ); + {$EXTERNALSYM AM_PROPERTY_DVD_RATE_CHANGE} + TAMPropertyDVDRateChange = AM_PROPERTY_DVD_RATE_CHANGE; + + AM_SimpleRateChange = record + // this is the simplest mechinism to set a time stamp rate change on + // a filter (simplest for the person setting the rate change, harder + // for the filter doing the rate change). + StartTime: TReferenceTime; //stream time at which to start this rate + Rate: Longint; //new rate * 10000 (decimal) + end; + {$EXTERNALSYM AM_SimpleRateChange} + TAMSimpleRateChange = AM_SimpleRateChange; + + AM_QueryRate = record + lMaxForwardFullFrame: LongInt; // rate * 10000 + lMaxReverseFullFrame: LongInt; // rate * 10000 + end; + {$EXTERNALSYM AM_QueryRate} + TAMQueryRate = AM_QueryRate; + + AM_ExactRateChange = record + OutputZeroTime: TReferenceTime; //input TS that maps to zero output TS + Rate: Longint; //new rate * 10000 (decimal) + end; + {$EXTERNALSYM AM_ExactRateChange} + TAMExactRateChange = AM_ExactRateChange; + + AM_MaxFullDateRate = {$IFDEF TYPE_IDENTITY}type {$ENDIF} Longint; //rate * 10000 (decimal) + {$EXTERNALSYM AM_MaxFullDateRate} + + AM_Step = {$IFDEF TYPE_IDENTITY}type {$ENDIF} DWORD; // number of frame to step + {$EXTERNALSYM AM_Step} + + // New rate change property set, structs. enums etc. + AM_DVD_ChangeRate = record + StartInTime : TReferenceTime; // stream time (input) at which to start decoding at this rate + StartOutTime : TReferenceTime; // reference time (output) at which to start showing at this rate + Rate : Longint; // new rate * 10000 (decimal) + end; + {$EXTERNALSYM AM_DVD_ChangeRate} + TAMDVDChangeRate = AM_DVD_ChangeRate; + + AM_DVD_DecoderPosition = {$IFDEF TYPE_IDENTITY}type {$ENDIF} int64 ; + {$EXTERNALSYM AM_DVD_DecoderPosition} + + DVD_PLAY_DIRECTION = ( + DVD_DIR_FORWARD, + DVD_DIR_BACKWARD + ); + {$EXTERNALSYM DVD_PLAY_DIRECTION} + TDVDPlayDirection = DVD_PLAY_DIRECTION; + +(*==========================================================================; + * + * Copyright (C) 1996-1997 Microsoft Corporation. All Rights Reserved. + * + * File: activecf.h + * + ***************************************************************************) + +const + CFSTR_VFW_FILTERLIST = 'Video for Windows 4 Filters'; + {$EXTERNALSYM CFSTR_VFW_FILTERLIST} + +type + tagVFW_FILTERLIST = record + cFilters: UINT; // number of CLSIDs in aClsId + aClsId: array[0..0] of TGUID; // ClsId of each filter + end; + {$EXTERNALSYM tagVFW_FILTERLIST} + VFW_FILTERLIST = tagVFW_FILTERLIST; + {$EXTERNALSYM VFW_FILTERLIST} + TVFWFilterList = tagVFW_FILTERLIST; + +(*==========================================================================; + * + * Copyright (C) 1996-1997 Microsoft Corporation. All Rights Reserved. + * + * File: vfwmsgs.h + * + ***************************************************************************) + +const +// +// Define the severity codes +// + + VFW_E_INVALIDMEDIATYPE = HResult($80040200); + {$EXTERNALSYM VFW_E_INVALIDMEDIATYPE} + VFW_E_INVALIDSUBTYPE = HResult($80040201); + {$EXTERNALSYM VFW_E_INVALIDSUBTYPE} + VFW_E_NEED_OWNER = HResult($80040202); + {$EXTERNALSYM VFW_E_NEED_OWNER} + VFW_E_ENUM_OUT_OF_SYNC = HResult($80040203); + {$EXTERNALSYM VFW_E_ENUM_OUT_OF_SYNC} + VFW_E_ALREADY_CONNECTED = HResult($80040204); + {$EXTERNALSYM VFW_E_ALREADY_CONNECTED} + VFW_E_FILTER_ACTIVE = HResult($80040205); + {$EXTERNALSYM VFW_E_FILTER_ACTIVE} + VFW_E_NO_TYPES = HResult($80040206); + {$EXTERNALSYM VFW_E_NO_TYPES} + VFW_E_NO_ACCEPTABLE_TYPES = HResult($80040207); + {$EXTERNALSYM VFW_E_NO_ACCEPTABLE_TYPES} + VFW_E_INVALID_DIRECTION = HResult($80040208); + {$EXTERNALSYM VFW_E_INVALID_DIRECTION} + VFW_E_NOT_CONNECTED = HResult($80040209); + {$EXTERNALSYM VFW_E_NOT_CONNECTED} + VFW_E_NO_ALLOCATOR = HResult($8004020A); + {$EXTERNALSYM VFW_E_NO_ALLOCATOR} + VFW_E_RUNTIME_ERROR = HResult($8004020B); + {$EXTERNALSYM VFW_E_RUNTIME_ERROR} + VFW_E_BUFFER_NOTSET = HResult($8004020C); + {$EXTERNALSYM VFW_E_BUFFER_NOTSET} + VFW_E_BUFFER_OVERFLOW = HResult($8004020D); + {$EXTERNALSYM VFW_E_BUFFER_OVERFLOW} + VFW_E_BADALIGN = HResult($8004020E); + {$EXTERNALSYM VFW_E_BADALIGN} + VFW_E_ALREADY_COMMITTED = HResult($8004020F); + {$EXTERNALSYM VFW_E_ALREADY_COMMITTED} + VFW_E_BUFFERS_OUTSTANDING = HResult($80040210); + {$EXTERNALSYM VFW_E_BUFFERS_OUTSTANDING} + VFW_E_NOT_COMMITTED = HResult($80040211); + {$EXTERNALSYM VFW_E_NOT_COMMITTED} + VFW_E_SIZENOTSET = HResult($80040212); + {$EXTERNALSYM VFW_E_SIZENOTSET} + VFW_E_NO_CLOCK = HResult($80040213); + {$EXTERNALSYM VFW_E_NO_CLOCK} + VFW_E_NO_SINK = HResult($80040214); + {$EXTERNALSYM VFW_E_NO_SINK} + VFW_E_NO_INTERFACE = HResult($80040215); + {$EXTERNALSYM VFW_E_NO_INTERFACE} + VFW_E_NOT_FOUND = HResult($80040216); + {$EXTERNALSYM VFW_E_NOT_FOUND} + VFW_E_CANNOT_CONNECT = HResult($80040217); + {$EXTERNALSYM VFW_E_CANNOT_CONNECT} + VFW_E_CANNOT_RENDER = HResult($80040218); + {$EXTERNALSYM VFW_E_CANNOT_RENDER} + VFW_E_CHANGING_FORMAT = HResult($80040219); + {$EXTERNALSYM VFW_E_CHANGING_FORMAT} + VFW_E_NO_COLOR_KEY_SET = HResult($8004021A); + {$EXTERNALSYM VFW_E_NO_COLOR_KEY_SET} + VFW_E_NOT_OVERLAY_CONNECTION = HResult($8004021B); + {$EXTERNALSYM VFW_E_NOT_OVERLAY_CONNECTION} + VFW_E_NOT_SAMPLE_CONNECTION = HResult($8004021C); + {$EXTERNALSYM VFW_E_NOT_SAMPLE_CONNECTION} + VFW_E_PALETTE_SET = HResult($8004021D); + {$EXTERNALSYM VFW_E_PALETTE_SET} + VFW_E_COLOR_KEY_SET = HResult($8004021E); + {$EXTERNALSYM VFW_E_COLOR_KEY_SET} + VFW_E_NO_COLOR_KEY_FOUND = HResult($8004021F); + {$EXTERNALSYM VFW_E_NO_COLOR_KEY_FOUND} + VFW_E_NO_PALETTE_AVAILABLE = HResult($80040220); + {$EXTERNALSYM VFW_E_NO_PALETTE_AVAILABLE} + VFW_E_NO_DISPLAY_PALETTE = HResult($80040221); + {$EXTERNALSYM VFW_E_NO_DISPLAY_PALETTE} + VFW_E_TOO_MANY_COLORS = HResult($80040222); + {$EXTERNALSYM VFW_E_TOO_MANY_COLORS} + VFW_E_STATE_CHANGED = HResult($80040223); + {$EXTERNALSYM VFW_E_STATE_CHANGED} + VFW_E_NOT_STOPPED = HResult($80040224); + {$EXTERNALSYM VFW_E_NOT_STOPPED} + VFW_E_NOT_PAUSED = HResult($80040225); + {$EXTERNALSYM VFW_E_NOT_PAUSED} + VFW_E_NOT_RUNNING = HResult($80040226); + {$EXTERNALSYM VFW_E_NOT_RUNNING} + VFW_E_WRONG_STATE = HResult($80040227); + {$EXTERNALSYM VFW_E_WRONG_STATE} + VFW_E_START_TIME_AFTER_END = HResult($80040228); + {$EXTERNALSYM VFW_E_START_TIME_AFTER_END} + VFW_E_INVALID_RECT = HResult($80040229); + {$EXTERNALSYM VFW_E_INVALID_RECT} + VFW_E_TYPE_NOT_ACCEPTED = HResult($8004022A); + {$EXTERNALSYM VFW_E_TYPE_NOT_ACCEPTED} + VFW_E_SAMPLE_REJECTED = HResult($8004022B); + {$EXTERNALSYM VFW_E_SAMPLE_REJECTED} + VFW_E_SAMPLE_REJECTED_EOS = HResult($8004022C); + {$EXTERNALSYM VFW_E_SAMPLE_REJECTED_EOS} + VFW_E_DUPLICATE_NAME = HResult($8004022D); + {$EXTERNALSYM VFW_E_DUPLICATE_NAME} + VFW_S_DUPLICATE_NAME = HResult($0004022D); + {$EXTERNALSYM VFW_S_DUPLICATE_NAME} + VFW_E_TIMEOUT = HResult($8004022E); + {$EXTERNALSYM VFW_E_TIMEOUT} + VFW_E_INVALID_FILE_FORMAT = HResult($8004022F); + {$EXTERNALSYM VFW_E_INVALID_FILE_FORMAT} + VFW_E_ENUM_OUT_OF_RANGE = HResult($80040230); + {$EXTERNALSYM VFW_E_ENUM_OUT_OF_RANGE} + VFW_E_CIRCULAR_GRAPH = HResult($80040231); + {$EXTERNALSYM VFW_E_CIRCULAR_GRAPH} + VFW_E_NOT_ALLOWED_TO_SAVE = HResult($80040232); + {$EXTERNALSYM VFW_E_NOT_ALLOWED_TO_SAVE} + VFW_E_TIME_ALREADY_PASSED = HResult($80040233); + {$EXTERNALSYM VFW_E_TIME_ALREADY_PASSED} + VFW_E_ALREADY_CANCELLED = HResult($80040234); + {$EXTERNALSYM VFW_E_ALREADY_CANCELLED} + VFW_E_CORRUPT_GRAPH_FILE = HResult($80040235); + {$EXTERNALSYM VFW_E_CORRUPT_GRAPH_FILE} + VFW_E_ADVISE_ALREADY_SET = HResult($80040236); + {$EXTERNALSYM VFW_E_ADVISE_ALREADY_SET} + VFW_S_STATE_INTERMEDIATE = HResult($00040237); + {$EXTERNALSYM VFW_S_STATE_INTERMEDIATE} + VFW_E_NO_MODEX_AVAILABLE = HResult($80040238); + {$EXTERNALSYM VFW_E_NO_MODEX_AVAILABLE} + VFW_E_NO_ADVISE_SET = HResult($80040239); + {$EXTERNALSYM VFW_E_NO_ADVISE_SET} + VFW_E_NO_FULLSCREEN = HResult($8004023B); + {$EXTERNALSYM VFW_E_NO_FULLSCREEN} + VFW_E_UNKNOWN_FILE_TYPE = HResult($80040240); + {$EXTERNALSYM VFW_E_UNKNOWN_FILE_TYPE} + VFW_E_CANNOT_LOAD_SOURCE_FILTER = HResult($80040241); + {$EXTERNALSYM VFW_E_CANNOT_LOAD_SOURCE_FILTER} + VFW_S_PARTIAL_RENDER = HResult($00040242); + {$EXTERNALSYM VFW_S_PARTIAL_RENDER} + VFW_E_FILE_TOO_SHORT = HResult($80040243); + {$EXTERNALSYM VFW_E_FILE_TOO_SHORT} + VFW_E_INVALID_FILE_VERSION = HResult($80040244); + {$EXTERNALSYM VFW_E_INVALID_FILE_VERSION} + VFW_S_SOME_DATA_IGNORED = HResult($00040245); + {$EXTERNALSYM VFW_S_SOME_DATA_IGNORED} + VFW_S_CONNECTIONS_DEFERRED = HResult($00040246); + {$EXTERNALSYM VFW_S_CONNECTIONS_DEFERRED} + VFW_E_INVALID_CLSID = HResult($80040247); + {$EXTERNALSYM VFW_E_INVALID_CLSID} + VFW_E_INVALID_MEDIA_TYPE = HResult($80040248); + {$EXTERNALSYM VFW_E_INVALID_MEDIA_TYPE} + VFW_E_BAD_KEY = HResult($800403F2); + {$EXTERNALSYM VFW_E_BAD_KEY} + VFW_S_NO_MORE_ITEMS = HResult($00040103); + {$EXTERNALSYM VFW_S_NO_MORE_ITEMS} + VFW_E_SAMPLE_TIME_NOT_SET = HResult($80040249); + {$EXTERNALSYM VFW_E_SAMPLE_TIME_NOT_SET} + VFW_S_RESOURCE_NOT_NEEDED = HResult($00040250); + {$EXTERNALSYM VFW_S_RESOURCE_NOT_NEEDED} + VFW_E_MEDIA_TIME_NOT_SET = HResult($80040251); + {$EXTERNALSYM VFW_E_MEDIA_TIME_NOT_SET} + VFW_E_NO_TIME_FORMAT_SET = HResult($80040252); + {$EXTERNALSYM VFW_E_NO_TIME_FORMAT_SET} + VFW_E_MONO_AUDIO_HW = HResult($80040253); + {$EXTERNALSYM VFW_E_MONO_AUDIO_HW} + VFW_S_MEDIA_TYPE_IGNORED = HResult($00040254); + {$EXTERNALSYM VFW_S_MEDIA_TYPE_IGNORED} + VFW_E_NO_AUDIO_HARDWARE = HResult($80040256); + {$EXTERNALSYM VFW_E_NO_AUDIO_HARDWARE} + VFW_S_VIDEO_NOT_RENDERED = HResult($00040257); + {$EXTERNALSYM VFW_S_VIDEO_NOT_RENDERED} + VFW_S_AUDIO_NOT_RENDERED = HResult($00040258); + {$EXTERNALSYM VFW_S_AUDIO_NOT_RENDERED} + VFW_E_RPZA = HResult($80040259); + {$EXTERNALSYM VFW_E_RPZA} + VFW_S_RPZA = HResult($0004025A); + {$EXTERNALSYM VFW_S_RPZA} + VFW_E_PROCESSOR_NOT_SUITABLE = HResult($8004025B); + {$EXTERNALSYM VFW_E_PROCESSOR_NOT_SUITABLE} + VFW_E_UNSUPPORTED_AUDIO = HResult($8004025C); + {$EXTERNALSYM VFW_E_UNSUPPORTED_AUDIO} + VFW_E_UNSUPPORTED_VIDEO = HResult($8004025D); + {$EXTERNALSYM VFW_E_UNSUPPORTED_VIDEO} + VFW_E_MPEG_NOT_CONSTRAINED = HResult($8004025E); + {$EXTERNALSYM VFW_E_MPEG_NOT_CONSTRAINED} + VFW_E_NOT_IN_GRAPH = HResult($8004025F); + {$EXTERNALSYM VFW_E_NOT_IN_GRAPH} + VFW_S_ESTIMATED = HResult($00040260); + {$EXTERNALSYM VFW_S_ESTIMATED} + VFW_E_NO_TIME_FORMAT = HResult($80040261); + {$EXTERNALSYM VFW_E_NO_TIME_FORMAT} + VFW_E_READ_ONLY = HResult($80040262); + {$EXTERNALSYM VFW_E_READ_ONLY} + VFW_S_RESERVED = HResult($00040263); + {$EXTERNALSYM VFW_S_RESERVED} + VFW_E_BUFFER_UNDERFLOW = HResult($80040264); + {$EXTERNALSYM VFW_E_BUFFER_UNDERFLOW} + VFW_E_UNSUPPORTED_STREAM = HResult($80040265); + {$EXTERNALSYM VFW_E_UNSUPPORTED_STREAM} + VFW_E_NO_TRANSPORT = HResult($80040266); + {$EXTERNALSYM VFW_E_NO_TRANSPORT} + VFW_S_STREAM_OFF = HResult($00040267); + {$EXTERNALSYM VFW_S_STREAM_OFF} + VFW_S_CANT_CUE = HResult($00040268); + {$EXTERNALSYM VFW_S_CANT_CUE} + VFW_E_BAD_VIDEOCD = HResult($80040269); + {$EXTERNALSYM VFW_E_BAD_VIDEOCD} + VFW_S_NO_STOP_TIME = HResult($00040270); + {$EXTERNALSYM VFW_S_NO_STOP_TIME} + VFW_E_OUT_OF_VIDEO_MEMORY = HResult($80040271); + {$EXTERNALSYM VFW_E_OUT_OF_VIDEO_MEMORY} + VFW_E_VP_NEGOTIATION_FAILED = HResult($80040272); + {$EXTERNALSYM VFW_E_VP_NEGOTIATION_FAILED} + VFW_E_DDRAW_CAPS_NOT_SUITABLE = HResult($80040273); + {$EXTERNALSYM VFW_E_DDRAW_CAPS_NOT_SUITABLE} + VFW_E_NO_VP_HARDWARE = HResult($80040274); + {$EXTERNALSYM VFW_E_NO_VP_HARDWARE} + VFW_E_NO_CAPTURE_HARDWARE = HResult($80040275); + {$EXTERNALSYM VFW_E_NO_CAPTURE_HARDWARE} + VFW_E_DVD_OPERATION_INHIBITED = HResult($80040276); + {$EXTERNALSYM VFW_E_DVD_OPERATION_INHIBITED} + VFW_E_DVD_INVALIDDOMAIN = HResult($80040277); + {$EXTERNALSYM VFW_E_DVD_INVALIDDOMAIN} + VFW_E_DVD_NO_BUTTON = Hresult($80040278); + {$EXTERNALSYM VFW_E_DVD_NO_BUTTON} + VFW_E_DVD_GRAPHNOTREADY = HResult($80040279); + {$EXTERNALSYM VFW_E_DVD_GRAPHNOTREADY} + VFW_E_DVD_RENDERFAIL = HResult($8004027A); + {$EXTERNALSYM VFW_E_DVD_RENDERFAIL} + VFW_E_DVD_DECNOTENOUGH = HResult($8004027B); + {$EXTERNALSYM VFW_E_DVD_DECNOTENOUGH} + VFW_E_DDRAW_VERSION_NOT_SUITABLE = HResult($8004027C); + {$EXTERNALSYM VFW_E_DDRAW_VERSION_NOT_SUITABLE} + VFW_E_COPYPROT_FAILED = HResult($8004027D); + {$EXTERNALSYM VFW_E_COPYPROT_FAILED} + VFW_S_NOPREVIEWPIN = HResult($0004027E); + {$EXTERNALSYM VFW_S_NOPREVIEWPIN} + VFW_E_TIME_EXPIRED = HResult($8004027F); + {$EXTERNALSYM VFW_E_TIME_EXPIRED} + VFW_S_DVD_NON_ONE_SEQUENTIAL = HResult($00040280); + {$EXTERNALSYM VFW_S_DVD_NON_ONE_SEQUENTIAL} + VFW_E_DVD_WRONG_SPEED = HResult($80040281); + {$EXTERNALSYM VFW_E_DVD_WRONG_SPEED} + VFW_E_DVD_MENU_DOES_NOT_EXIST = HResult($80040282); + {$EXTERNALSYM VFW_E_DVD_MENU_DOES_NOT_EXIST} + VFW_E_DVD_CMD_CANCELLED = HResult($80040283); + {$EXTERNALSYM VFW_E_DVD_CMD_CANCELLED} + VFW_E_DVD_STATE_WRONG_VERSION = HResult($80040284); + {$EXTERNALSYM VFW_E_DVD_STATE_WRONG_VERSION} + VFW_E_DVD_STATE_CORRUPT = HResult($80040285); + {$EXTERNALSYM VFW_E_DVD_STATE_CORRUPT} + VFW_E_DVD_STATE_WRONG_DISC = HResult($80040286); + {$EXTERNALSYM VFW_E_DVD_STATE_WRONG_DISC} + VFW_E_DVD_INCOMPATIBLE_REGION = HResult($80040287); + {$EXTERNALSYM VFW_E_DVD_INCOMPATIBLE_REGION} + VFW_E_DVD_NO_ATTRIBUTES = HResult($80040288); + {$EXTERNALSYM VFW_E_DVD_NO_ATTRIBUTES} + VFW_E_DVD_NO_GOUP_PGC = HResult($80040289); + {$EXTERNALSYM VFW_E_DVD_NO_GOUP_PGC} + VFW_E_DVD_LOW_PARENTAL_LEVEL = HResult($8004028A); + {$EXTERNALSYM VFW_E_DVD_LOW_PARENTAL_LEVEL} + VFW_E_DVD_NOT_IN_KARAOKE_MODE = HResult($8004028B); + {$EXTERNALSYM VFW_E_DVD_NOT_IN_KARAOKE_MODE} + VFW_S_DVD_CHANNEL_CONTENTS_NOT_AVAILABLE = HResult($0004028C); + {$EXTERNALSYM VFW_S_DVD_CHANNEL_CONTENTS_NOT_AVAILABLE} + VFW_S_DVD_NOT_ACCURATE = HResult($0004028D); + {$EXTERNALSYM VFW_S_DVD_NOT_ACCURATE} + VFW_E_FRAME_STEP_UNSUPPORTED = HResult($8004028E); + {$EXTERNALSYM VFW_E_FRAME_STEP_UNSUPPORTED} + VFW_E_DVD_STREAM_DISABLED = HResult($8004028F); + {$EXTERNALSYM VFW_E_DVD_STREAM_DISABLED} + VFW_E_DVD_TITLE_UNKNOWN = HResult($80040290); + {$EXTERNALSYM VFW_E_DVD_TITLE_UNKNOWN} + VFW_E_DVD_INVALID_DISC = HResult($80040291); + {$EXTERNALSYM VFW_E_DVD_INVALID_DISC} + VFW_E_DVD_NO_RESUME_INFORMATION = HResult($80040292); + {$EXTERNALSYM VFW_E_DVD_NO_RESUME_INFORMATION} + VFW_E_PIN_ALREADY_BLOCKED_ON_THIS_THREAD = HResult($80040293); + {$EXTERNALSYM VFW_E_PIN_ALREADY_BLOCKED_ON_THIS_THREAD} + VFW_E_PIN_ALREADY_BLOCKED = HResult($80040294); + {$EXTERNALSYM VFW_E_PIN_ALREADY_BLOCKED} + VFW_E_CERTIFICATION_FAILURE = HResult($80040295); + {$EXTERNALSYM VFW_E_CERTIFICATION_FAILURE} + VFW_E_VMR_NOT_IN_MIXER_MODE = HResult($80040296); + {$EXTERNALSYM VFW_E_VMR_NOT_IN_MIXER_MODE} + + // The application has not yet provided the VMR filter with a valid allocator-presenter object.%0 + VFW_E_VMR_NO_AP_SUPPLIED = HResult($80040297); + {$EXTERNALSYM VFW_E_VMR_NO_AP_SUPPLIED} + + // The VMR could not find any de-interlacing hardware on the current display device.%0 + VFW_E_VMR_NO_DEINTERLACE_HW = HResult($80040298); + {$EXTERNALSYM VFW_E_VMR_NO_DEINTERLACE_HW} + + // The VMR could not find any ProcAmp hardware on the current display device.%0 + VFW_E_VMR_NO_PROCAMP_HW = HResult($80040299); + {$EXTERNALSYM VFW_E_VMR_NO_PROCAMP_HW} + + // VMR9 does not work with VPE-based hardware decoders.%0 + VFW_E_DVD_VMR9_INCOMPATIBLEDEC = HResult($8004029A); + {$EXTERNALSYM VFW_E_DVD_VMR9_INCOMPATIBLEDEC} + + // The current display device does not support Content Output Protection Protocol (COPP) H/W.%0 + VFW_E_NO_COPP_HW = HRESULT($8004029B); + {$EXTERNALSYM VFW_E_NO_COPP_HW} + + E_PROP_SET_UNSUPPORTED = HResult($80070492); + {$EXTERNALSYM E_PROP_SET_UNSUPPORTED} + E_PROP_ID_UNSUPPORTED = HResult($80070490); + {$EXTERNALSYM E_PROP_ID_UNSUPPORTED} + + +(*==========================================================================; + * + * Copyright (C) 1996-1997 Microsoft Corporation. All Rights Reserved. + * + * Files: edevdefs.h + * XPrtDefs.h (derived from edevdefs.h) + * + ***************************************************************************) + +const + ED_BASE = $1000; + {$EXTERNALSYM ED_BASE} + +// this is used to tell the device communications object which +// physical communications port to use. + DEV_PORT_SIM = 1; + {$EXTERNALSYM DEV_PORT_SIM} + DEV_PORT_COM1 = 2; // standard serial ports + {$EXTERNALSYM DEV_PORT_COM1} + DEV_PORT_COM2 = 3; + {$EXTERNALSYM DEV_PORT_COM2} + DEV_PORT_COM3 = 4; + {$EXTERNALSYM DEV_PORT_COM3} + DEV_PORT_COM4 = 5; + {$EXTERNALSYM DEV_PORT_COM4} + DEV_PORT_DIAQ = 6; // Diaquest driver + {$EXTERNALSYM DEV_PORT_DIAQ} + DEV_PORT_ARTI = 7; // ARTI driver + {$EXTERNALSYM DEV_PORT_ARTI} + DEV_PORT_1394 = 8; // IEEE 1394 Serial Bus + {$EXTERNALSYM DEV_PORT_1394} + DEV_PORT_USB = 9; // Universal Serial Bus + {$EXTERNALSYM DEV_PORT_USB} + DEV_PORT_MIN = DEV_PORT_SIM; + {$EXTERNALSYM DEV_PORT_MIN} + DEV_PORT_MAX = DEV_PORT_USB; + {$EXTERNALSYM DEV_PORT_MAX} + +// IAMExtDevice Capability Items: unless otherwise specified, these items return +// OATRUE or OAFALSE. All return values are in pdwValue unless otherwise specified: + + ED_DEVCAP_CAN_RECORD = ED_BASE+1; + {$EXTERNALSYM ED_DEVCAP_CAN_RECORD} + ED_DEVCAP_CAN_RECORD_STROBE = ED_BASE+2; + {$EXTERNALSYM ED_DEVCAP_CAN_RECORD_STROBE} + ED_DEVCAP_HAS_AUDIO = ED_BASE+3; + {$EXTERNALSYM ED_DEVCAP_HAS_AUDIO} + ED_DEVCAP_HAS_VIDEO = ED_BASE+4; + {$EXTERNALSYM ED_DEVCAP_HAS_VIDEO} + ED_DEVCAP_USES_FILES = ED_BASE+5; + {$EXTERNALSYM ED_DEVCAP_USES_FILES} + ED_DEVCAP_CAN_SAVE = ED_BASE+6; + {$EXTERNALSYM ED_DEVCAP_CAN_SAVE} + ED_DEVCAP_DEVICE_TYPE = ED_BASE+7; + {$EXTERNALSYM ED_DEVCAP_DEVICE_TYPE} + ED_DEVTYPE_VCR = ED_BASE+8; + {$EXTERNALSYM ED_DEVTYPE_VCR} + ED_DEVTYPE_LASERDISK = ED_BASE+9; + {$EXTERNALSYM ED_DEVTYPE_LASERDISK} + ED_DEVTYPE_ATR = ED_BASE+10; + {$EXTERNALSYM ED_DEVTYPE_ATR} + ED_DEVTYPE_DDR = ED_BASE+11; + {$EXTERNALSYM ED_DEVTYPE_DDR} + ED_DEVTYPE_ROUTER = ED_BASE+12; + {$EXTERNALSYM ED_DEVTYPE_ROUTER} + ED_DEVTYPE_KEYER = ED_BASE+13; + {$EXTERNALSYM ED_DEVTYPE_KEYER} + ED_DEVTYPE_MIXER_VIDEO = ED_BASE+14; + {$EXTERNALSYM ED_DEVTYPE_MIXER_VIDEO} + ED_DEVTYPE_DVE = ED_BASE+15; + {$EXTERNALSYM ED_DEVTYPE_DVE} + ED_DEVTYPE_WIPEGEN = ED_BASE+16; + {$EXTERNALSYM ED_DEVTYPE_WIPEGEN} + ED_DEVTYPE_MIXER_AUDIO = ED_BASE+17; + {$EXTERNALSYM ED_DEVTYPE_MIXER_AUDIO} + ED_DEVTYPE_CG = ED_BASE+18; + {$EXTERNALSYM ED_DEVTYPE_CG} + ED_DEVTYPE_TBC = ED_BASE+19; + {$EXTERNALSYM ED_DEVTYPE_TBC} + ED_DEVTYPE_TCG = ED_BASE+20; + {$EXTERNALSYM ED_DEVTYPE_TCG} + ED_DEVTYPE_GPI = ED_BASE+21; + {$EXTERNALSYM ED_DEVTYPE_GPI} + ED_DEVTYPE_JOYSTICK = ED_BASE+22; + {$EXTERNALSYM ED_DEVTYPE_JOYSTICK} + ED_DEVTYPE_KEYBOARD = ED_BASE+23; + {$EXTERNALSYM ED_DEVTYPE_KEYBOARD} + +// returns mfr-specific ID from external device. + ED_DEVCAP_EXTERNAL_DEVICE_ID = ED_BASE+24; + {$EXTERNALSYM ED_DEVCAP_EXTERNAL_DEVICE_ID} + + ED_DEVCAP_TIMECODE_READ = ED_BASE+25; + {$EXTERNALSYM ED_DEVCAP_TIMECODE_READ} + ED_DEVCAP_TIMECODE_WRITE = ED_BASE+26; + {$EXTERNALSYM ED_DEVCAP_TIMECODE_WRITE} +// used for seekable non-timecode enabled devices + ED_DEVCAP_CTLTRK_READ = ED_BASE+27; + {$EXTERNALSYM ED_DEVCAP_CTLTRK_READ} +// used for seekable non-timecode enabled devices + ED_DEVCAP_INDEX_READ = ED_BASE+28; + {$EXTERNALSYM ED_DEVCAP_INDEX_READ} + +// returns device preroll time in current time format + ED_DEVCAP_PREROLL = ED_BASE+29; + {$EXTERNALSYM ED_DEVCAP_PREROLL} +// returns device postroll time in current time format + ED_DEVCAP_POSTROLL = ED_BASE+30; + {$EXTERNALSYM ED_DEVCAP_POSTROLL} + +// returns indication of device’s synchronization accuracy. + ED_DEVCAP_SYNC_ACCURACY = ED_BASE+31; + {$EXTERNALSYM ED_DEVCAP_SYNC_ACCURACY} + ED_SYNCACC_PRECISE = ED_BASE+32; + {$EXTERNALSYM ED_SYNCACC_PRECISE} + ED_SYNCACC_FRAME = ED_BASE+33; + {$EXTERNALSYM ED_SYNCACC_FRAME} + ED_SYNCACC_ROUGH = ED_BASE+34; + {$EXTERNALSYM ED_SYNCACC_ROUGH} + +// returns device’s normal framerate. + ED_DEVCAP_NORMAL_RATE = ED_BASE+35; + {$EXTERNALSYM ED_DEVCAP_NORMAL_RATE} + ED_RATE_24 = ED_BASE+36; + {$EXTERNALSYM ED_RATE_24} + ED_RATE_25 = ED_BASE+37; + {$EXTERNALSYM ED_RATE_25} + ED_RATE_2997 = ED_BASE+38; + {$EXTERNALSYM ED_RATE_2997} + ED_RATE_30 = ED_BASE+39; + {$EXTERNALSYM ED_RATE_30} + + ED_DEVCAP_CAN_PREVIEW = ED_BASE+40; + {$EXTERNALSYM ED_DEVCAP_CAN_PREVIEW} + ED_DEVCAP_CAN_MONITOR_SOURCES = ED_BASE+41; + {$EXTERNALSYM ED_DEVCAP_CAN_MONITOR_SOURCES} + +// indicates implementation allows testing of methods/parameters by +// setting the hi bit of a parm that makes sense - see individual methods +// for details. + ED_DEVCAP_CAN_TEST = ED_BASE+42; + {$EXTERNALSYM ED_DEVCAP_CAN_TEST} + +// indicates device accepts video as an input. + ED_DEVCAP_VIDEO_INPUTS = ED_BASE+43; + {$EXTERNALSYM ED_DEVCAP_VIDEO_INPUTS} + +// indicates device accepts audio as an input. + ED_DEVCAP_AUDIO_INPUTS = ED_BASE+44; + {$EXTERNALSYM ED_DEVCAP_AUDIO_INPUTS} + + ED_DEVCAP_NEEDS_CALIBRATING = ED_BASE+45; + {$EXTERNALSYM ED_DEVCAP_NEEDS_CALIBRATING} + + ED_DEVCAP_SEEK_TYPE = ED_BASE+46; + {$EXTERNALSYM ED_DEVCAP_SEEK_TYPE} + ED_SEEK_PERFECT = ED_BASE+47; + {$EXTERNALSYM ED_SEEK_PERFECT} + ED_SEEK_FAST = ED_BASE+48; + {$EXTERNALSYM ED_SEEK_FAST} + ED_SEEK_SLOW = ED_BASE+49; + {$EXTERNALSYM ED_SEEK_SLOW} + + ED_POWER_ON = ED_BASE+50; + {$EXTERNALSYM ED_POWER_ON} + ED_POWER_OFF = ED_BASE+51; + {$EXTERNALSYM ED_POWER_OFF} + ED_POWER_STANDBY = ED_BASE+52; + {$EXTERNALSYM ED_POWER_STANDBY} + + ED_POWER_DEVICE_DEPENDENT = ED_BASE+1033; // Power is on with limited functions + {$EXTERNALSYM ED_POWER_DEVICE_DEPENDENT} + + ED_ACTIVE = ED_BASE+53; + {$EXTERNALSYM ED_ACTIVE} + ED_INACTIVE = ED_BASE+54; + {$EXTERNALSYM ED_INACTIVE} + ED_ALL = ED_BASE+55; + {$EXTERNALSYM ED_ALL} + ED_TEST = ED_BASE+56; + {$EXTERNALSYM ED_TEST} + +// IAMExtTransport Capability Items: unless otherwise specified, these items return +// OATRUE or OAFALSE. All return values are in pdwValue unless otherwise specified: + + ED_TRANSCAP_CAN_EJECT = ED_BASE+100; + {$EXTERNALSYM ED_TRANSCAP_CAN_EJECT} + ED_TRANSCAP_CAN_BUMP_PLAY = ED_BASE+101; + {$EXTERNALSYM ED_TRANSCAP_CAN_BUMP_PLAY} + ED_TRANSCAP_CAN_PLAY_BACKWARDS = ED_BASE+102; + {$EXTERNALSYM ED_TRANSCAP_CAN_PLAY_BACKWARDS} + ED_TRANSCAP_CAN_SET_EE = ED_BASE+103; + {$EXTERNALSYM ED_TRANSCAP_CAN_SET_EE} + ED_TRANSCAP_CAN_SET_PB = ED_BASE+104; + {$EXTERNALSYM ED_TRANSCAP_CAN_SET_PB} + ED_TRANSCAP_CAN_DELAY_VIDEO_IN = ED_BASE+105; + {$EXTERNALSYM ED_TRANSCAP_CAN_DELAY_VIDEO_IN} + ED_TRANSCAP_CAN_DELAY_VIDEO_OUT = ED_BASE+106; + {$EXTERNALSYM ED_TRANSCAP_CAN_DELAY_VIDEO_OUT} + ED_TRANSCAP_CAN_DELAY_AUDIO_IN = ED_BASE+107; + {$EXTERNALSYM ED_TRANSCAP_CAN_DELAY_AUDIO_IN} + ED_TRANSCAP_CAN_DELAY_AUDIO_OUT = ED_BASE+108; + {$EXTERNALSYM ED_TRANSCAP_CAN_DELAY_AUDIO_OUT} + ED_TRANSCAP_FWD_VARIABLE_MAX = ED_BASE+109; + {$EXTERNALSYM ED_TRANSCAP_FWD_VARIABLE_MAX} + ED_TRANSCAP_FWD_VARIABLE_MIN = ED_BASE+800; + {$EXTERNALSYM ED_TRANSCAP_FWD_VARIABLE_MIN} + ED_TRANSCAP_REV_VARIABLE_MAX = ED_BASE+110; + {$EXTERNALSYM ED_TRANSCAP_REV_VARIABLE_MAX} + ED_TRANSCAP_REV_VARIABLE_MIN = ED_BASE+801; + {$EXTERNALSYM ED_TRANSCAP_REV_VARIABLE_MIN} + ED_TRANSCAP_FWD_SHUTTLE_MAX = ED_BASE+802; + {$EXTERNALSYM ED_TRANSCAP_FWD_SHUTTLE_MAX} + ED_TRANSCAP_FWD_SHUTTLE_MIN = ED_BASE+803; + {$EXTERNALSYM ED_TRANSCAP_FWD_SHUTTLE_MIN} + ED_TRANSCAP_REV_SHUTTLE_MAX = ED_BASE+804; + {$EXTERNALSYM ED_TRANSCAP_REV_SHUTTLE_MAX} + ED_TRANSCAP_REV_SHUTTLE_MIN = ED_BASE+805; + {$EXTERNALSYM ED_TRANSCAP_REV_SHUTTLE_MIN} + ED_TRANSCAP_NUM_AUDIO_TRACKS = ED_BASE+111; + {$EXTERNALSYM ED_TRANSCAP_NUM_AUDIO_TRACKS} + ED_TRANSCAP_LTC_TRACK = ED_BASE+112; + {$EXTERNALSYM ED_TRANSCAP_LTC_TRACK} + ED_TRANSCAP_NEEDS_TBC = ED_BASE+113; + {$EXTERNALSYM ED_TRANSCAP_NEEDS_TBC} + ED_TRANSCAP_NEEDS_CUEING = ED_BASE+114; + {$EXTERNALSYM ED_TRANSCAP_NEEDS_CUEING} + ED_TRANSCAP_CAN_INSERT = ED_BASE+115; + {$EXTERNALSYM ED_TRANSCAP_CAN_INSERT} + ED_TRANSCAP_CAN_ASSEMBLE = ED_BASE+116; + {$EXTERNALSYM ED_TRANSCAP_CAN_ASSEMBLE} + ED_TRANSCAP_FIELD_STEP = ED_BASE+117; + {$EXTERNALSYM ED_TRANSCAP_FIELD_STEP} + ED_TRANSCAP_CLOCK_INC_RATE = ED_BASE+118; + {$EXTERNALSYM ED_TRANSCAP_CLOCK_INC_RATE} + ED_TRANSCAP_CAN_DETECT_LENGTH = ED_BASE+119; + {$EXTERNALSYM ED_TRANSCAP_CAN_DETECT_LENGTH} + ED_TRANSCAP_CAN_FREEZE = ED_BASE+120; + {$EXTERNALSYM ED_TRANSCAP_CAN_FREEZE} + ED_TRANSCAP_HAS_TUNER = ED_BASE+121; + {$EXTERNALSYM ED_TRANSCAP_HAS_TUNER} + ED_TRANSCAP_HAS_TIMER = ED_BASE+122; + {$EXTERNALSYM ED_TRANSCAP_HAS_TIMER} + ED_TRANSCAP_HAS_CLOCK = ED_BASE+123; + {$EXTERNALSYM ED_TRANSCAP_HAS_CLOCK} + ED_TRANSCAP_MULTIPLE_EDITS = ED_BASE+806; + {$EXTERNALSYM ED_TRANSCAP_MULTIPLE_EDITS} + ED_TRANSCAP_IS_MASTER = ED_BASE+807; + {$EXTERNALSYM ED_TRANSCAP_IS_MASTER} + ED_TRANSCAP_HAS_DT = ED_BASE+814; + {$EXTERNALSYM ED_TRANSCAP_HAS_DT} + +// IAMExtTransport Media States + ED_MEDIA_SPIN_UP = ED_BASE+130; + {$EXTERNALSYM ED_MEDIA_SPIN_UP} + ED_MEDIA_SPIN_DOWN = ED_BASE+131; + {$EXTERNALSYM ED_MEDIA_SPIN_DOWN} + ED_MEDIA_UNLOAD = ED_BASE+132; + {$EXTERNALSYM ED_MEDIA_UNLOAD} + +// IAMExtTransport Modes + ED_MODE_PLAY = ED_BASE+200; + {$EXTERNALSYM ED_MODE_PLAY} + ED_MODE_STOP = ED_BASE+201; + {$EXTERNALSYM ED_MODE_STOP} + ED_MODE_FREEZE = ED_BASE+202; + {$EXTERNALSYM ED_MODE_FREEZE} + ED_MODE_THAW = ED_BASE+203; + {$EXTERNALSYM ED_MODE_THAW} + ED_MODE_FF = ED_BASE+204; + {$EXTERNALSYM ED_MODE_FF} + ED_MODE_REW = ED_BASE+205; + {$EXTERNALSYM ED_MODE_REW} + ED_MODE_RECORD = ED_BASE+206; + {$EXTERNALSYM ED_MODE_RECORD} + ED_MODE_RECORD_STROBE = ED_BASE+207; + {$EXTERNALSYM ED_MODE_RECORD_STROBE} + ED_MODE_RECORD_FREEZE = ED_BASE+808; // never "put", only "get" + {$EXTERNALSYM ED_MODE_RECORD_FREEZE} + ED_MODE_STEP = ED_BASE+208; + {$EXTERNALSYM ED_MODE_STEP} + ED_MODE_STEP_FWD = ED_BASE+208; + {$EXTERNALSYM ED_MODE_STEP_FWD} + ED_MODE_STEP_REV = ED_BASE+809; + {$EXTERNALSYM ED_MODE_STEP_REV} + ED_MODE_SHUTTLE = ED_BASE+209; + {$EXTERNALSYM ED_MODE_SHUTTLE} + ED_MODE_EDIT_CUE = ED_BASE+210; + {$EXTERNALSYM ED_MODE_EDIT_CUE} + ED_MODE_VAR_SPEED = ED_BASE+211; + {$EXTERNALSYM ED_MODE_VAR_SPEED} + ED_MODE_PERFORM = ED_BASE+212; + {$EXTERNALSYM ED_MODE_PERFORM} + ED_MODE_LINK_ON = ED_BASE+280; + {$EXTERNALSYM ED_MODE_LINK_ON} + ED_MODE_LINK_OFF = ED_BASE+281; + {$EXTERNALSYM ED_MODE_LINK_OFF} + ED_MODE_NOTIFY_ENABLE = ED_BASE+810; + {$EXTERNALSYM ED_MODE_NOTIFY_ENABLE} + ED_MODE_NOTIFY_DISABLE = ED_BASE+811; + {$EXTERNALSYM ED_MODE_NOTIFY_DISABLE} + ED_MODE_SHOT_SEARCH = ED_BASE+812; + {$EXTERNALSYM ED_MODE_SHOT_SEARCH} + +// IAMTimecodeReader/Generator/Display defines +// +// Timecode Generator Mode params and values: +// + ED_TCG_TIMECODE_TYPE = ED_BASE+400; + {$EXTERNALSYM ED_TCG_TIMECODE_TYPE} + ED_TCG_SMPTE_LTC = ED_BASE+401; + {$EXTERNALSYM ED_TCG_SMPTE_LTC} + ED_TCG_SMPTE_VITC = ED_BASE+402; + {$EXTERNALSYM ED_TCG_SMPTE_VITC} + ED_TCG_MIDI_QF = ED_BASE+403; + {$EXTERNALSYM ED_TCG_MIDI_QF} + ED_TCG_MIDI_FULL = ED_BASE+404; + {$EXTERNALSYM ED_TCG_MIDI_FULL} + + ED_TCG_FRAMERATE = ED_BASE+405; + {$EXTERNALSYM ED_TCG_FRAMERATE} + ED_FORMAT_SMPTE_30 = ED_BASE+406; + {$EXTERNALSYM ED_FORMAT_SMPTE_30} + ED_FORMAT_SMPTE_30DROP = ED_BASE+407; + {$EXTERNALSYM ED_FORMAT_SMPTE_30DROP} + ED_FORMAT_SMPTE_25 = ED_BASE+408; + {$EXTERNALSYM ED_FORMAT_SMPTE_25} + ED_FORMAT_SMPTE_24 = ED_BASE+409; + {$EXTERNALSYM ED_FORMAT_SMPTE_24} + + ED_TCG_SYNC_SOURCE = ED_BASE+410; + {$EXTERNALSYM ED_TCG_SYNC_SOURCE} + ED_TCG_VIDEO = ED_BASE+411; + {$EXTERNALSYM ED_TCG_VIDEO} + ED_TCG_READER = ED_BASE+412; + {$EXTERNALSYM ED_TCG_READER} + ED_TCG_FREE = ED_BASE+413; + {$EXTERNALSYM ED_TCG_FREE} + + ED_TCG_REFERENCE_SOURCE = ED_BASE+414; + {$EXTERNALSYM ED_TCG_REFERENCE_SOURCE} + +// TimeCodeReader Mode params and values: + ED_TCR_SOURCE = ED_BASE+416; + {$EXTERNALSYM ED_TCR_SOURCE} +// ED_TCG (already defined) + ED_TCR_LTC = ED_BASE+417; + {$EXTERNALSYM ED_TCR_LTC} + ED_TCR_VITC = ED_BASE+418; + {$EXTERNALSYM ED_TCR_VITC} + ED_TCR_CT = ED_BASE+419; + {$EXTERNALSYM ED_TCR_CT} + ED_TCR_FTC = ED_BASE+420; + {$EXTERNALSYM ED_TCR_FTC} + +// ED_MODE_NOTIFY_ENABLE can be OATRUE or OAFALSE (defined in transport mode +// section of this file). + ED_TCR_LAST_VALUE = ED_BASE+421; + {$EXTERNALSYM ED_TCR_LAST_VALUE} + +// TimeCode Display Mode params and values: +// + ED_TCD_SOURCE = ED_BASE+422; + {$EXTERNALSYM ED_TCD_SOURCE} + ED_TCR = ED_BASE+423; + {$EXTERNALSYM ED_TCR} + ED_TCG = ED_BASE+424; + {$EXTERNALSYM ED_TCG} + + ED_TCD_SIZE = ED_BASE+425; + {$EXTERNALSYM ED_TCD_SIZE} + ED_SMALL = ED_BASE+426; + {$EXTERNALSYM ED_SMALL} + ED_MED = ED_BASE+427; + {$EXTERNALSYM ED_MED} + ED_LARGE = ED_BASE+428; + {$EXTERNALSYM ED_LARGE} + + ED_TCD_POSITION = ED_BASE+429; + {$EXTERNALSYM ED_TCD_POSITION} + ED_TOP = $0001; + {$EXTERNALSYM ED_TOP} + ED_MIDDLE = $0002; + {$EXTERNALSYM ED_MIDDLE} + ED_BOTTOM = $0004; + {$EXTERNALSYM ED_BOTTOM} + ED_LEFT = $0100; + {$EXTERNALSYM ED_LEFT} + ED_CENTER = $0200; + {$EXTERNALSYM ED_CENTER} + ED_RIGHT = $0400; + {$EXTERNALSYM ED_RIGHT} + + ED_TCD_INTENSITY = ED_BASE+436; + {$EXTERNALSYM ED_TCD_INTENSITY} + ED_HIGH = ED_BASE+437; + {$EXTERNALSYM ED_HIGH} + ED_LOW = ED_BASE+438; + {$EXTERNALSYM ED_LOW} + + ED_TCD_TRANSPARENCY = ED_BASE+439; + {$EXTERNALSYM ED_TCD_TRANSPARENCY} + ED_TCD_INVERT = ED_BASE+440; + {$EXTERNALSYM ED_TCD_INVERT} + +// IAMExtTransport defines +// +// Transport status, params and values +// + +// IAMExtTransport Status items and and values: + ED_MODE = ED_BASE+500; + {$EXTERNALSYM ED_MODE} + ED_ERROR = ED_BASE+501; + {$EXTERNALSYM ED_ERROR} + ED_LOCAL = ED_BASE+502; + {$EXTERNALSYM ED_LOCAL} + ED_RECORD_INHIBIT = ED_BASE+503; + {$EXTERNALSYM ED_RECORD_INHIBIT} + ED_SERVO_LOCK = ED_BASE+504; + {$EXTERNALSYM ED_SERVO_LOCK} + ED_MEDIA_PRESENT = ED_BASE+505; + {$EXTERNALSYM ED_MEDIA_PRESENT} + ED_MEDIA_LENGTH = ED_BASE+506; + {$EXTERNALSYM ED_MEDIA_LENGTH} + ED_MEDIA_SIZE = ED_BASE+507; + {$EXTERNALSYM ED_MEDIA_SIZE} + ED_MEDIA_TRACK_COUNT = ED_BASE+508; + {$EXTERNALSYM ED_MEDIA_TRACK_COUNT} + ED_MEDIA_TRACK_LENGTH = ED_BASE+509; + {$EXTERNALSYM ED_MEDIA_TRACK_LENGTH} + ED_MEDIA_SIDE = ED_BASE+510; + {$EXTERNALSYM ED_MEDIA_SIDE} + + ED_MEDIA_TYPE = ED_BASE+511; + {$EXTERNALSYM ED_MEDIA_TYPE} + ED_MEDIA_VHS = ED_BASE+512; + {$EXTERNALSYM ED_MEDIA_VHS} + ED_MEDIA_SVHS = ED_BASE+513; + {$EXTERNALSYM ED_MEDIA_SVHS} + ED_MEDIA_HI8 = ED_BASE+514; + {$EXTERNALSYM ED_MEDIA_HI8} + ED_MEDIA_UMATIC = ED_BASE+515; + {$EXTERNALSYM ED_MEDIA_UMATIC} + ED_MEDIA_DVC = ED_BASE+516; + {$EXTERNALSYM ED_MEDIA_DVC} + ED_MEDIA_1_INCH = ED_BASE+517; + {$EXTERNALSYM ED_MEDIA_1_INCH} + ED_MEDIA_D1 = ED_BASE+518; + {$EXTERNALSYM ED_MEDIA_D1} + ED_MEDIA_D2 = ED_BASE+519; + {$EXTERNALSYM ED_MEDIA_D2} + ED_MEDIA_D3 = ED_BASE+520; + {$EXTERNALSYM ED_MEDIA_D3} + ED_MEDIA_D5 = ED_BASE+521; + {$EXTERNALSYM ED_MEDIA_D5} + ED_MEDIA_DBETA = ED_BASE+522; + {$EXTERNALSYM ED_MEDIA_DBETA} + ED_MEDIA_BETA = ED_BASE+523; + {$EXTERNALSYM ED_MEDIA_BETA} + ED_MEDIA_8MM = ED_BASE+524; + {$EXTERNALSYM ED_MEDIA_8MM} + ED_MEDIA_DDR = ED_BASE+525; + {$EXTERNALSYM ED_MEDIA_DDR} + ED_MEDIA_SX = ED_BASE+813; + {$EXTERNALSYM ED_MEDIA_SX} + ED_MEDIA_OTHER = ED_BASE+526; + {$EXTERNALSYM ED_MEDIA_OTHER} + ED_MEDIA_CLV = ED_BASE+527; + {$EXTERNALSYM ED_MEDIA_CLV} + ED_MEDIA_CAV = ED_BASE+528; + {$EXTERNALSYM ED_MEDIA_CAV} + ED_MEDIA_POSITION = ED_BASE+529; + {$EXTERNALSYM ED_MEDIA_POSITION} + ED_MEDIA_NEO = ED_BASE+531; // Mini digital tape for MPEG2TS signal + {$EXTERNALSYM ED_MEDIA_NEO} + ED_MEDIA_MICROMV = ED_MEDIA_NEO; + {$EXTERNALSYM ED_MEDIA_MICROMV} + + ED_LINK_MODE = ED_BASE+530; + {$EXTERNALSYM ED_LINK_MODE} + +// IAMExtTransport Basic Parms + ED_TRANSBASIC_TIME_FORMAT = ED_BASE+540; + {$EXTERNALSYM ED_TRANSBASIC_TIME_FORMAT} + ED_FORMAT_MILLISECONDS = ED_BASE+541; + {$EXTERNALSYM ED_FORMAT_MILLISECONDS} + ED_FORMAT_FRAMES = ED_BASE+542; + {$EXTERNALSYM ED_FORMAT_FRAMES} + ED_FORMAT_REFERENCE_TIME = ED_BASE+543; + {$EXTERNALSYM ED_FORMAT_REFERENCE_TIME} + + ED_FORMAT_HMSF = ED_BASE+547; + {$EXTERNALSYM ED_FORMAT_HMSF} + ED_FORMAT_TMSF = ED_BASE+548; + {$EXTERNALSYM ED_FORMAT_TMSF} + + ED_TRANSBASIC_TIME_REFERENCE = ED_BASE+549; + {$EXTERNALSYM ED_TRANSBASIC_TIME_REFERENCE} + ED_TIMEREF_TIMECODE = ED_BASE+550; + {$EXTERNALSYM ED_TIMEREF_TIMECODE} + ED_TIMEREF_CONTROL_TRACK = ED_BASE+551; + {$EXTERNALSYM ED_TIMEREF_CONTROL_TRACK} + ED_TIMEREF_INDEX = ED_BASE+552; + {$EXTERNALSYM ED_TIMEREF_INDEX} + + ED_TRANSBASIC_SUPERIMPOSE = ED_BASE+553; + {$EXTERNALSYM ED_TRANSBASIC_SUPERIMPOSE} + ED_TRANSBASIC_END_STOP_ACTION = ED_BASE+554; + {$EXTERNALSYM ED_TRANSBASIC_END_STOP_ACTION} + + ED_TRANSBASIC_RECORD_FORMAT = ED_BASE+555; + {$EXTERNALSYM ED_TRANSBASIC_RECORD_FORMAT} + ED_RECORD_FORMAT_SP = ED_BASE+556; + {$EXTERNALSYM ED_RECORD_FORMAT_SP} + ED_RECORD_FORMAT_LP = ED_BASE+557; + {$EXTERNALSYM ED_RECORD_FORMAT_LP} + ED_RECORD_FORMAT_EP = ED_BASE+558; + {$EXTERNALSYM ED_RECORD_FORMAT_EP} + + ED_TRANSBASIC_STEP_COUNT = ED_BASE+559; + {$EXTERNALSYM ED_TRANSBASIC_STEP_COUNT} + ED_TRANSBASIC_STEP_UNIT = ED_BASE+560; + {$EXTERNALSYM ED_TRANSBASIC_STEP_UNIT} + ED_STEP_FIELD = ED_BASE+561; + {$EXTERNALSYM ED_STEP_FIELD} + ED_STEP_FRAME = ED_BASE+562; + {$EXTERNALSYM ED_STEP_FRAME} + ED_STEP_3_2 = ED_BASE+563; + {$EXTERNALSYM ED_STEP_3_2} + + ED_TRANSBASIC_PREROLL = ED_BASE+564; + {$EXTERNALSYM ED_TRANSBASIC_PREROLL} + ED_TRANSBASIC_RECPREROLL = ED_BASE+565; + {$EXTERNALSYM ED_TRANSBASIC_RECPREROLL} + ED_TRANSBASIC_POSTROLL = ED_BASE+566; + {$EXTERNALSYM ED_TRANSBASIC_POSTROLL} + ED_TRANSBASIC_EDIT_DELAY = ED_BASE+567; + {$EXTERNALSYM ED_TRANSBASIC_EDIT_DELAY} + ED_TRANSBASIC_PLAYTC_DELAY = ED_BASE+568; + {$EXTERNALSYM ED_TRANSBASIC_PLAYTC_DELAY} + ED_TRANSBASIC_RECTC_DELAY = ED_BASE+569; + {$EXTERNALSYM ED_TRANSBASIC_RECTC_DELAY} + ED_TRANSBASIC_EDIT_FIELD = ED_BASE+570; + {$EXTERNALSYM ED_TRANSBASIC_EDIT_FIELD} + ED_TRANSBASIC_FRAME_SERVO = ED_BASE+571; + {$EXTERNALSYM ED_TRANSBASIC_FRAME_SERVO} + ED_TRANSBASIC_CF_SERVO = ED_BASE+572; + {$EXTERNALSYM ED_TRANSBASIC_CF_SERVO} + ED_TRANSBASIC_SERVO_REF = ED_BASE+573; + {$EXTERNALSYM ED_TRANSBASIC_SERVO_REF} + ED_REF_EXTERNAL = ED_BASE+574; + {$EXTERNALSYM ED_REF_EXTERNAL} + ED_REF_INPUT = ED_BASE+575; + {$EXTERNALSYM ED_REF_INPUT} + ED_REF_INTERNAL = ED_BASE+576; + {$EXTERNALSYM ED_REF_INTERNAL} + ED_REF_AUTO = ED_BASE+577; + {$EXTERNALSYM ED_REF_AUTO} + + ED_TRANSBASIC_WARN_GL = ED_BASE+578; + {$EXTERNALSYM ED_TRANSBASIC_WARN_GL} + ED_TRANSBASIC_SET_TRACKING = ED_BASE+579; + {$EXTERNALSYM ED_TRANSBASIC_SET_TRACKING} + ED_TRACKING_PLUS = ED_BASE+580; + {$EXTERNALSYM ED_TRACKING_PLUS} + ED_TRACKING_MINUS = ED_BASE+581; + {$EXTERNALSYM ED_TRACKING_MINUS} + ED_TRACKING_RESET = ED_BASE+582; + {$EXTERNALSYM ED_TRACKING_RESET} + + ED_TRANSBASIC_SET_FREEZE_TIMEOUT = ED_BASE+583; + {$EXTERNALSYM ED_TRANSBASIC_SET_FREEZE_TIMEOUT} + ED_TRANSBASIC_VOLUME_NAME = ED_BASE+584; + {$EXTERNALSYM ED_TRANSBASIC_VOLUME_NAME} + ED_TRANSBASIC_BALLISTIC_1 = ED_BASE+585; + {$EXTERNALSYM ED_TRANSBASIC_BALLISTIC_1} + ED_TRANSBASIC_BALLISTIC_2 = ED_BASE+586; + {$EXTERNALSYM ED_TRANSBASIC_BALLISTIC_2} + ED_TRANSBASIC_BALLISTIC_3 = ED_BASE+587; + {$EXTERNALSYM ED_TRANSBASIC_BALLISTIC_3} + ED_TRANSBASIC_BALLISTIC_4 = ED_BASE+588; + {$EXTERNALSYM ED_TRANSBASIC_BALLISTIC_4} + ED_TRANSBASIC_BALLISTIC_5 = ED_BASE+589; + {$EXTERNALSYM ED_TRANSBASIC_BALLISTIC_5} + ED_TRANSBASIC_BALLISTIC_6 = ED_BASE+590; + {$EXTERNALSYM ED_TRANSBASIC_BALLISTIC_6} + ED_TRANSBASIC_BALLISTIC_7 = ED_BASE+591; + {$EXTERNALSYM ED_TRANSBASIC_BALLISTIC_7} + ED_TRANSBASIC_BALLISTIC_8 = ED_BASE+592; + {$EXTERNALSYM ED_TRANSBASIC_BALLISTIC_8} + ED_TRANSBASIC_BALLISTIC_9 = ED_BASE+593; + {$EXTERNALSYM ED_TRANSBASIC_BALLISTIC_9} + ED_TRANSBASIC_BALLISTIC_10 = ED_BASE+594; + {$EXTERNALSYM ED_TRANSBASIC_BALLISTIC_10} + ED_TRANSBASIC_BALLISTIC_11 = ED_BASE+595; + {$EXTERNALSYM ED_TRANSBASIC_BALLISTIC_11} + ED_TRANSBASIC_BALLISTIC_12 = ED_BASE+596; + {$EXTERNALSYM ED_TRANSBASIC_BALLISTIC_12} + ED_TRANSBASIC_BALLISTIC_13 = ED_BASE+597; + {$EXTERNALSYM ED_TRANSBASIC_BALLISTIC_13} + ED_TRANSBASIC_BALLISTIC_14 = ED_BASE+598; + {$EXTERNALSYM ED_TRANSBASIC_BALLISTIC_14} + ED_TRANSBASIC_BALLISTIC_15 = ED_BASE+599; + {$EXTERNALSYM ED_TRANSBASIC_BALLISTIC_15} + ED_TRANSBASIC_BALLISTIC_16 = ED_BASE+600; + {$EXTERNALSYM ED_TRANSBASIC_BALLISTIC_16} + ED_TRANSBASIC_BALLISTIC_17 = ED_BASE+601; + {$EXTERNALSYM ED_TRANSBASIC_BALLISTIC_17} + ED_TRANSBASIC_BALLISTIC_18 = ED_BASE+602; + {$EXTERNALSYM ED_TRANSBASIC_BALLISTIC_18} + ED_TRANSBASIC_BALLISTIC_19 = ED_BASE+603; + {$EXTERNALSYM ED_TRANSBASIC_BALLISTIC_19} + ED_TRANSBASIC_BALLISTIC_20 = ED_BASE+604; + {$EXTERNALSYM ED_TRANSBASIC_BALLISTIC_20} + +// consumer VCR items + ED_TRANSBASIC_SETCLOCK = ED_BASE+605; + {$EXTERNALSYM ED_TRANSBASIC_SETCLOCK} + ED_TRANSBASIC_SET_COUNTER_FORMAT = ED_BASE+606; + {$EXTERNALSYM ED_TRANSBASIC_SET_COUNTER_FORMAT} + ED_TRANSBASIC_SET_COUNTER_VALUE = ED_BASE+607; + {$EXTERNALSYM ED_TRANSBASIC_SET_COUNTER_VALUE} + + ED_TRANSBASIC_SETTUNER_CH_UP = ED_BASE+608; + {$EXTERNALSYM ED_TRANSBASIC_SETTUNER_CH_UP} + ED_TRANSBASIC_SETTUNER_CH_DN = ED_BASE+609; + {$EXTERNALSYM ED_TRANSBASIC_SETTUNER_CH_DN} + ED_TRANSBASIC_SETTUNER_SK_UP = ED_BASE+610; + {$EXTERNALSYM ED_TRANSBASIC_SETTUNER_SK_UP} + ED_TRANSBASIC_SETTUNER_SK_DN = ED_BASE+611; + {$EXTERNALSYM ED_TRANSBASIC_SETTUNER_SK_DN} + ED_TRANSBASIC_SETTUNER_CH = ED_BASE+612; + {$EXTERNALSYM ED_TRANSBASIC_SETTUNER_CH} + ED_TRANSBASIC_SETTUNER_NUM = ED_BASE+613; + {$EXTERNALSYM ED_TRANSBASIC_SETTUNER_NUM} + ED_TRANSBASIC_SETTIMER_EVENT = ED_BASE+614; + {$EXTERNALSYM ED_TRANSBASIC_SETTIMER_EVENT} + ED_TRANSBASIC_SETTIMER_STARTDAY = ED_BASE+615; + {$EXTERNALSYM ED_TRANSBASIC_SETTIMER_STARTDAY} + ED_TRANSBASIC_SETTIMER_STARTTIME = ED_BASE+616; + {$EXTERNALSYM ED_TRANSBASIC_SETTIMER_STARTTIME} + ED_TRANSBASIC_SETTIMER_STOPDAY = ED_BASE+617; + {$EXTERNALSYM ED_TRANSBASIC_SETTIMER_STOPDAY} + ED_TRANSBASIC_SETTIMER_STOPTIME = ED_BASE+618; + {$EXTERNALSYM ED_TRANSBASIC_SETTIMER_STOPTIME} + +// IAMExtTransport video parameters + ED_TRANSVIDEO_SET_OUTPUT = ED_BASE+630; + {$EXTERNALSYM ED_TRANSVIDEO_SET_OUTPUT} + ED_E2E = ED_BASE+631; + {$EXTERNALSYM ED_E2E} + ED_PLAYBACK = ED_BASE+632; + {$EXTERNALSYM ED_PLAYBACK} + ED_OFF = ED_BASE+633; + {$EXTERNALSYM ED_OFF} + + ED_TRANSVIDEO_SET_SOURCE = ED_BASE+634; + {$EXTERNALSYM ED_TRANSVIDEO_SET_SOURCE} + +// IAMExtTransport audio parameters + ED_TRANSAUDIO_ENABLE_OUTPUT = ED_BASE+640; + {$EXTERNALSYM ED_TRANSAUDIO_ENABLE_OUTPUT} + ED_AUDIO_ALL = $10000000; + {$EXTERNALSYM ED_AUDIO_ALL} + ED_AUDIO_1 = $0000001; + {$EXTERNALSYM ED_AUDIO_1} + ED_AUDIO_2 = $0000002; + {$EXTERNALSYM ED_AUDIO_2} + ED_AUDIO_3 = $0000004; + {$EXTERNALSYM ED_AUDIO_3} + ED_AUDIO_4 = $0000008; + {$EXTERNALSYM ED_AUDIO_4} + ED_AUDIO_5 = $0000010; + {$EXTERNALSYM ED_AUDIO_5} + ED_AUDIO_6 = $0000020; + {$EXTERNALSYM ED_AUDIO_6} + ED_AUDIO_7 = $0000040; + {$EXTERNALSYM ED_AUDIO_7} + ED_AUDIO_8 = $0000080; + {$EXTERNALSYM ED_AUDIO_8} + ED_AUDIO_9 = $0000100; + {$EXTERNALSYM ED_AUDIO_9} + ED_AUDIO_10 = $0000200; + {$EXTERNALSYM ED_AUDIO_10} + ED_AUDIO_11 = $0000400; + {$EXTERNALSYM ED_AUDIO_11} + ED_AUDIO_12 = $0000800; + {$EXTERNALSYM ED_AUDIO_12} + ED_AUDIO_13 = $0001000; + {$EXTERNALSYM ED_AUDIO_13} + ED_AUDIO_14 = $0002000; + {$EXTERNALSYM ED_AUDIO_14} + ED_AUDIO_15 = $0004000; + {$EXTERNALSYM ED_AUDIO_15} + ED_AUDIO_16 = $0008000; + {$EXTERNALSYM ED_AUDIO_16} + ED_AUDIO_17 = $0010000; + {$EXTERNALSYM ED_AUDIO_17} + ED_AUDIO_18 = $0020000; + {$EXTERNALSYM ED_AUDIO_18} + ED_AUDIO_19 = $0040000; + {$EXTERNALSYM ED_AUDIO_19} + ED_AUDIO_20 = $0080000; + {$EXTERNALSYM ED_AUDIO_20} + ED_AUDIO_21 = $0100000; + {$EXTERNALSYM ED_AUDIO_21} + ED_AUDIO_22 = $0200000; + {$EXTERNALSYM ED_AUDIO_22} + ED_AUDIO_23 = $0400000; + {$EXTERNALSYM ED_AUDIO_23} + ED_AUDIO_24 = $0800000; + {$EXTERNALSYM ED_AUDIO_24} + ED_VIDEO = $2000000; + {$EXTERNALSYM ED_VIDEO} + + ED_TRANSAUDIO_ENABLE_RECORD = ED_BASE+642; + {$EXTERNALSYM ED_TRANSAUDIO_ENABLE_RECORD} + ED_TRANSAUDIO_ENABLE_SELSYNC = ED_BASE+643; + {$EXTERNALSYM ED_TRANSAUDIO_ENABLE_SELSYNC} + ED_TRANSAUDIO_SET_SOURCE = ED_BASE+644; + {$EXTERNALSYM ED_TRANSAUDIO_SET_SOURCE} + ED_TRANSAUDIO_SET_MONITOR = ED_BASE+645; + {$EXTERNALSYM ED_TRANSAUDIO_SET_MONITOR} + +// Edit Property Set-related defs + +// The following values reflect (and control) the state of an +// edit property set + ED_INVALID = ED_BASE+652; + {$EXTERNALSYM ED_INVALID} + ED_EXECUTING = ED_BASE+653; + {$EXTERNALSYM ED_EXECUTING} + ED_REGISTER = ED_BASE+654; + {$EXTERNALSYM ED_REGISTER} + ED_DELETE = ED_BASE+655; + {$EXTERNALSYM ED_DELETE} + +// Edit property set parameters and values + ED_EDIT_HEVENT = ED_BASE+656; + {$EXTERNALSYM ED_EDIT_HEVENT} + ED_EDIT_TEST = ED_BASE+657; + {$EXTERNALSYM ED_EDIT_TEST} + ED_EDIT_IMMEDIATE = ED_BASE+658; + {$EXTERNALSYM ED_EDIT_IMMEDIATE} + + ED_EDIT_MODE = ED_BASE+659; + {$EXTERNALSYM ED_EDIT_MODE} +// can be one of the following values: + ED_EDIT_MODE_ASSEMBLE = ED_BASE+660; + {$EXTERNALSYM ED_EDIT_MODE_ASSEMBLE} + ED_EDIT_MODE_INSERT = ED_BASE+661; + {$EXTERNALSYM ED_EDIT_MODE_INSERT} + ED_EDIT_MODE_CRASH_RECORD = ED_BASE+662; + {$EXTERNALSYM ED_EDIT_MODE_CRASH_RECORD} + ED_EDIT_MODE_BOOKMARK_TIME = ED_BASE+663; + {$EXTERNALSYM ED_EDIT_MODE_BOOKMARK_TIME} + ED_EDIT_MODE_BOOKMARK_CHAPTER = ED_BASE+664; + {$EXTERNALSYM ED_EDIT_MODE_BOOKMARK_CHAPTER} + + ED_EDIT_MASTER = ED_BASE+666; + {$EXTERNALSYM ED_EDIT_MASTER} + + ED_EDIT_TRACK = ED_BASE+667; + {$EXTERNALSYM ED_EDIT_TRACK} +// can be one of the following possible OR'd values: +// ED_VIDEO, ED_AUDIO_1 thru ED_AUDIO_24 (or ED_AUDIO_ALL) + + EDED_EDIT_SRC_INPOINT = ED_BASE+668; + {$EXTERNALSYM EDED_EDIT_SRC_INPOINT} + ED_EDIT_SRC_OUTPOINT = ED_BASE+669; + {$EXTERNALSYM ED_EDIT_SRC_OUTPOINT} + ED_EDIT_REC_INPOINT = ED_BASE+670; + {$EXTERNALSYM ED_EDIT_REC_INPOINT} + ED_EDIT_REC_OUTPOINT = ED_BASE+671; + {$EXTERNALSYM ED_EDIT_REC_OUTPOINT} + + ED_EDIT_REHEARSE_MODE = ED_BASE+672; + {$EXTERNALSYM ED_EDIT_REHEARSE_MODE} +// can be one of the following possible values: + ED_EDIT_BVB = ED_BASE+673; + {$EXTERNALSYM ED_EDIT_BVB} + ED_EDIT_VBV = ED_BASE+674; + {$EXTERNALSYM ED_EDIT_VBV} + ED_EDIT_VVV = ED_BASE+675; + {$EXTERNALSYM ED_EDIT_VVV} + ED_EDIT_PERFORM = ED_BASE+676; + {$EXTERNALSYM ED_EDIT_PERFORM} + + +// Set this property to OATRUE to kill the edit if in progress + ED_EDIT_ABORT = ED_BASE+677; + {$EXTERNALSYM ED_EDIT_ABORT} +// how long to wait for edit to complete + ED_EDIT_TIMEOUT = ED_BASE+678; + {$EXTERNALSYM ED_EDIT_TIMEOUT} + +// This property causes the device to seek to a point specified by +// ED_EDIT_SEEK_MODE (see below). NOTE: Only one event at a time can seek. + ED_EDIT_SEEK = ED_BASE+679; + {$EXTERNALSYM ED_EDIT_SEEK} + ED_EDIT_SEEK_MODE = ED_BASE+680; + {$EXTERNALSYM ED_EDIT_SEEK_MODE} + +//possible values: + ED_EDIT_SEEK_EDIT_IN = ED_BASE+681; + {$EXTERNALSYM ED_EDIT_SEEK_EDIT_IN} + ED_EDIT_SEEK_EDIT_OUT = ED_BASE+682; + {$EXTERNALSYM ED_EDIT_SEEK_EDIT_OUT} + ED_EDIT_SEEK_PREROLL = ED_BASE+683; + {$EXTERNALSYM ED_EDIT_SEEK_PREROLL} + ED_EDIT_SEEK_PREROLL_CT = ED_BASE+684; + {$EXTERNALSYM ED_EDIT_SEEK_PREROLL_CT} + ED_EDIT_SEEK_BOOKMARK = ED_BASE+685; + {$EXTERNALSYM ED_EDIT_SEEK_BOOKMARK} + ED_EDIT_OFFSET = ED_BASE+686; + {$EXTERNALSYM ED_EDIT_OFFSET} + ED_EDIT_PREREAD = ED_BASE+815; + {$EXTERNALSYM ED_EDIT_PREREAD} +// +// Some error codes: +// +// device could be in local mode + ED_ERR_DEVICE_NOT_READY = ED_BASE+700; + {$EXTERNALSYM ED_ERR_DEVICE_NOT_READY} + +// ************************************************** +// +// New constants added for implementation of DVCR +// +// ************************************************** + + +// +// New Device type (a DV has two subunits: camera and VCR) +// + ED_DEVTYPE_CAMERA = ED_BASE+900; + {$EXTERNALSYM ED_DEVTYPE_CAMERA} + + ED_DEVTYPE_TUNER = ED_BASE+901; + {$EXTERNALSYM ED_DEVTYPE_TUNER} + + ED_DEVTYPE_DVHS = ED_BASE+902; + {$EXTERNALSYM ED_DEVTYPE_DVHS} + + ED_DEVTYPE_UNKNOWN = ED_BASE+903; // Driver cannot determine the device type + {$EXTERNALSYM ED_DEVTYPE_UNKNOWN} + + ED_DEVTYPE_CAMERA_STORAGE = ED_BASE+1034; // Storage for digital still images, short video files, etc. + {$EXTERNALSYM ED_DEVTYPE_CAMERA_STORAGE} + + ED_DEVTYPE_DTV = ED_BASE+1035; // DTV with serial bus interface + {$EXTERNALSYM ED_DEVTYPE_DTV} + + ED_DEVTYPE_PC_VIRTUAL = ED_BASE+1036; // Emulated device (virtual) on a PC + {$EXTERNALSYM ED_DEVTYPE_PC_VIRTUAL} + + +// +// Unknownn capability +// Instead of return E_NOTIMPL, or S_OK with OAFALSE, it may return S_OK with _UNKNOWN +// + ED_CAPABILITY_UNKNOWN = ED_BASE+910; + {$EXTERNALSYM ED_CAPABILITY_UNKNOWN} + + +// +// Send raw 1394/AVC extenal device command via GetTransportBasicParameters() +// This is specifically for a 1394 AVC device connected with DEV_PORT_1394. +// + ED_RAW_EXT_DEV_CMD = ED_BASE+920; + {$EXTERNALSYM ED_RAW_EXT_DEV_CMD} + + +// +// MEDIUM INFO +// + ED_MEDIA_VHSC = ED_BASE+925; // New media type + {$EXTERNALSYM ED_MEDIA_VHSC} + ED_MEDIA_UNKNOWN = ED_BASE+926; // Unknown media + {$EXTERNALSYM ED_MEDIA_UNKNOWN} + ED_MEDIA_NOT_PRESENT = ED_BASE+927; + {$EXTERNALSYM ED_MEDIA_NOT_PRESENT} + + +// +// Device Control command that can result in pending state. +// + ED_CONTROL_HEVENT_GET = ED_BASE+928; // To get a sychronous event handle + {$EXTERNALSYM ED_CONTROL_HEVENT_GET} + ED_CONTROL_HEVENT_RELEASE = ED_BASE+929; // To release sychronous event handle must match what it got + {$EXTERNALSYM ED_CONTROL_HEVENT_RELEASE} + + ED_DEV_REMOVED_HEVENT_GET = ED_BASE+960; // To be a notify event and will be signal if device is removed. + {$EXTERNALSYM ED_DEV_REMOVED_HEVENT_GET} + ED_DEV_REMOVED_HEVENT_RELEASE = ED_BASE+961; // Release this event handle + {$EXTERNALSYM ED_DEV_REMOVED_HEVENT_RELEASE} + + +// +// TRANSPORT STATE +// + ED_NOTIFY_HEVENT_GET = ED_BASE+930; // To get a sychronous event handle + {$EXTERNALSYM ED_NOTIFY_HEVENT_GET} + ED_NOTIFY_HEVENT_RELEASE = ED_BASE+931; // To release sychronous event handle must match what it got + {$EXTERNALSYM ED_NOTIFY_HEVENT_RELEASE} + ED_MODE_CHANGE_NOTIFY = ED_BASE+932; // This is asynchronous operation, wait for event. + {$EXTERNALSYM ED_MODE_CHANGE_NOTIFY} + + ED_MODE_PLAY_FASTEST_FWD = ED_BASE+933; + {$EXTERNALSYM ED_MODE_PLAY_FASTEST_FWD} + ED_MODE_PLAY_SLOWEST_FWD = ED_BASE+934; + {$EXTERNALSYM ED_MODE_PLAY_SLOWEST_FWD} + ED_MODE_PLAY_FASTEST_REV = ED_BASE+935; + {$EXTERNALSYM ED_MODE_PLAY_FASTEST_REV} + ED_MODE_PLAY_SLOWEST_REV = ED_BASE+936; + {$EXTERNALSYM ED_MODE_PLAY_SLOWEST_REV} + + ED_MODE_WIND = ED_BASE+937; + {$EXTERNALSYM ED_MODE_WIND} + ED_MODE_REW_FASTEST = ED_BASE+938; // High speed rewind + {$EXTERNALSYM ED_MODE_REW_FASTEST} + + ED_MODE_REV_PLAY = ED_BASE+939; // x1 speed reverse play + {$EXTERNALSYM ED_MODE_REV_PLAY} + +// +// Additional play modes (added post Windows XP) +// + + ED_MODE_PLAY_SLOW_FWD_6 = ED_BASE+1001; // Slow forward + {$EXTERNALSYM ED_MODE_PLAY_SLOW_FWD_6} + ED_MODE_PLAY_SLOW_FWD_5 = ED_BASE+1002; + {$EXTERNALSYM ED_MODE_PLAY_SLOW_FWD_5} + ED_MODE_PLAY_SLOW_FWD_4 = ED_BASE+1003; + {$EXTERNALSYM ED_MODE_PLAY_SLOW_FWD_4} + ED_MODE_PLAY_SLOW_FWD_3 = ED_BASE+1004; + {$EXTERNALSYM ED_MODE_PLAY_SLOW_FWD_3} + ED_MODE_PLAY_SLOW_FWD_2 = ED_BASE+1005; + {$EXTERNALSYM ED_MODE_PLAY_SLOW_FWD_2} + ED_MODE_PLAY_SLOW_FWD_1 = ED_BASE+1006; + {$EXTERNALSYM ED_MODE_PLAY_SLOW_FWD_1} + + ED_MODE_PLAY_FAST_FWD_1 = ED_BASE+1007; // Fast forward + {$EXTERNALSYM ED_MODE_PLAY_FAST_FWD_1} + ED_MODE_PLAY_FAST_FWD_2 = ED_BASE+1008; + {$EXTERNALSYM ED_MODE_PLAY_FAST_FWD_2} + ED_MODE_PLAY_FAST_FWD_3 = ED_BASE+1009; + {$EXTERNALSYM ED_MODE_PLAY_FAST_FWD_3} + ED_MODE_PLAY_FAST_FWD_4 = ED_BASE+1010; + {$EXTERNALSYM ED_MODE_PLAY_FAST_FWD_4} + ED_MODE_PLAY_FAST_FWD_5 = ED_BASE+1011; + {$EXTERNALSYM ED_MODE_PLAY_FAST_FWD_5} + ED_MODE_PLAY_FAST_FWD_6 = ED_BASE+1012; + {$EXTERNALSYM ED_MODE_PLAY_FAST_FWD_6} + + ED_MODE_PLAY_SLOW_REV_6 = ED_BASE+1013; // Slow reverse + {$EXTERNALSYM ED_MODE_PLAY_SLOW_REV_6} + ED_MODE_PLAY_SLOW_REV_5 = ED_BASE+1014; + {$EXTERNALSYM ED_MODE_PLAY_SLOW_REV_5} + ED_MODE_PLAY_SLOW_REV_4 = ED_BASE+1015; + {$EXTERNALSYM ED_MODE_PLAY_SLOW_REV_4} + ED_MODE_PLAY_SLOW_REV_3 = ED_BASE+1016; + {$EXTERNALSYM ED_MODE_PLAY_SLOW_REV_3} + ED_MODE_PLAY_SLOW_REV_2 = ED_BASE+1017; + {$EXTERNALSYM ED_MODE_PLAY_SLOW_REV_2} + ED_MODE_PLAY_SLOW_REV_1 = ED_BASE+1018; + {$EXTERNALSYM ED_MODE_PLAY_SLOW_REV_1} + + ED_MODE_PLAY_FAST_REV_1 = ED_BASE+1019; // Fast reverse + {$EXTERNALSYM ED_MODE_PLAY_FAST_REV_1} + ED_MODE_PLAY_FAST_REV_2 = ED_BASE+1020; + {$EXTERNALSYM ED_MODE_PLAY_FAST_REV_2} + ED_MODE_PLAY_FAST_REV_3 = ED_BASE+1021; + {$EXTERNALSYM ED_MODE_PLAY_FAST_REV_3} + ED_MODE_PLAY_FAST_REV_4 = ED_BASE+1022; + {$EXTERNALSYM ED_MODE_PLAY_FAST_REV_4} + ED_MODE_PLAY_FAST_REV_5 = ED_BASE+1023; + {$EXTERNALSYM ED_MODE_PLAY_FAST_REV_5} + ED_MODE_PLAY_FAST_REV_6 = ED_BASE+1024; + {$EXTERNALSYM ED_MODE_PLAY_FAST_REV_6} + + ED_MODE_REVERSE = ED_MODE_REV_PLAY; // Same as Reverse playback + {$EXTERNALSYM ED_MODE_REVERSE} + ED_MODE_REVERSE_FREEZE = ED_BASE+1025; // Pause at reverse playback + {$EXTERNALSYM ED_MODE_REVERSE_FREEZE} + + ED_MODE_PLAY_SLOW_FWD_X = ED_BASE+1026; // Possible response for a trick play + {$EXTERNALSYM ED_MODE_PLAY_SLOW_FWD_X} + ED_MODE_PLAY_FAST_FWD_X = ED_BASE+1027; // Possible response for a trick play + {$EXTERNALSYM ED_MODE_PLAY_FAST_FWD_X} + ED_MODE_PLAY_SLOW_REV_X = ED_BASE+1028; // Possible response for a trick play + {$EXTERNALSYM ED_MODE_PLAY_SLOW_REV_X} + ED_MODE_PLAY_FAST_REV_X = ED_BASE+1029; // Possible response for a trick play + {$EXTERNALSYM ED_MODE_PLAY_FAST_REV_X} + + ED_MODE_STOP_START = ED_BASE+1030; // Indicate stopping at the begin of a tape + {$EXTERNALSYM ED_MODE_STOP_START} + ED_MODE_STOP_END = ED_BASE+1031; // Indicate stopping at the end of a tape + {$EXTERNALSYM ED_MODE_STOP_END} + ED_MODE_STOP_EMERGENCY = ED_BASE+1032; // Indicate stopping due to an emergency + {$EXTERNALSYM ED_MODE_STOP_EMERGENCY} + +// +// TRANSPOSRTBASIC: input and output signal +// + ED_TRANSBASIC_INPUT_SIGNAL = ED_BASE+940; + {$EXTERNALSYM ED_TRANSBASIC_INPUT_SIGNAL} + ED_TRANSBASIC_OUTPUT_SIGNAL = ED_BASE+941; + {$EXTERNALSYM ED_TRANSBASIC_OUTPUT_SIGNAL} + + ED_TRANSBASIC_SIGNAL_525_60_SD = ED_BASE+942; + {$EXTERNALSYM ED_TRANSBASIC_SIGNAL_525_60_SD} + ED_TRANSBASIC_SIGNAL_525_60_SDL = ED_BASE+943; + {$EXTERNALSYM ED_TRANSBASIC_SIGNAL_525_60_SDL} + ED_TRANSBASIC_SIGNAL_625_50_SD = ED_BASE+944; + {$EXTERNALSYM ED_TRANSBASIC_SIGNAL_625_50_SD} + ED_TRANSBASIC_SIGNAL_625_50_SDL = ED_BASE+945; + {$EXTERNALSYM ED_TRANSBASIC_SIGNAL_625_50_SDL} + ED_TRANSBASIC_SIGNAL_MPEG2TS = ED_BASE+946; + {$EXTERNALSYM ED_TRANSBASIC_SIGNAL_MPEG2TS} + ED_TRANSBASIC_SIGNAL_625_60_HD = ED_BASE+947; + {$EXTERNALSYM ED_TRANSBASIC_SIGNAL_625_60_HD} + ED_TRANSBASIC_SIGNAL_625_50_HD = ED_BASE+948; + {$EXTERNALSYM ED_TRANSBASIC_SIGNAL_625_50_HD} + + ED_TRANSBASIC_SIGNAL_2500_60_MPEG = ED_BASE+980; + {$EXTERNALSYM ED_TRANSBASIC_SIGNAL_2500_60_MPEG} + ED_TRANSBASIC_SIGNAL_1250_60_MPEG = ED_BASE+981; + {$EXTERNALSYM ED_TRANSBASIC_SIGNAL_1250_60_MPEG} + ED_TRANSBASIC_SIGNAL_0625_60_MPEG = ED_BASE+982; + {$EXTERNALSYM ED_TRANSBASIC_SIGNAL_0625_60_MPEG} + + ED_TRANSBASIC_SIGNAL_2500_50_MPEG = ED_BASE+985; + {$EXTERNALSYM ED_TRANSBASIC_SIGNAL_2500_50_MPEG} + ED_TRANSBASIC_SIGNAL_1250_50_MPEG = ED_BASE+986; + {$EXTERNALSYM ED_TRANSBASIC_SIGNAL_1250_50_MPEG} + ED_TRANSBASIC_SIGNAL_0625_50_MPEG = ED_BASE+987; + {$EXTERNALSYM ED_TRANSBASIC_SIGNAL_0625_50_MPEG} + + ED_TRANSBASIC_SIGNAL_UNKNOWN = ED_BASE+990; + {$EXTERNALSYM ED_TRANSBASIC_SIGNAL_UNKNOWN} + + ED_TRANSBASIC_SIGNAL_525_60_DV25 = ED_BASE+991; + {$EXTERNALSYM ED_TRANSBASIC_SIGNAL_525_60_DV25} + ED_TRANSBASIC_SIGNAL_625_50_DV25 = ED_BASE+992; + {$EXTERNALSYM ED_TRANSBASIC_SIGNAL_625_50_DV25} + + ED_TRANSBASIC_SIGNAL_525_60_DV50 = ED_BASE+993; + {$EXTERNALSYM ED_TRANSBASIC_SIGNAL_525_60_DV50} + ED_TRANSBASIC_SIGNAL_625_50_DV50 = ED_BASE+994; + {$EXTERNALSYM ED_TRANSBASIC_SIGNAL_625_50_DV50} + + ED_TRANSBASIC_SIGNAL_HD_60_DVH1 = ED_BASE+995; // DVCPRO 100: 1080i or 720p + {$EXTERNALSYM ED_TRANSBASIC_SIGNAL_HD_60_DVH1} + ED_TRANSBASIC_SIGNAL_HD_50_DVH1 = ED_BASE+996; // DVCPRO 100: 1080i only + {$EXTERNALSYM ED_TRANSBASIC_SIGNAL_HD_50_DVH1} + + +// +// TIMECODE/AbsoluteTrackNumber/RealTimeCounter read/seek/write +// + ED_DEVCAP_TIMECODE_SEEK = ED_BASE+950; + {$EXTERNALSYM ED_DEVCAP_TIMECODE_SEEK} + + ED_DEVCAP_ATN_READ = ED_BASE+951; + {$EXTERNALSYM ED_DEVCAP_ATN_READ} + ED_DEVCAP_ATN_SEEK = ED_BASE+952; + {$EXTERNALSYM ED_DEVCAP_ATN_SEEK} + ED_DEVCAP_ATN_WRITE = ED_BASE+953; + {$EXTERNALSYM ED_DEVCAP_ATN_WRITE} + + ED_DEVCAP_RTC_READ = ED_BASE+954; + {$EXTERNALSYM ED_DEVCAP_RTC_READ} + ED_DEVCAP_RTC_SEEK = ED_BASE+955; + {$EXTERNALSYM ED_DEVCAP_RTC_SEEK} + ED_DEVCAP_RTC_WRITE = ED_BASE+956; + {$EXTERNALSYM ED_DEVCAP_RTC_WRITE} + +// +// Basic parameter +// + ED_TIMEREF_ATN = ED_BASE+958; + {$EXTERNALSYM ED_TIMEREF_ATN} + +// +// GUID used to identify a class driver +// + MSTapeDeviceGUID : TGUID = '{8C0F6AF2-0EDB-44c1-8AEB-59040BD830ED}'; // MSTapeDeviceGUID + {$EXTERNALSYM MSTapeDeviceGUID} + +(*==========================================================================; + * + * Copyright (C) 1996-1997 Microsoft Corporation. All Rights Reserved. + * + * File: aviriff.h + * + ***************************************************************************) + +type +(*+ + * + * Structures and defines for the RIFF AVI file format extended to + * handle very large/long files + * + *-=====================================================================*) + + { +#if !defined NUMELMS + #define NUMELMS(aa) (sizeof(aa)/sizeof((aa)[0])) +#endif + } +// all structures in this file are packed on word boundaries +// +(* + * heres the general layout of an AVI riff file (new format) + * + * RIFF (3F??????) AVI <- not more than 1 GB in size + * LIST (size) hdrl + * avih (0038) + * LIST (size) strl + * strh (0038) + * strf (????) + * indx (3ff8) <- size may vary, should be sector sized + * LIST (size) strl + * strh (0038) + * strf (????) + * indx (3ff8) <- size may vary, should be sector sized + * LIST (size) odml + * dmlh (????) + * JUNK (size) <- fill to align to sector - 12 + * LIST (7f??????) movi <- aligned on sector - 12 + * 00dc (size) <- sector aligned + * 01wb (size) <- sector aligned + * ix00 (size) <- sector aligned + * idx1 (00??????) <- sector aligned + * RIFF (7F??????) AVIX + * JUNK (size) <- fill to align to sector -12 + * LIST (size) movi + * 00dc (size) <- sector aligned + * RIFF (7F??????) AVIX <- not more than 2GB in size + * JUNK (size) <- fill to align to sector - 12 + * LIST (size) movi + * 00dc (size) <- sector aligned + * + *-===================================================================*) + +// +// structures for manipulating RIFF headers +// +{ +#define FCC(ch4) ((((DWORD)(ch4) & 0xFF) << 24) | \ + (((DWORD)(ch4) & 0xFF00) << 8) | \ + (((DWORD)(ch4) & 0xFF0000) >> 8) | \ + (((DWORD)(ch4) & 0xFF000000) >> 24)) +} + PRIFFChunk = ^TRIFFChunk; + _riffchunk = record + fcc: FOURCC; + cb: DWORD; + end; + {$EXTERNALSYM _riffchunk} + RIFFCHUNK = _riffchunk; + {$EXTERNALSYM RIFFCHUNK} + LPRIFFCHUNK = ^RIFFCHUNK; + {$EXTERNALSYM LPRIFFCHUNK} + TRIFFChunk = _riffchunk; + + PRIFFList = ^TRIFFList; + _rifflist = record + fcc: FOURCC; + cb: DWORD; + fccListType: FOURCC; + end; + {$EXTERNALSYM _rifflist} + RIFFLIST = _rifflist; + {$EXTERNALSYM RIFFLIST} + LPRIFFLIST = ^RIFFLIST; + {$EXTERNALSYM LPRIFFLIST} + TRIFFList = _rifflist; + +{ +#define RIFFROUND(cb) ((cb) + ((cb)&1)) +#define RIFFNEXT(pChunk) (LPRIFFCHUNK)((LPBYTE)(pChunk) \ + + sizeof(RIFFCHUNK) \ + + RIFFROUND(((LPRIFFCHUNK)pChunk)->cb)) + +} +// +// ==================== avi header structures =========================== +// + +// main header for the avi file (compatibility header) +const + ckidMAINAVIHEADER = $68697661;// 'avih' + {$EXTERNALSYM ckidMAINAVIHEADER} + +type + _avimainheader = record + fcc: FOURCC; // 'avih' + cb: DWORD; // size of this structure -8 + dwMicroSecPerFrame: DWORD; // frame display rate (or 0L) + dwMaxBytesPerSec: DWORD; // max. transfer rate + dwPaddingGranularity: DWORD; // pad to multiples of this size; normally 2K. + dwFlags: DWORD; // the ever-present flags + dwTotalFrames: DWORD; // # frames in first movi list + dwInitialFrames: DWORD; + dwStreams: DWORD; + dwSuggestedBufferSize: DWORD; + dwWidth: DWORD; + dwHeight: DWORD; + dwReserved: array[0..3] of DWORD; + end; + {$EXTERNALSYM _avimainheader} + AVIMAINHEADER = _avimainheader; + {$EXTERNALSYM AVIMAINHEADER} + TAVIMainHeader = _avimainheader; + +const + AVIF_HASINDEX = $00000010; // Index at end of file? + {$EXTERNALSYM AVIF_HASINDEX} + AVIF_MUSTUSEINDEX = $00000020; + {$EXTERNALSYM AVIF_MUSTUSEINDEX} + AVIF_ISINTERLEAVED = $00000100; + {$EXTERNALSYM AVIF_ISINTERLEAVED} + AVIF_TRUSTCKTYPE = $00000800; // Use CKType to find key frames + {$EXTERNALSYM AVIF_TRUSTCKTYPE} + AVIF_WASCAPTUREFILE = $00010000; + {$EXTERNALSYM AVIF_WASCAPTUREFILE} + AVIF_COPYRIGHTED = $00020000; + {$EXTERNALSYM AVIF_COPYRIGHTED} + + ckidODML = $6C6D646F; //'odml' + {$EXTERNALSYM ckidODML} + ckidAVIEXTHEADER = $686C6D64; //'dmlh' + {$EXTERNALSYM ckidAVIEXTHEADER} + +type + _aviextheader = record + fcc: FOURCC; // 'dmlh' + cb: DWORD; // size of this structure -8 + dwGrandFrames: DWORD; // total number of frames in the file + dwFuture: array[0..60] of DWORD; // to be defined later + end; + {$EXTERNALSYM _aviextheader} + AVIEXTHEADER = _aviextheader; + {$EXTERNALSYM AVIEXTHEADER} + TAVIExtHeader = _aviextheader; + +// +// structure of an AVI stream header riff chunk +// +const + ckidSTREAMLIST = $6C727473; //'strl' + {$EXTERNALSYM ckidSTREAMLIST} + ckidSTREAMHEADER = $68727473; //'strh' + {$EXTERNALSYM ckidSTREAMHEADER} + +type + _avistreamheader = record + fcc: FOURCC; // 'strh' + cb: DWORD; // size of this structure - 8 + + fccType: FOURCC; // stream type codes + + fccHandler: FOURCC; + dwFlags: DWORD; + + wPriority: WORD; + wLanguage: WORD; + dwInitialFrames: DWORD; + dwScale: DWORD; + dwRate: DWORD; // dwRate/dwScale is stream tick rate in ticks/sec + dwStart: DWORD; + dwLength: DWORD; + dwSuggestedBufferSize: DWORD; + dwQuality: DWORD; + dwSampleSize: DWORD; + + rcFrame: record + left: SmallInt; + top: SmallInt; + right: SmallInt; + bottom: SmallInt; + end; + end; + {$EXTERNALSYM _avistreamheader} + AVISTREAMHEADER = _avistreamheader; + {$EXTERNALSYM AVISTREAMHEADER} + TAVIStreamHeader = _avistreamheader; + +const + + streamtypeVIDEO = $73646976; //'vids' + {$EXTERNALSYM streamtypeVIDEO} + streamtypeAUDIO = $73647561; //'auds' + {$EXTERNALSYM streamtypeAUDIO} + streamtypeMIDI = $7364696D; //'mids' + {$EXTERNALSYM streamtypeMIDI} + streamtypeTEXT = $73747874; //'txts' + {$EXTERNALSYM streamtypeTEXT} + + AVISF_DISABLED = $00000001; + {$EXTERNALSYM AVISF_DISABLED} + AVISF_VIDEO_PALCHANGES = $00010000; + {$EXTERNALSYM AVISF_VIDEO_PALCHANGES} + +// +// structure of an AVI stream format chunk +// + + ckidSTREAMFORMAT = $66727473; //'strf' + {$EXTERNALSYM ckidSTREAMFORMAT} + +// +// avi stream formats are different for each stream type +// +// BITMAPINFOHEADER for video streams +// WAVEFORMATEX or PCMWAVEFORMAT for audio streams +// nothing for text streams +// nothing for midi streams + + +// +// structure of old style AVI index +// + ckidAVIOLDINDEX = $31786469;//'idx1' + {$EXTERNALSYM ckidAVIOLDINDEX} + +type + _avioldindex = record + fcc: FOURCC; // 'idx1' + cb: DWORD; // size of this structure -8 + + aIndex: array[0..0] of record + dwChunkId: DWORD; + dwFlags: DWORD; + dwOffset: DWORD; // offset of riff chunk header for the data + dwSize: DWORD; // size of the data (excluding riff header size) + end; // size of this array + end; + {$EXTERNALSYM _avioldindex} + AVIOLDINDEX = _avioldindex; + {$EXTERNALSYM AVIOLDINDEX} + TAVIOldIndex = _avioldindex; + +const + AVIIF_LIST = $00000001; + {$EXTERNALSYM AVIIF_LIST} + AVIIF_KEYFRAME = $00000010; + {$EXTERNALSYM AVIIF_KEYFRAME} + + AVIIF_NO_TIME = $00000100; + {$EXTERNALSYM AVIIF_NO_TIME} + AVIIF_COMPRESSOR = $0FFF0000; // unused? + {$EXTERNALSYM AVIIF_COMPRESSOR} + + +// old timecode structure +//typedef union _timecode { +// struct { +// WORD wFrameRate; +// WORD wFrameFract; +// LONG cFrames; +// }; +// DWORDLONG qw; +// } TIMECODE; +// +// struct for all the SMPTE timecode info +// + TIMECODE_RATE_30DROP = 0; // this MUST be zero + {$EXTERNALSYM TIMECODE_RATE_30DROP} + +type + _timecodedata = record + time: TTimeCode; + dwSMPTEflags: DWORD; + dwUser: DWORD; + end; + {$EXTERNALSYM _timecodedata} + TIMECODEDATA = _timecodedata; + {$EXTERNALSYM TIMECODEDATA} + TTimeCodeData = _timecodedata; + +// dwSMPTEflags masks/values +// +const + TIMECODE_SMPTE_BINARY_GROUP = $07; + {$EXTERNALSYM TIMECODE_SMPTE_BINARY_GROUP} + TIMECODE_SMPTE_COLOR_FRAME = $08; + {$EXTERNALSYM TIMECODE_SMPTE_COLOR_FRAME} + +// +// ============ structures for new style AVI indexes ================= +// + +// index type codes +// + AVI_INDEX_OF_INDEXES = $00; + {$EXTERNALSYM AVI_INDEX_OF_INDEXES} + AVI_INDEX_OF_CHUNKS = $01; + {$EXTERNALSYM AVI_INDEX_OF_CHUNKS} + AVI_INDEX_OF_TIMED_CHUNKS = $02; + {$EXTERNALSYM AVI_INDEX_OF_TIMED_CHUNKS} + AVI_INDEX_OF_SUB_2FIELD = $03; + {$EXTERNALSYM AVI_INDEX_OF_SUB_2FIELD} + AVI_INDEX_IS_DATA = $80; + {$EXTERNALSYM AVI_INDEX_IS_DATA} + +// index subtype codes +// + AVI_INDEX_SUB_DEFAULT = $00; + {$EXTERNALSYM AVI_INDEX_SUB_DEFAULT} + +// INDEX_OF_CHUNKS subtype codes +// + AVI_INDEX_SUB_2FIELD = $01; + {$EXTERNALSYM AVI_INDEX_SUB_2FIELD} + +// meta structure of all avi indexes +// +type + _avimetaindex = record + fcc: FOURCC; + cb: UINT; + wLongsPerEntry: WORD; + bIndexSubType: BYTE; + bIndexType: BYTE; + nEntriesInUse: DWORD; + dwChunkId: DWORD; + dwReserved: array[0..2] of DWORD; + adwIndex: array[0..0] of DWORD; + end; + {$EXTERNALSYM _avimetaindex} + AVIMETAINDEX = _avimetaindex; + {$EXTERNALSYM AVIMETAINDEX} + TAVIMetaIndex = _avimetaindex; + + +const + STDINDEXSIZE = $4000; + {$EXTERNALSYM STDINDEXSIZE} +{ +#define NUMINDEX(wLongsPerEntry) ((STDINDEXSIZE-32)/4/(wLongsPerEntry)) +#define NUMINDEXFILL(wLongsPerEntry) ((STDINDEXSIZE/4) - NUMINDEX(wLongsPerEntry)) +} +// structure of a super index (INDEX_OF_INDEXES) +// + ckidAVISUPERINDEX = $78646E69;//'indx' + {$EXTERNALSYM ckidAVISUPERINDEX} + +type + _avisuperindex = record + fcc: FOURCC; // 'indx' + cb: UINT; // size of this structure + wLongsPerEntry: WORD; // ==4 + bIndexSubType: BYTE; // ==0 (frame index) or AVI_INDEX_SUB_2FIELD + bIndexType: BYTE; // ==AVI_INDEX_OF_INDEXES + nEntriesInUse: DWORD; // offset of next unused entry in aIndex + dwChunkId: DWORD; // chunk ID of chunks being indexed, (i.e. RGB8) + dwReserved: array[0..2] of DWORD; // must be 0 + + aIndex: array[0..3] of record + qwOffset: Int64; // 64 bit offset to sub index chunk + dwSize: DWORD; // 32 bit size of sub index chunk + dwDuration: DWORD; // time span of subindex chunk (in stream ticks) + end; + end; + {$EXTERNALSYM _avisuperindex} + AVISUPERINDEX = _avisuperindex; + {$EXTERNALSYM AVISUPERINDEX} + TAVISuperIndex = _avisuperindex; + +//#define Valid_SUPERINDEX(pi) (*(DWORD *)(&((pi)->wLongsPerEntry)) == (4 | (AVI_INDEX_OF_INDEXES << 24))) + +// struct of a standard index (AVI_INDEX_OF_CHUNKS) +// + + _avistdindex_entry = record + dwOffset: DWORD; // 32 bit offset to data (points to data, not riff header) + dwSize: DWORD; // 31 bit size of data (does not include size of riff header), bit 31 is deltaframe bit + end; + {$EXTERNALSYM _avistdindex_entry} + AVISTDINDEX_ENTRY = _avistdindex_entry; + {$EXTERNALSYM AVISTDINDEX_ENTRY} + TAVIStdIndexEntry = _avistdindex_entry; + +const + AVISTDINDEX_DELTAFRAME = $80000000; // Delta frames have the high bit set; + {$EXTERNALSYM AVISTDINDEX_DELTAFRAME} + AVISTDINDEX_SIZEMASK = not $80000000; + {$EXTERNALSYM AVISTDINDEX_SIZEMASK} + +type + _avistdindex = record + fcc: FOURCC; // 'indx' or '##ix' + cb: UINT; // size of this structure + wLongsPerEntry: WORD; // ==2 + bIndexSubType: BYTE; // ==0 + bIndexType: BYTE; // ==AVI_INDEX_OF_CHUNKS + nEntriesInUse: DWORD; // offset of next unused entry in aIndex + dwChunkId: DWORD; // chunk ID of chunks being indexed, (i.e. RGB8) + qwBaseOffset: Int64; // base offset that all index intries are relative to + dwReserved_3: DWORD; + aIndex: array[0..2043] of TAVIStdIndexEntry; + end; + {$EXTERNALSYM _avistdindex} + AVISTDINDEX = _avistdindex; + {$EXTERNALSYM AVISTDINDEX} + TAVIStdIndex = _avistdindex; + +// struct of a time variant standard index (AVI_INDEX_OF_TIMED_CHUNKS) +// + _avitimedindex_entry = record + dwOffset: DWORD; // 32 bit offset to data (points to data, not riff header) + dwSize: DWORD; // 31 bit size of data (does not include size of riff header) (high bit is deltaframe bit) + dwDuration: DWORD; // how much time the chunk should be played (in stream ticks) + end; + {$EXTERNALSYM _avitimedindex_entry} + AVITIMEDINDEX_ENTRY = _avitimedindex_entry; + {$EXTERNALSYM AVITIMEDINDEX_ENTRY} + TAVITimedIndexEntry = _avitimedindex_entry; + + _avitimedindex = record + fcc: FOURCC; // 'indx' or '##ix' + cb: UINT; // size of this structure + wLongsPerEntry: WORD; // ==3 + bIndexSubType: BYTE; // ==0 + bIndexType: BYTE; // ==AVI_INDEX_OF_TIMED_CHUNKS + nEntriesInUse: DWORD; // offset of next unused entry in aIndex + dwChunkId: DWORD; // chunk ID of chunks being indexed, (i.e. RGB8) + qwBaseOffset: Int64; // base offset that all index intries are relative to + dwReserved_3: DWORD; // must be 0 + aIndex: array[0..1361] of TAVITimedIndexEntry; + adwTrailingFill: array[0..2733] of DWORD; // to align struct to correct size + end; + {$EXTERNALSYM _avitimedindex} + AVITIMEDINDEX = _avitimedindex; + {$EXTERNALSYM AVITIMEDINDEX} + TAVITimedIndex = _avitimedindex; + +// structure of a timecode stream +// + _avitimecodeindex = record + fcc: FOURCC; // 'indx' or '##ix' + cb: UINT; // size of this structure + wLongsPerEntry: WORD; // ==4 + bIndexSubType: BYTE; // ==0 + bIndexType: BYTE; // ==AVI_INDEX_IS_DATA + nEntriesInUse: DWORD; // offset of next unused entry in aIndex + dwChunkId: DWORD; // 'time' + dwReserved: array[0..2] of DWORD; // must be 0 + aIndex: array[0..0] of TTimeCodeData; + end; + {$EXTERNALSYM _avitimecodeindex} + AVITIMECODEINDEX = _avitimecodeindex; + {$EXTERNALSYM AVITIMECODEINDEX} + TAviTimeCodeIndex = _avitimecodeindex; + +// structure of a timecode discontinuity list (when wLongsPerEntry == 7) +// + _avitcdlindex_entry = record + dwTick: DWORD; // stream tick time that maps to this timecode value + time: TTimeCode; + dwSMPTEflags: DWORD; + dwUser: DWORD; + szReelId: array[0..11] of Char; + end; + {$EXTERNALSYM _avitcdlindex_entry} + AVITCDLINDEX_ENTRY = _avitcdlindex_entry; + {$EXTERNALSYM AVITCDLINDEX_ENTRY} + TAVITcdlIndexEntry = _avitcdlindex_entry; + + _avitcdlindex = record + fcc: FOURCC; // 'indx' or '##ix' + cb: UINT; // size of this structure + wLongsPerEntry: WORD; // ==7 (must be 4 or more all 'tcdl' indexes + bIndexSubType: BYTE; // ==0 + bIndexType: BYTE; // ==AVI_INDEX_IS_DATA + nEntriesInUse: DWORD; // offset of next unused entry in aIndex + dwChunkId: DWORD; // 'tcdl' + dwReserved: array[0..2] of DWORD; // must be 0 + aIndex: array[0..583] of TAVITcdlIndexEntry; + adwTrailingFill: array[0..3511] of DWORD; // to align struct to correct size + end; + {$EXTERNALSYM _avitcdlindex} + AVITCDLINDEX = _avitcdlindex; + {$EXTERNALSYM AVITCDLINDEX} + TAVITcdlIndex = _avitcdlindex; + + + _avifieldindex_chunk = record + {$EXTERNALSYM _avifieldindex_chunk} + fcc: FOURCC; // 'ix##' + cb: DWORD; // size of this structure + wLongsPerEntry: WORD; // must be 3 (size of each entry in + // aIndex array) + bIndexSubType: BYTE; // AVI_INDEX_2FIELD + bIndexType: BYTE; // AVI_INDEX_OF_CHUNKS + nEntriesInUse: DWORD; // + dwChunkId: DWORD; // '##dc' or '##db' + qwBaseOffset: Int64; // offsets in aIndex array are relative to this + dwReserved3: DWORD; // must be 0 + + aIndex: array[0..0] of record + dwOffset: DWORD; + dwSize: DWORD; // size of all fields + dwOffsetField2: DWORD; // (bit 31 set for NON-keyframes) + end; // offset to second field + end; + AVIFIELDINDEX = _avifieldindex_chunk; + {$EXTERNALSYM AVIFIELDINDEX} + PAVIFIELDINDEX = ^AVIFIELDINDEX; + {$EXTERNALSYM PAVIFIELDINDEX} + TAVIFieldIndex = _avifieldindex_chunk; + +(*==========================================================================; + * + * Copyright (C) 1996-1997 Microsoft Corporation. All Rights Reserved. + * + * File: evcode.h + * + ***************************************************************************) + +const +// +// list of standard Quartz event codes and the expected params +// + +// Event codes are broken into two groups +// -- system event codes +// -- extension event codes +// All system event codes are below EC_USER + + EC_SYSTEMBASE = $00; + {$EXTERNALSYM EC_SYSTEMBASE} + EC_USER = $8000; + {$EXTERNALSYM EC_USER} + + +// System-defined event codes +// ========================== +// +// There are three types of system-defined event codes: +// +// 1. Those which are always passed through to the application +// (To be collected by calls to GetEvent or within WaitForCompletion.) +// (e.g. EC_ERRORABORT, EC_USERABORT.) +// +// 2. Those which are pure internal and will never be passed to +// the application. (e.g. EC_SHUTDOWN) +// +// 3. Those which have default handling. Default handing implies that +// the event is not passed to the application. However, default +// handling may be canceled by calling +// IMediaEvent::CancelDefaultHandling. If the default handling is +// cancelled in this way, then the message will be delivered to the +// application and the application must action it appropriately. +// Default handling can be restored by calling RestoreDefaultHandling. +// +// We will refer to these events as application, internal and defaulted +// events respectively. +// +// System-defined events may have interface pointers, BSTR's, etc passed +// as parameters. It is therefore essential that, for any message +// retrieved using GetEvent, a matching call to FreeEventParams is made +// to ensure that relevant interfaces are released and storage freed. +// Failure to call FreeEventParams will result in memory leaks, if not +// worse. +// +// Filters sending these messages to the filter graph should not AddRef() +// any interfaces that they may pass as parameters. The filter graph +// manager will AddRef them if required. E.g. if the event is to be queued +// for the application or queued to a worker thread. + +// Each event listed below is immediately followed by a parameter list +// detailing the types of the parameters associated with the message, +// and an indication of whether the message is an application, internal +// or defaulted message. This is then followed by a short description. +// The use of "void" in the parameter list implies that the parameter is not +// used. Such parameters should be zero. + +// Other defined EC_ regions: +// DVD event codes 0x0100 - 0x0150 (dvdevcod.h) +// audio device event codes 0x0200 - 0x0250 (audevcod.h) +// WindowsMedia SDK-originated events 0x0251 - 0x0300 (see below) +// MSVIDCTL 0x0301 - 0x0325 (msvidctl.idl) +// stream buffer engine (PVR) 0x0326 - 0x0350 (sbe.idl) + + EC_COMPLETE = $01; + {$EXTERNALSYM EC_COMPLETE} +// ( HResult, void ) : defaulted (special) +// Signals the completed playback of a stream within the graph. This message +// is sent by renderers when they receive end-of-stream. The default handling +// of this message results in a _SINGLE_ EC_COMPLETE being sent to the +// application when ALL of the individual renderers have signaled EC_COMPLETE +// to the filter graph. If the default handing is canceled, the application +// will see all of the individual EC_COMPLETEs. + + + EC_USERABORT = $02; + {$EXTERNALSYM EC_USERABORT} +// ( void, void ) : application +// In some sense, the user has requested that playback be terminated. +// This message is typically sent by renderers that render into a +// window if the user closes the window into which it was rendering. +// It is up to the application to decide if playback should actually +// be stopped. + + + EC_ERRORABORT = $03; + {$EXTERNALSYM EC_ERRORABORT} +// ( HResult, void ) : application +// Operation aborted because of error + + + EC_TIME = $04; + {$EXTERNALSYM EC_TIME} +// ( DWORD, DWORD ) : application +// The requested reference time occurred. (This event is currently not used). +// lParam1 is low dword of ref time, lParam2 is high dword of TRefTime. + + + EC_REPAINT = $05; + {$EXTERNALSYM EC_REPAINT} +// ( IPin * (could be NULL), void ) : defaulted +// A repaint is required - lParam1 contains the (IPin *) that needs the data +// to be sent again. Default handling is: if the output pin which the IPin is +// attached to supports the IMediaEventSink interface then it will be called +// with the EC_REPAINT first. If that fails then normal repaint processing is +// done by the filter graph. + + +// Stream error notifications + EC_STREAM_ERROR_STOPPED = $06; + {$EXTERNALSYM EC_STREAM_ERROR_STOPPED} + EC_STREAM_ERROR_STILLPLAYING = $07; + {$EXTERNALSYM EC_STREAM_ERROR_STILLPLAYING} +// ( HResult, DWORD ) : application +// lParam 1 is major code, lParam2 is minor code, either may be zero. + + + EC_ERROR_STILLPLAYING = $08; + {$EXTERNALSYM EC_ERROR_STILLPLAYING} +// ( HResult, void ) : application +// The filter graph manager may issue Run's to the graph asynchronously. +// If such a Run fails, EC_ERROR_STILLPLAYING is issued to notify the +// application of the failure. The state of the underlying filters +// at such a time will be indeterminate - they will all have been asked +// to run, but some are almost certainly not. + + + EC_PALETTE_CHANGED = $09; + {$EXTERNALSYM EC_PALETTE_CHANGED} +// ( void, void ) : application +// notify application that the video palette has changed + + + EC_VIDEO_SIZE_CHANGED = $0A; + {$EXTERNALSYM EC_VIDEO_SIZE_CHANGED} +// ( DWORD, void ) : application +// Sent by video renderers. +// Notifies the application that the native video size has changed. +// LOWORD of the DWORD is the new width, HIWORD is the new height. + + + EC_QUALITY_CHANGE = $0B; + {$EXTERNALSYM EC_QUALITY_CHANGE} +// ( void, void ) : application +// Notify application that playback degradation has occurred + + + EC_SHUTTING_DOWN = $0C; + {$EXTERNALSYM EC_SHUTTING_DOWN} +// ( void, void ) : internal +// This message is sent by the filter graph manager to any plug-in +// distributors which support IMediaEventSink to notify them that +// the filter graph is starting to shutdown. + + + EC_CLOCK_CHANGED = $0D; + {$EXTERNALSYM EC_CLOCK_CHANGED} +// ( void, void ) : application +// Notify application that the clock has changed. +// (i.e. SetSyncSource has been called on the filter graph and has been +// distributed successfully to the filters in the graph.) + + EC_PAUSED = $0E; + {$EXTERNALSYM EC_PAUSED} +// ( HResult, void ) : application +// Notify application the previous pause request has completed + + EC_OPENING_FILE = $10; + {$EXTERNALSYM EC_OPENING_FILE} + EC_BUFFERING_DATA = $11; + {$EXTERNALSYM EC_BUFFERING_DATA} +// ( BOOL, void ) : application +// lParam1 == 1 --> starting to open file or buffer data +// lParam1 == 0 --> not opening or buffering any more +// (This event does not appear to be used by ActiveMovie.) + + + EC_FULLSCREEN_LOST = $12; + {$EXTERNALSYM EC_FULLSCREEN_LOST} +// ( void, IBaseFilter * ) : application +// Sent by full screen renderers when switched away from full screen. +// IBaseFilter may be NULL. + + + EC_ACTIVATE = $13; + {$EXTERNALSYM EC_ACTIVATE} +// ( BOOL, IBaseFilter * ) : internal +// Sent by video renderers when they lose or gain activation. +// lParam1 is set to 1 if gained or 0 if lost +// lParam2 is the IBaseFilter* for the filter that is sending the message +// Used for sound follows focus and full-screen switching + + + EC_NEED_RESTART = $14; + {$EXTERNALSYM EC_NEED_RESTART} +// ( void, void ) : defaulted +// Sent by renderers when they regain a resource (e.g. audio renderer). +// Causes a restart by Pause/put_Current/Run (if running). + + + EC_WINDOW_DESTROYED = $15; + {$EXTERNALSYM EC_WINDOW_DESTROYED} +// ( IBaseFilter *, void ) : internal +// Sent by video renderers when the window has been destroyed. Handled +// by the filter graph / distributor telling the resource manager. +// lParam1 is the IBaseFilter* of the filter whose window is being destroyed + + + EC_DISPLAY_CHANGED = $16; + {$EXTERNALSYM EC_DISPLAY_CHANGED} +// ( IPin *, void ) : internal +// Sent by renderers when they detect a display change. the filter graph +// will arrange for the graph to be stopped and the pin send in lParam1 +// to be reconnected. by being reconnected it allows a renderer to reset +// and connect with a more appropriate format for the new display mode +// lParam1 contains an (IPin *) that should be reconnected by the graph + + + EC_STARVATION = $17; + {$EXTERNALSYM EC_STARVATION} +// ( void, void ) : defaulted +// Sent by a filter when it detects starvation. Default handling (only when +// running) is for the graph to be paused until all filters enter the +// paused state and then run. Normally this would be sent by a parser or source +// filter when too little data is arriving. + + + EC_OLE_EVENT = $18; + {$EXTERNALSYM EC_OLE_EVENT} +// ( BSTR, BSTR ) : application +// Sent by a filter to pass a text string to the application. +// Conventionally, the first string is a type, and the second a parameter. + + + EC_NOTIFY_WINDOW = $19; + {$EXTERNALSYM EC_NOTIFY_WINDOW} +// ( HWND, void ) : internal +// Pass the window handle around during pin connection. + + EC_STREAM_CONTROL_STOPPED = $1A; + {$EXTERNALSYM EC_STREAM_CONTROL_STOPPED} +// ( IPin * pSender, DWORD dwCookie ) +// Notification that an earlier call to IAMStreamControl::StopAt +// has now take effect. Calls to the method can be marked +// with a cookie which is passed back in the second parameter, +// allowing applications to easily tie together request +// and completion notifications. +// +// NB: IPin will point to the pin that actioned the Stop. This +// may not be the pin that the StopAt was sent to. + + EC_STREAM_CONTROL_STARTED = $1B; + {$EXTERNALSYM EC_STREAM_CONTROL_STARTED} +// ( IPin * pSender, DWORD dwCookie ) +// Notification that an earlier call to IAMStreamControl::StartAt +// has now take effect. Calls to the method can be marked +// with a cookie which is passed back in the second parameter, +// allowing applications to easily tie together request +// and completion notifications. +// +// NB: IPin will point to the pin that actioned the Start. This +// may not be the pin that the StartAt was sent to. + + EC_END_OF_SEGMENT = $1C; + {$EXTERNALSYM EC_END_OF_SEGMENT} +// +// ( const REFERENCE_TIME *pStreamTimeAtEndOfSegment, DWORD dwSegmentNumber ) +// +// pStreamTimeAtEndOfSegment +// pointer to the accumulated stream clock +// time since the start of the segment - this is directly computable +// as the sum of the previous and current segment durations (Stop - Start) +// and the rate applied to each segment +// The source add this time to the time within each segment to get +// a total elapsed time +// +// dwSegmentNumber +// Segment number - starts at 0 +// +// Notifies that a segment end has been reached when the +// AM_SEEKING_Segment flags was set for IMediaSeeking::SetPositions +// Passes in an IMediaSeeking interface to allow the next segment +// to be defined by the application + + EC_SEGMENT_STARTED = $1D; + {$EXTERNALSYM EC_SEGMENT_STARTED} +// +// ( const REFERENCE_TIME *pStreamTimeAtStartOfSegment, DWORD dwSegmentNumber) +// +// pStreamTimeAtStartOfSegment +// pointer to the accumulated stream clock +// time since the start of the segment - this is directly computable +// as the sum of the previous segment durations (Stop - Start) +// and the rate applied to each segment +// +// dwSegmentNumber +// Segment number - starts at 0 +// +// Notifies that a new segment has been started. +// This is sent synchronously by any entity that will issue +// EC_END_OF_SEGMENT when a new segment is started +// (See IMediaSeeking::SetPositions - AM_SEEKING_Segment flag) +// It is used to compute how many EC_END_OF_SEGMENT notifications +// to expect at the end of a segment and as a consitency check + + EC_LENGTH_CHANGED = $1E; + {$EXTERNALSYM EC_LENGTH_CHANGED} +// (void, void) +// sent to indicate that the length of the "file" has changed + + EC_DEVICE_LOST = $1f; + {$EXTERNALSYM EC_DEVICE_LOST} +// (IUnknown, 0) +// +// request window notification when the device is available again +// (through WM_DEVICECHANGED messages registered with +// RegisterDeviceNotification; see IAMDeviceRemoval interface) + + EC_STEP_COMPLETE = $24; + {$EXTERNALSYM EC_STEP_COMPLETE} +// (BOOL bCacelled, void) +// Step request complete +// if bCancelled is TRUE the step was cancelled. This can happen +// if the application issued some control request or because there +// was a mode change etc etc + + +// EC_SKIP_FRAMES = $25; +// ( nFramesToSkip, void ) : internal +// Get the filter graph to seek accuratley. +// Event code 25 is reserved for future use. (dx8.1 specific) + + EC_TIMECODE_AVAILABLE = $30; + {$EXTERNALSYM EC_TIMECODE_AVAILABLE} +// Sent by filter supporting timecode +// Param1 has a pointer to the sending object +// Param2 has the device ID of the sending object + + EC_EXTDEVICE_MODE_CHANGE = $31; + {$EXTERNALSYM EC_EXTDEVICE_MODE_CHANGE} +// Sent by filter supporting IAMExtDevice +// Param1 has the new mode +// Param2 has the device ID of the sending object + + + EC_STATE_CHANGE = $32; + {$EXTERNALSYM EC_STATE_CHANGE} +// ( FILTER_STATE, BOOL bInternal) +// Used to notify the application of any state changes in the filter graph. +// lParam1 is of type enum FILTER_STATE (defined in strmif.h) and indicates +// the state of the filter graph. +// +// lParam2 == 0 indicates that the previous state change request has completed +// & a change in application state. +// lParam2 == 1 reserved for future use to indicate internal state changes. + + EC_GRAPH_CHANGED = $50; + {$EXTERNALSYM EC_GRAPH_CHANGED} +// Sent by filter to notify interesting graph changes + + EC_CLOCK_UNSET = $51; + {$EXTERNALSYM EC_CLOCK_UNSET} +// ( void, void ) : application +// Used to notify the filter graph to unset the current graph clock. +// Has the affect of forcing the filter graph to reestablish the graph clock +// on the next Pause/Run (note that this is only used by ksproxy, when the pin +// of a clock providing filter is disconnected) + + EC_VMR_RENDERDEVICE_SET = $53; + {$EXTERNALSYM EC_VMR_RENDERDEVICE_SET} +// (Render_Device type, void) +// Identifies the type of rendering mechanism the VMR +// is using to display video. Types used include: + VMR_RENDER_DEVICE_OVERLAY = $01; + {$EXTERNALSYM VMR_RENDER_DEVICE_OVERLAY} + VMR_RENDER_DEVICE_VIDMEM = $02; + {$EXTERNALSYM VMR_RENDER_DEVICE_VIDMEM} + VMR_RENDER_DEVICE_SYSMEM = $04; + {$EXTERNALSYM VMR_RENDER_DEVICE_SYSMEM} + + + EC_VMR_SURFACE_FLIPPED = $54; + {$EXTERNALSYM EC_VMR_SURFACE_FLIPPED} +// (hr - Flip return code, void) +// Identifies the VMR's allocator-presenter has called the DDraw flip api on +// the surface being presented. This allows the VMR to keep its DX-VA table +// of DDraw surfaces in sync with DDraws flipping chain. + + EC_VMR_RECONNECTION_FAILED = $55; + {$EXTERNALSYM EC_VMR_RECONNECTION_FAILED} +// (hr - ReceiveConnection return code, void) +// Identifies that an upstream decoder tried to perform a dynamic format +// change and the VMR was unable to accept the new format. + + EC_PREPROCESS_COMPLETE = $56; + {$EXTERNALSYM EC_PREPROCESS_COMPLETE} +// Sent by the WM ASF writer filter (WMSDK V9 version) to signal the completion +// of a pre-process run when running in multipass encode mode. +// Param1 = 0, Param2 = IBaseFilter ptr of sending filter + + EC_CODECAPI_EVENT = $57; + {$EXTERNALSYM EC_CODECAPI_EVENT} +// Sent by the Codec API when an event is encountered. Both the Data +// must be freed by the recipient using CoTaskMemFree +// Param1 = UserDataPointer, Param2 = VOID* Data + + + + +//------------------------------------------ +// +// BDA events: +// +// Event code 0x80 through 0x8f are reserved for BDA +// + + +//------------------------------------------ +// +// WindowsMedia SDK filter-specific events: +// +// +// Note that for EC_WMT_EVENT events the wmsdk-based filters use the following structure for +// passing event parameters to the app: + +type + PAMWMTEventData = ^TAMWMTEventData; + AM_WMT_EVENT_DATA = record + hrStatus : HResult; // status code + pData : pointer; // event data + end; + {$EXTERNALSYM AM_WMT_EVENT_DATA} + TAMWMTEventData = AM_WMT_EVENT_DATA; + +const + + EC_WMT_EVENT_BASE = $0251; + {$EXTERNALSYM EC_WMT_EVENT_BASE} +// + EC_WMT_INDEX_EVENT = EC_WMT_EVENT_BASE; + {$EXTERNALSYM EC_WMT_INDEX_EVENT} +// WindowsMedia SDK-originated file indexing status, sent by WMSDK-based filters +// +// lParam1 is one of the enum WMT_STATUS messages listed below, sent by the WindowsMedia SDK +// lParam2 is specific to the lParam event +// +// the following WMT_STATUS messages are sent for this event: +// WMT_STARTED - lParam2 is 0 +// WMT_CLOSED - lParam2 is 0 +// WMT_INDEX_PROGRESS - lParam2 is a DWORD containing the progress percent complete +// + + EC_WMT_EVENT = EC_WMT_EVENT_BASE+1; + {$EXTERNALSYM EC_WMT_EVENT} +// WindowsMedia SDK-originated event, sent by WMSDK-based filters +// +// lParam1 is one of the enum WMT_STATUS messages listed below, sent by the WindowsMedia SDK +// lParam2 is a pointer an AM_WMT_EVENT_DATA structure where, +// hrStatus is the status code sent by the wmsdk +// pData is specific to the lParam1 event +// +// the following WMT_STATUS messages are sent by the WMSDK Reader filter for this event: +// WMT_NO_RIGHTS - pData is a pointer to a WCHAR string containing a challenge URL +// WMT_ACQUIRE_LICENSE - lParam2 is a pointer to a WM_GET_LICENSE_DATA struct +// WMT_NO_RIGHTS_EX - lParam2 is a pointer to a WM_GET_LICENSE_DATA struct +// WMT_NEEDS_INDIVIDUALIZATION - lParam2 is NULL +// WMT_INDIVIDUALIZE - lParam2 is a pointer to a WM_INDIVIDUALIZE_STATUS struct +// the WMSDK (V9) ASF Writer filter will send this event in response to a wmsdk-signaled error during file +// writing, along with the wmsdk WMT_STATUS error as the lParam1 and hrStatus embedded in the +// AM_WMT_EVENT_DATA struct pointed to by the lParam2 pointer. +// +// end WMSDK-originated events +//----------------------------------------- + + EC_BUILT = $300; + {$EXTERNALSYM EC_BUILT} + // Sent to notify transition from unbuilt to built state + + EC_UNBUILT = $301; + {$EXTERNALSYM EC_UNBUILT} + // Sent to notify transtion from built to unbuilt state + +(*==========================================================================; + * + * Copyright (C) 1996-1997 Microsoft Corporation. All Rights Reserved. + * + * File: uuids.h + * + ***************************************************************************) + +const + +// -- to allow consistent labeling of Media types and subtypes -- + // ?? GUID_NULL ?? + GUID_NULL: TGUID = (D1:$00000000;D2:$0000;D3:$0000;D4:($00,$00,$00,$00,$00,$00,$00,$00)); + MEDIATYPE_NULL: TGUID = (D1:$00000000;D2:$0000;D3:$0000;D4:($00,$00,$00,$00,$00,$00,$00,$00)); + MEDIASUBTYPE_NULL: TGUID = (D1:$00000000;D2:$0000;D3:$0000;D4:($00,$00,$00,$00,$00,$00,$00,$00)); + +// -- Use this subtype if you don't have a use for a subtype for your type + MEDIASUBTYPE_None: TGUID = (D1:$E436EB8E;D2:$524F;D3:$11CE;D4:($9F,$53,$00,$20,$AF,$0B,$A7,$70)); + {$EXTERNALSYM MEDIASUBTYPE_None} + +// -- major types --- + MEDIATYPE_Video: TGUID = (D1:$73646976;D2:$0000;D3:$0010;D4:($80,$00,$00,$AA,$00,$38,$9B,$71)); + {$EXTERNALSYM MEDIATYPE_Video} + MEDIATYPE_Audio: TGUID = (D1:$73647561;D2:$0000;D3:$0010;D4:($80,$00,$00,$AA,$00,$38,$9B,$71)); + {$EXTERNALSYM MEDIATYPE_Audio} + MEDIATYPE_Text: TGUID = (D1:$73747874;D2:$0000;D3:$0010;D4:($80,$00,$00,$AA,$00,$38,$9B,$71)); + {$EXTERNALSYM MEDIATYPE_Text} + MEDIATYPE_Midi: TGUID = (D1:$7364696D;D2:$0000;D3:$0010;D4:($80,$00,$00,$AA,$00,$38,$9B,$71)); + {$EXTERNALSYM MEDIATYPE_Midi} + MEDIATYPE_Stream: TGUID = (D1:$E436EB83;D2:$524F;D3:$11CE;D4:($9F,$53,$00,$20,$AF,$0B,$A7,$70)); + {$EXTERNALSYM MEDIATYPE_Stream} + MEDIATYPE_Interleaved: TGUID = (D1:$73766169;D2:$0000;D3:$0010;D4:($80,$00,$00,$AA,$00,$38,$9B,$71)); + {$EXTERNALSYM MEDIATYPE_Interleaved} + MEDIATYPE_File: TGUID = (D1:$656C6966;D2:$0000;D3:$0010;D4:($80,$00,$00,$AA,$00,$38,$9B,$71)); + {$EXTERNALSYM MEDIATYPE_File} + MEDIATYPE_ScriptCommand: TGUID = (D1:$73636D64;D2:$0000;D3:$0010;D4:($80,$00,$00,$AA,$00,$38,$9B,$71)); + {$EXTERNALSYM MEDIATYPE_ScriptCommand} + MEDIATYPE_AUXLine21Data: TGUID = (D1:$670AEA80;D2:$3A82;D3:$11D0;D4:($B7,$9B,$00,$AA,$00,$37,$67,$A7)); + {$EXTERNALSYM MEDIATYPE_AUXLine21Data} + MEDIATYPE_VBI : TGUID = '{F72A76E1-EB0A-11D0-ACE4-0000C0CC16BA}'; + {$EXTERNALSYM MEDIATYPE_VBI} + MEDIATYPE_Timecode: TGUID = (D1:$0482DEE3;D2:$7817;D3:$11CF;D4:($8A,$03,$00,$AA,$00,$6E,$CB,$65)); + {$EXTERNALSYM MEDIATYPE_Timecode} + MEDIATYPE_LMRT : TGUID = (D1:$74726c6d;D2:$0000;D3:$0010;D4:($80,$00,$00,$aa,$00,$38,$9b,$71)); + {$EXTERNALSYM MEDIATYPE_LMRT} + MEDIATYPE_URL_STREAM: TGUID = (D1:$736c7275;D2:$0000;D3:$0010;D4:($80,$00,$00,$aa,$00,$38,$9b,$71)); + {$EXTERNALSYM MEDIATYPE_URL_STREAM} + +// -- sub types --- + MEDIASUBTYPE_CLPL: TGUID = (D1:$4C504C43;D2:$0000;D3:$0010;D4:($80,$00,$00,$aa,$00,$38,$9b,$71)); + {$EXTERNALSYM MEDIASUBTYPE_CLPL} + MEDIASUBTYPE_YUYV: TGUID = (D1:$56595559;D2:$0000;D3:$0010;D4:($80,$00,$00,$aa,$00,$38,$9b,$71)); + {$EXTERNALSYM MEDIASUBTYPE_YUYV} + MEDIASUBTYPE_IYUV: TGUID = (D1:$56555949;D2:$0000;D3:$0010;D4:($80,$00,$00,$aa,$00,$38,$9b,$71)); + {$EXTERNALSYM MEDIASUBTYPE_IYUV} + MEDIASUBTYPE_YVU9: TGUID = (D1:$39555659;D2:$0000;D3:$0010;D4:($80,$00,$00,$AA,$00,$38,$9B,$71)); + {$EXTERNALSYM MEDIASUBTYPE_YVU9} + MEDIASUBTYPE_Y411: TGUID = (D1:$31313459;D2:$0000;D3:$0010;D4:($80,$00,$00,$AA,$00,$38,$9B,$71)); + {$EXTERNALSYM MEDIASUBTYPE_Y411} + MEDIASUBTYPE_Y41P: TGUID = (D1:$50313459;D2:$0000;D3:$0010;D4:($80,$00,$00,$AA,$00,$38,$9B,$71)); + {$EXTERNALSYM MEDIASUBTYPE_Y41P} + MEDIASUBTYPE_YUY2: TGUID = (D1:$32595559;D2:$0000;D3:$0010;D4:($80,$00,$00,$AA,$00,$38,$9B,$71)); + {$EXTERNALSYM MEDIASUBTYPE_YUY2} + MEDIASUBTYPE_YVYU: TGUID = (D1:$55595659;D2:$0000;D3:$0010;D4:($80,$00,$00,$AA,$00,$38,$9B,$71)); + {$EXTERNALSYM MEDIASUBTYPE_YVYU} + MEDIASUBTYPE_UYVY: TGUID = (D1:$59565955;D2:$0000;D3:$0010;D4:($80,$00,$00,$AA,$00,$38,$9B,$71)); + {$EXTERNALSYM MEDIASUBTYPE_UYVY} + MEDIASUBTYPE_Y211: TGUID = (D1:$31313259;D2:$0000;D3:$0010;D4:($80,$00,$00,$AA,$00,$38,$9B,$71)); + {$EXTERNALSYM MEDIASUBTYPE_Y211} + MEDIASUBTYPE_CLJR: TGUID = (D1:$524A4C43;D2:$0000;D3:$0010;D4:($80,$00,$00,$AA,$00,$38,$9B,$71)); + {$EXTERNALSYM MEDIASUBTYPE_CLJR} + MEDIASUBTYPE_IF09: TGUID = (D1:$39304649;D2:$0000;D3:$0010;D4:($80,$00,$00,$AA,$00,$38,$9B,$71)); + {$EXTERNALSYM MEDIASUBTYPE_IF09} + MEDIASUBTYPE_CPLA: TGUID = (D1:$414C5043;D2:$0000;D3:$0010;D4:($80,$00,$00,$AA,$00,$38,$9B,$71)); + {$EXTERNALSYM MEDIASUBTYPE_CPLA} + MEDIASUBTYPE_MJPG: TGUID = (D1:$47504A4D;D2:$0000;D3:$0010;D4:($80,$00,$00,$AA,$00,$38,$9B,$71)); + {$EXTERNALSYM MEDIASUBTYPE_MJPG} + MEDIASUBTYPE_TVMJ: TGUID = (D1:$4A4D5654;D2:$0000;D3:$0010;D4:($80,$00,$00,$AA,$00,$38,$9B,$71)); + {$EXTERNALSYM MEDIASUBTYPE_TVMJ} + MEDIASUBTYPE_WAKE: TGUID = (D1:$454B4157;D2:$0000;D3:$0010;D4:($80,$00,$00,$AA,$00,$38,$9B,$71)); + {$EXTERNALSYM MEDIASUBTYPE_WAKE} + MEDIASUBTYPE_CFCC: TGUID = (D1:$43434643;D2:$0000;D3:$0010;D4:($80,$00,$00,$AA,$00,$38,$9B,$71)); + {$EXTERNALSYM MEDIASUBTYPE_CFCC} + MEDIASUBTYPE_IJPG: TGUID = (D1:$47504A49;D2:$0000;D3:$0010;D4:($80,$00,$00,$AA,$00,$38,$9B,$71)); + {$EXTERNALSYM MEDIASUBTYPE_IJPG} + MEDIASUBTYPE_Plum: TGUID = (D1:$6D756C50;D2:$0000;D3:$0010;D4:($80,$00,$00,$AA,$00,$38,$9B,$71)); + {$EXTERNALSYM MEDIASUBTYPE_Plum} + MEDIASUBTYPE_DVCS: TGUID = (D1:$53435644;D2:$0000;D3:$0010;D4:($80,$00,$00,$AA,$00,$38,$9B,$71)); + {$EXTERNALSYM MEDIASUBTYPE_DVCS} + MEDIASUBTYPE_DVSD: TGUID = (D1:$44535644;D2:$0000;D3:$0010;D4:($80,$00,$00,$AA,$00,$38,$9B,$71)); + {$EXTERNALSYM MEDIASUBTYPE_DVSD} + MEDIASUBTYPE_MDVF: TGUID = (D1:$4656444D;D2:$0000;D3:$0010;D4:($80,$00,$00,$AA,$00,$38,$9B,$71)); + {$EXTERNALSYM MEDIASUBTYPE_MDVF} + MEDIASUBTYPE_RGB1: TGUID = (D1:$E436EB78;D2:$524F;D3:$11CE;D4:($9F,$53,$00,$20,$AF,$0B,$A7,$70)); + {$EXTERNALSYM MEDIASUBTYPE_RGB1} + MEDIASUBTYPE_RGB4: TGUID = (D1:$E436EB79;D2:$524F;D3:$11CE;D4:($9F,$53,$00,$20,$AF,$0B,$A7,$70)); + {$EXTERNALSYM MEDIASUBTYPE_RGB4} + MEDIASUBTYPE_RGB8: TGUID = (D1:$E436EB7A;D2:$524F;D3:$11CE;D4:($9F,$53,$00,$20,$AF,$0B,$A7,$70)); + {$EXTERNALSYM MEDIASUBTYPE_RGB8} + MEDIASUBTYPE_RGB565: TGUID = (D1:$E436EB7B;D2:$524F;D3:$11CE;D4:($9F,$53,$00,$20,$AF,$0B,$A7,$70)); + {$EXTERNALSYM MEDIASUBTYPE_RGB565} + MEDIASUBTYPE_RGB555: TGUID = (D1:$E436EB7C;D2:$524F;D3:$11CE;D4:($9F,$53,$00,$20,$AF,$0B,$A7,$70)); + {$EXTERNALSYM MEDIASUBTYPE_RGB555} + MEDIASUBTYPE_RGB24: TGUID = (D1:$E436EB7D;D2:$524F;D3:$11CE;D4:($9F,$53,$00,$20,$AF,$0B,$A7,$70)); + {$EXTERNALSYM MEDIASUBTYPE_RGB24} + MEDIASUBTYPE_RGB32: TGUID = (D1:$E436EB7E;D2:$524F;D3:$11CE;D4:($9F,$53,$00,$20,$AF,$0B,$A7,$70)); + {$EXTERNALSYM MEDIASUBTYPE_RGB32} + MEDIASUBTYPE_ARGB1555 : TGUID = '{297C55AF-E209-4cb3-B757-C76D6B9C88A8}'; + {$EXTERNALSYM MEDIASUBTYPE_ARGB1555} + MEDIASUBTYPE_ARGB4444 : TGUID = '{6E6415E6-5C24-425f-93CD-80102B3D1CCA}'; + {$EXTERNALSYM MEDIASUBTYPE_ARGB4444} + MEDIASUBTYPE_ARGB32 : TGUID = (D1:$773c9ac0;D2:$3274;D3:$11d0;D4:($b7,$24,$00,$aa,$00,$6c,$1a,$1 )); + {$EXTERNALSYM MEDIASUBTYPE_ARGB32} + + MEDIASUBTYPE_A2R10G10B10 : TGUID = '{2f8bb76d-b644-4550-acf3-d30caa65d5c5}'; + {$EXTERNALSYM MEDIASUBTYPE_A2R10G10B10} + MEDIASUBTYPE_A2B10G10R10 : TGUID = '{576f7893-bdf6-48c4-875f-ae7b81834567}'; + {$EXTERNALSYM MEDIASUBTYPE_A2B10G10R10} + + MEDIASUBTYPE_AYUV : TGUID = '{56555941-0000-0010-8000-00AA00389B71}'; //'AYUV' == MEDIASUBTYPE_AYUV + {$EXTERNALSYM MEDIASUBTYPE_AYUV} + MEDIASUBTYPE_AI44 : TGUID = '{34344941-0000-0010-8000-00AA00389B71}'; //'AI44' == MEDIASUBTYPE_AI44 + {$EXTERNALSYM MEDIASUBTYPE_AI44} + MEDIASUBTYPE_IA44 : TGUID = '{34344149-0000-0010-8000-00AA00389B71}'; //'IA44' == MEDIASUBTYPE_IA44 + {$EXTERNALSYM MEDIASUBTYPE_IA44} + +{$IFDEF ENABLEVMR7} +// +// DirectX7 D3D Render Target media subtypes. +// + MEDIASUBTYPE_RGB32_D3D_DX7_RT : TGUID = '{32335237-0000-0010-8000-00AA00389B71}'; //'7R32' == MEDIASUBTYPE_RGB32_D3D_DX7_RT + {$EXTERNALSYM MEDIASUBTYPE_RGB32_D3D_DX7_RT} + MEDIASUBTYPE_RGB16_D3D_DX7_RT : TGUID = '{36315237-0000-0010-8000-00AA00389B71}'; //'7R16' == MEDIASUBTYPE_RGB16_D3D_DX7_RT + {$EXTERNALSYM MEDIASUBTYPE_RGB16_D3D_DX7_RT} + MEDIASUBTYPE_ARGB32_D3D_DX7_RT : TGUID = '{38384137-0000-0010-8000-00AA00389B71}'; //'7A88' == MEDIASUBTYPE_ARGB32_D3D_DX7_RT + {$EXTERNALSYM MEDIASUBTYPE_ARGB32_D3D_DX7_RT} + MEDIASUBTYPE_ARGB4444_D3D_DX7_RT : TGUID = '{34344137-0000-0010-8000-00AA00389B71}'; //'7A44' == MEDIASUBTYPE_ARGB4444_D3D_DX7_RT + {$EXTERNALSYM MEDIASUBTYPE_ARGB4444_D3D_DX7_RT} + MEDIASUBTYPE_ARGB1555_D3D_DX7_RT : TGUID = '{35314137-0000-0010-8000-00AA00389B71}'; //'7A15' == MEDIASUBTYPE_ARGB1555_D3D_DX7_RT + {$EXTERNALSYM MEDIASUBTYPE_ARGB1555_D3D_DX7_RT} +{$ENDIF} +// +// DirectX9 D3D Render Target media subtypes. +// + + MEDIASUBTYPE_RGB32_D3D_DX9_RT : TGUID = '{32335239-0000-0010-8000-00AA00389B71}'; // 9R32 + {$EXTERNALSYM MEDIASUBTYPE_RGB32_D3D_DX9_RT} + MEDIASUBTYPE_RGB16_D3D_DX9_RT : TGUID = '{36315239-0000-0010-8000-00AA00389B71}'; // 9R16 + {$EXTERNALSYM MEDIASUBTYPE_RGB16_D3D_DX9_RT} + MEDIASUBTYPE_ARGB32_D3D_DX9_RT : TGUID = '{38384139-0000-0010-8000-00AA00389B71}'; // 9A88 + {$EXTERNALSYM MEDIASUBTYPE_ARGB32_D3D_DX9_RT} + MEDIASUBTYPE_ARGB4444_D3D_DX9_RT : TGUID = '{34344139-0000-0010-8000-00AA00389B71}'; // 9A44 + {$EXTERNALSYM MEDIASUBTYPE_ARGB4444_D3D_DX9_RT} + MEDIASUBTYPE_ARGB1555_D3D_DX9_RT : TGUID = '{35314139-0000-0010-8000-00AA00389B71}'; // 9A15 + {$EXTERNALSYM MEDIASUBTYPE_ARGB1555_D3D_DX9_RT} + + +{ +#define MEDIASUBTYPE_HASALPHA(mt) ( ((mt).subtype == MEDIASUBTYPE_ARGB4444) || \ + ((mt).subtype == MEDIASUBTYPE_ARGB32) || \ + ((mt).subtype == MEDIASUBTYPE_AYUV) || \ + ((mt).subtype == MEDIASUBTYPE_AI44) || \ + ((mt).subtype == MEDIASUBTYPE_IA44) || \ + ((mt).subtype == MEDIASUBTYPE_ARGB1555) || \ + ((mt).subtype == MEDIASUBTYPE_ARGB32_D3D_DX7_RT) || \ + ((mt).subtype == MEDIASUBTYPE_ARGB4444_D3D_DX7_RT) || \ + ((mt).subtype == MEDIASUBTYPE_ARGB1555_D3D_DX7_RT) || \ + ((mt).subtype == MEDIASUBTYPE_ARGB32_D3D_DX9_RT) || \ + ((mt).subtype == MEDIASUBTYPE_ARGB4444_D3D_DX9_RT) || \ + ((mt).subtype == MEDIASUBTYPE_ARGB1555_D3D_DX9_RT) ) + +#define MEDIASUBTYPE_HASALPHA7(mt) (((mt).subtype == MEDIASUBTYPE_ARGB32_D3D_DX7_RT) || \ + ((mt).subtype == MEDIASUBTYPE_ARGB4444_D3D_DX7_RT) || \ + ((mt).subtype == MEDIASUBTYPE_ARGB1555_D3D_DX7_RT) ) + +#define MEDIASUBTYPE_D3D_DX7_RT(mt) (((mt).subtype == MEDIASUBTYPE_ARGB32_D3D_DX7_RT) || \ + ((mt).subtype == MEDIASUBTYPE_ARGB4444_D3D_DX7_RT) || \ + ((mt).subtype == MEDIASUBTYPE_ARGB1555_D3D_DX7_RT) || \ + ((mt).subtype == MEDIASUBTYPE_RGB32_D3D_DX7_RT) || \ + ((mt).subtype == MEDIASUBTYPE_RGB16_D3D_DX7_RT)) + +#define MEDIASUBTYPE_HASALPHA9(mt) (((mt).subtype == MEDIASUBTYPE_ARGB32_D3D_DX9_RT) || \ + ((mt).subtype == MEDIASUBTYPE_ARGB4444_D3D_DX9_RT) || \ + ((mt).subtype == MEDIASUBTYPE_ARGB1555_D3D_DX9_RT) ) + + +#define MEDIASUBTYPE_D3D_DX9_RT(mt) (((mt).subtype == MEDIASUBTYPE_ARGB32_D3D_DX9_RT) || \ + ((mt).subtype == MEDIASUBTYPE_ARGB4444_D3D_DX9_RT) || \ + ((mt).subtype == MEDIASUBTYPE_ARGB1555_D3D_DX9_RT) || \ + ((mt).subtype == MEDIASUBTYPE_RGB32_D3D_DX9_RT) || \ + ((mt).subtype == MEDIASUBTYPE_RGB16_D3D_DX9_RT)) +} + +// DX-VA uncompressed surface formats + + MEDIASUBTYPE_YV12 : TGUID = '{32315659-0000-0010-8000-00AA00389B71}'; // YV12 + {$EXTERNALSYM MEDIASUBTYPE_YV12} + MEDIASUBTYPE_NV12 : TGUID = '{3231564E-0000-0010-8000-00AA00389B71}'; // NV12 + {$EXTERNALSYM MEDIASUBTYPE_NV12} + MEDIASUBTYPE_IMC1 : TGUID = '{31434D49-0000-0010-8000-00AA00389B71}'; // IMC1 + {$EXTERNALSYM MEDIASUBTYPE_IMC1} + MEDIASUBTYPE_IMC2 : TGUID = '{32434d49-0000-0010-8000-00AA00389B71}'; // IMC2 + {$EXTERNALSYM MEDIASUBTYPE_IMC2} + MEDIASUBTYPE_IMC3 : TGUID = '{33434d49-0000-0010-8000-00AA00389B71}'; // IMC3 + {$EXTERNALSYM MEDIASUBTYPE_IMC3} + MEDIASUBTYPE_IMC4 : TGUID = '{34434d49-0000-0010-8000-00AA00389B71}'; // IMC4 + {$EXTERNALSYM MEDIASUBTYPE_IMC4} + MEDIASUBTYPE_S340 : TGUID = '{30343353-0000-0010-8000-00AA00389B71}'; // S340 + {$EXTERNALSYM MEDIASUBTYPE_S340} + MEDIASUBTYPE_S342 : TGUID = '{32343353-0000-0010-8000-00AA00389B71}'; // S342 + {$EXTERNALSYM MEDIASUBTYPE_S342} + + + MEDIASUBTYPE_Overlay: TGUID = (D1:$E436EB7F;D2:$524F;D3:$11CE;D4:($9F,$53,$00,$20,$AF,$0B,$A7,$70)); + {$EXTERNALSYM MEDIASUBTYPE_Overlay} + MEDIASUBTYPE_MPEG1Packet: TGUID = (D1:$E436EB80;D2:$524F;D3:$11CE;D4:($9F,$53,$00,$20,$AF,$0B,$A7,$70)); + {$EXTERNALSYM MEDIASUBTYPE_MPEG1Packet} + MEDIASUBTYPE_MPEG1Payload: TGUID = (D1:$E436EB81;D2:$524F;D3:$11CE;D4:($9F,$53,$00,$20,$AF,$0B,$A7,$70)); + {$EXTERNALSYM MEDIASUBTYPE_MPEG1Payload} + MEDIASUBTYPE_MPEG1AudioPayload: TGUID = (D1:$00000050;D2:$0000;D3:$0010;D4:($80,$00,$00,$AA,$00,$38,$9B,$71)); + {$EXTERNALSYM MEDIASUBTYPE_MPEG1AudioPayload} + MEDIATYPE_MPEG1SystemStream: TGUID = (D1:$E436EB82;D2:$524F;D3:$11CE;D4:($9F,$53,$00,$20,$AF,$0B,$A7,$70)); + {$EXTERNALSYM MEDIATYPE_MPEG1SystemStream} + MEDIASUBTYPE_MPEG1System: TGUID = (D1:$E436EB84;D2:$524F;D3:$11CE;D4:($9F,$53,$00,$20,$AF,$0B,$A7,$70)); + {$EXTERNALSYM MEDIASUBTYPE_MPEG1System} + MEDIASUBTYPE_MPEG1VideoCD: TGUID = (D1:$E436EB85;D2:$524F;D3:$11CE;D4:($9F,$53,$00,$20,$AF,$0B,$A7,$70)); + {$EXTERNALSYM MEDIASUBTYPE_MPEG1VideoCD} + MEDIASUBTYPE_MPEG1Video: TGUID = (D1:$E436EB86;D2:$524F;D3:$11CE;D4:($9F,$53,$00,$20,$AF,$0B,$A7,$70)); + {$EXTERNALSYM MEDIASUBTYPE_MPEG1Video} + MEDIASUBTYPE_MPEG1Audio: TGUID = (D1:$E436EB87;D2:$524F;D3:$11CE;D4:($9F,$53,$00,$20,$AF,$0B,$A7,$70)); + {$EXTERNALSYM MEDIASUBTYPE_MPEG1Audio} + MEDIASUBTYPE_Avi: TGUID = (D1:$E436EB88;D2:$524F;D3:$11CE;D4:($9F,$53,$00,$20,$AF,$0B,$A7,$70)); + {$EXTERNALSYM MEDIASUBTYPE_Avi} + MEDIASUBTYPE_Asf: TGUID = (D1:$3db80f90;D2:$9412;D3:$11d1;D4:($ad,$ed,$00,$00,$f8,$75,$4b,$99)); + {$EXTERNALSYM MEDIASUBTYPE_Asf} + MEDIASUBTYPE_QTMovie: TGUID = (D1:$E436EB89;D2:$524F;D3:$11CE;D4:($9F,$53,$00,$20,$AF,$0B,$A7,$70)); + {$EXTERNALSYM MEDIASUBTYPE_QTMovie} + MEDIASUBTYPE_QTRpza: TGUID = (D1:$617A7072;D2:$0000;D3:$0010;D4:($80,$00,$00,$AA,$00,$38,$9B,$71)); + {$EXTERNALSYM MEDIASUBTYPE_QTRpza} + MEDIASUBTYPE_QTSmc: TGUID = (D1:$20636D73;D2:$0000;D3:$0010;D4:($80,$00,$00,$AA,$00,$38,$9B,$71)); + {$EXTERNALSYM MEDIASUBTYPE_QTSmc} + MEDIASUBTYPE_QTRle: TGUID = (D1:$20656C72;D2:$0000;D3:$0010;D4:($80,$00,$00,$AA,$00,$38,$9B,$71)); + {$EXTERNALSYM MEDIASUBTYPE_QTRle} + MEDIASUBTYPE_QTJpeg: TGUID = (D1:$6765706A;D2:$0000;D3:$0010;D4:($80,$00,$00,$AA,$00,$38,$9B,$71)); + {$EXTERNALSYM MEDIASUBTYPE_QTJpeg} + MEDIASUBTYPE_PCMAudio_Obsolete: TGUID = (D1:$E436EB8A;D2:$524F;D3:$11CE;D4:($9F,$53,$00,$20,$AF,$0B,$A7,$70)); + {$EXTERNALSYM MEDIASUBTYPE_PCMAudio_Obsolete} + MEDIASUBTYPE_PCM: TGUID = (D1:$00000001;D2:$0000;D3:$0010;D4:($80,$00,$00,$AA,$00,$38,$9B,$71)); + {$EXTERNALSYM MEDIASUBTYPE_PCM} + MEDIASUBTYPE_WAVE: TGUID = (D1:$E436EB8B;D2:$524F;D3:$11CE;D4:($9F,$53,$00,$20,$AF,$0B,$A7,$70)); + {$EXTERNALSYM MEDIASUBTYPE_WAVE} + MEDIASUBTYPE_AU: TGUID = (D1:$E436EB8C;D2:$524F;D3:$11CE;D4:($9F,$53,$00,$20,$AF,$0B,$A7,$70)); + {$EXTERNALSYM MEDIASUBTYPE_AU} + MEDIASUBTYPE_AIFF: TGUID = (D1:$E436EB8D;D2:$524F;D3:$11CE;D4:($9F,$53,$00,$20,$AF,$0B,$A7,$70)); + {$EXTERNALSYM MEDIASUBTYPE_AIFF} + MEDIASUBTYPE_dvsd_: TGUID = (D1:$64737664;D2:$0000;D3:$0010;D4:($80,$00,$00,$AA,$00,$38,$9B,$71)); + {$EXTERNALSYM MEDIASUBTYPE_dvsd_} + MEDIASUBTYPE_dvhd: TGUID = (D1:$64687664;D2:$0000;D3:$0010;D4:($80,$00,$00,$AA,$00,$38,$9B,$71)); + {$EXTERNALSYM MEDIASUBTYPE_dvhd} + MEDIASUBTYPE_dvsl : TGUID = (D1:$6C737664;D2:$0000;D3:$0010;D4:($80,$00,$00,$AA,$00,$38,$9B,$71)); + {$EXTERNALSYM MEDIASUBTYPE_dvsl} + + MEDIASUBTYPE_dv25 : TGUID = '{35327664-0000-0010-8000-00aa00389b71}'; + {$EXTERNALSYM MEDIASUBTYPE_dv25} + MEDIASUBTYPE_dv50 : TGUID = '{30357664-0000-0010-8000-00aa00389b71}'; + {$EXTERNALSYM MEDIASUBTYPE_dv50} + MEDIASUBTYPE_dvh1 : TGUID = '{31687664-0000-0010-8000-00aa00389b71}'; + {$EXTERNALSYM MEDIASUBTYPE_dvh1} + + MEDIASUBTYPE_Line21_BytePair: TGUID = (D1:$6E8D4A22;D2:$310C;D3:$11D0;D4:($B7,$9A,$00,$AA,$00,$37,$67,$A7)); + {$EXTERNALSYM MEDIASUBTYPE_Line21_BytePair} + MEDIASUBTYPE_Line21_GOPPacket: TGUID = (D1:$6E8D4A23;D2:$310C;D3:$11D0;D4:($B7,$9A,$00,$AA,$00,$37,$67,$A7)); + {$EXTERNALSYM MEDIASUBTYPE_Line21_GOPPacket} + MEDIASUBTYPE_Line21_VBIRawData: TGUID = (D1:$6E8D4A24;D2:$310C;D3:$11D0;D4:($B7,$9A,$00,$AA,$00,$37,$67,$A7)); + {$EXTERNALSYM MEDIASUBTYPE_Line21_VBIRawData} + MEDIASUBTYPE_TELETEXT : TGUID = '{F72A76E3-EB0A-11D0-ACE4-0000C0CC16BA}'; // MEDIASUBTYPE_TELETEXT + {$EXTERNALSYM MEDIASUBTYPE_TELETEXT} + MEDIASUBTYPE_WSS : TGUID = '{2791D576-8E7A-466F-9E90-5D3F3083738B}'; + {$EXTERNALSYM MEDIASUBTYPE_WSS} + MEDIASUBTYPE_VPS : TGUID = '{A1B3F620-9792-4d8d-81A4-86AF25772090}'; + {$EXTERNALSYM MEDIASUBTYPE_VPS} + MEDIASUBTYPE_DRM_Audio: TGUID = (D1:$00000009;D2:$0000;D3:$0010;D4:($80,$00,$00,$aa,$00,$38,$9b,$71)); + {$EXTERNALSYM MEDIASUBTYPE_DRM_Audio} + MEDIASUBTYPE_IEEE_FLOAT: TGUID = (D1:$00000003;D2:$0000;D3:$0010;D4:($80,$00,$00,$aa,$00,$38,$9b,$71)); + {$EXTERNALSYM MEDIASUBTYPE_IEEE_FLOAT} + MEDIASUBTYPE_DOLBY_AC3_SPDIF: TGUID = (D1:$00000092;D2:$0000;D3:$0010;D4:($80,$00,$00,$aa,$00,$38,$9b,$71)); + {$EXTERNALSYM MEDIASUBTYPE_DOLBY_AC3_SPDIF} + MEDIASUBTYPE_RAW_SPORT: TGUID = (D1:$00000240;D2:$0000;D3:$0010;D4:($80,$00,$00,$aa,$00,$38,$9b,$71)); + {$EXTERNALSYM MEDIASUBTYPE_RAW_SPORT} + MEDIASUBTYPE_SPDIF_TAG_241h: TGUID = (D1:$00000241;D2:$0000;D3:$0010;D4:($80,$00,$00,$aa,$00,$38,$9b,$71)); + {$EXTERNALSYM MEDIASUBTYPE_SPDIF_TAG_241h} + +// DirectShow DSS definitions + + MEDIASUBTYPE_DssVideo: TGUID = (D1:$A0AF4F81;D2:$E163;D3:$11D0;D4:($BA,$D9,$00,$60,$97,$44,$11,$1A)); + {$EXTERNALSYM MEDIASUBTYPE_DssVideo} + MEDIASUBTYPE_DssAudio: TGUID = (D1:$A0AF4F82;D2:$E163;D3:$11D0;D4:($BA,$D9,$00,$60,$97,$44,$11,$1A)); + {$EXTERNALSYM MEDIASUBTYPE_DssAudio} + MEDIASUBTYPE_VPVideo: TGUID = (D1:$5A9B6A40;D2:$1A22;D3:$11D1;D4:($BA,$D9,$00,$60,$97,$44,$11,$1A)); + {$EXTERNALSYM MEDIASUBTYPE_VPVideo} + MEDIASUBTYPE_VPVBI: TGUID = (D1:$5A9B6A41;D2:$1A22;D3:$11D1;D4:($BA,$D9,$00,$60,$97,$44,$11,$1A)); + {$EXTERNALSYM MEDIASUBTYPE_VPVBI} + +//--- dxmedia (the cutlist source filter) + CLSID_SimpleCutList: TGUID = (D1:$A5EA8D30;D2:$253D;D3:$11D1;D4:($B3,$F1,$00,$AA,$00,$37,$61,$C5)); + {$EXTERNALSYM CLSID_SimpleCutList} + CLSID_VideoFileClip: TGUID = (D1:$A5EA8D31;D2:$253D;D3:$11D1;D4:($B3,$F1,$00,$AA,$00,$37,$61,$C5)); + {$EXTERNALSYM CLSID_VideoFileClip} + CLSID_AudioFileClip: TGUID = (D1:$A5EA8D32;D2:$253D;D3:$11D1;D4:($B3,$F1,$00,$AA,$00,$37,$61,$C5)); + {$EXTERNALSYM CLSID_AudioFileClip} + CLSID_CutListCacheMemory: TGUID = (D1:$A5EA8D33;D2:$253D;D3:$11D1;D4:($B3,$F1,$00,$AA,$00,$37,$61,$C5)); + {$EXTERNALSYM CLSID_CutListCacheMemory} +//--- end cut list stuff + CLSID_CaptureGraphBuilder: TGUID = (D1:$BF87B6E0;D2:$8C27;D3:$11D0;D4:($B3,$F0,$00,$AA,$00,$37,$61,$C5)); + {$EXTERNALSYM CLSID_CaptureGraphBuilder} + CLSID_CaptureGraphBuilder2: TGUID = (D1:$BF87B6E1;D2:$8C27;D3:$11d0;D4:($B3,$F0,$00,$AA,$00,$37,$61,$C5)); + {$EXTERNALSYM CLSID_CaptureGraphBuilder2} + CLSID_ProtoFilterGraph: TGUID = (D1:$E436EBB0;D2:$524F;D3:$11CE;D4:($9F,$53,$00,$20,$AF,$0B,$A7,$70)); + {$EXTERNALSYM CLSID_ProtoFilterGraph} + CLSID_SystemClock: TGUID = (D1:$E436EBB1;D2:$524F;D3:$11CE;D4:($9F,$53,$00,$20,$AF,$0B,$A7,$70)); + {$EXTERNALSYM CLSID_SystemClock} + CLSID_FilterMapper: TGUID = (D1:$E436EBB2;D2:$524F;D3:$11CE;D4:($9F,$53,$00,$20,$AF,$0B,$A7,$70)); + {$EXTERNALSYM CLSID_FilterMapper} + CLSID_FilterGraph: TGUID = (D1:$E436EBB3;D2:$524F;D3:$11CE;D4:($9F,$53,$00,$20,$AF,$0B,$A7,$70)); + {$EXTERNALSYM CLSID_FilterGraph} + CLSID_FilterGraphNoThread: TGUID = (D1:$E436EBB8;D2:$524F;D3:$11CE;D4:($9F,$53,$00,$20,$AF,$0B,$A7,$70)); + {$EXTERNALSYM CLSID_FilterGraphNoThread} + CLSID_MPEG1Doc: TGUID = (D1:$E4BBD160;D2:$4269;D3:$11CE;D4:($83,$8D,$00,$AA,$00,$55,$59,$5A)); + {$EXTERNALSYM CLSID_MPEG1Doc} + CLSID_FileSource: TGUID = (D1:$701722E0;D2:$8AE3;D3:$11CE;D4:($A8,$5C,$00,$AA,$00,$2F,$EA,$B5)); + {$EXTERNALSYM CLSID_FileSource} + CLSID_MPEG1PacketPlayer: TGUID = (D1:$26C25940;D2:$4CA9;D3:$11CE;D4:($A8,$28,$00,$AA,$00,$2F,$EA,$B5)); + {$EXTERNALSYM CLSID_MPEG1PacketPlayer} + CLSID_MPEG1Splitter: TGUID = (D1:$336475D0;D2:$942A;D3:$11CE;D4:($A8,$70,$00,$AA,$00,$2F,$EA,$B5)); + {$EXTERNALSYM CLSID_MPEG1Splitter} + CLSID_CMpegVideoCodec: TGUID = (D1:$FEB50740;D2:$7BEF;D3:$11CE;D4:($9B,$D9,$00,$00,$E2,$02,$59,$9C)); + {$EXTERNALSYM CLSID_CMpegVideoCodec} + CLSID_CMpegAudioCodec: TGUID = (D1:$4A2286E0;D2:$7BEF;D3:$11CE;D4:($9B,$D9,$00,$00,$E2,$02,$59,$9C)); + {$EXTERNALSYM CLSID_CMpegAudioCodec} + CLSID_TextRender: TGUID = (D1:$E30629D3;D2:$27E5;D3:$11CE;D4:($87,$5D,$00,$60,$8C,$B7,$80,$66)); + {$EXTERNALSYM CLSID_TextRender} + + CLSID_InfTee: TGUID = (D1:$F8388A40;D2:$D5BB;D3:$11D0;D4:($BE,$5A,$00,$80,$C7,$06,$56,$8E)); + {$EXTERNALSYM CLSID_InfTee} + CLSID_AviSplitter: TGUID = (D1:$1B544C20;D2:$FD0B;D3:$11CE;D4:($8C,$63,$00,$AA,$00,$44,$B5,$1E)); + {$EXTERNALSYM CLSID_AviSplitter} + CLSID_AviReader: TGUID = (D1:$1B544C21;D2:$FD0B;D3:$11CE;D4:($8C,$63,$00,$AA,$00,$44,$B5,$1E)); + {$EXTERNALSYM CLSID_AviReader} + CLSID_VfwCapture: TGUID = (D1:$1B544C22;D2:$FD0B;D3:$11CE;D4:($8C,$63,$00,$AA,$00,$44,$B5,$1E)); + {$EXTERNALSYM CLSID_VfwCapture} + CLSID_CaptureProperties: TGUID = (D1:$1B544C22;D2:$FD0B;D3:$11CE;D4:($8C,$63,$00,$AA,$00,$44,$B5,$1F)); + {$EXTERNALSYM CLSID_CaptureProperties} + CLSID_FGControl: TGUID = (D1:$E436EBB4;D2:$524F;D3:$11CE;D4:($9F,$53,$00,$20,$AF,$0B,$A7,$70)); + {$EXTERNALSYM CLSID_FGControl} + CLSID_MOVReader: TGUID = (D1:$44584800;D2:$F8EE;D3:$11CE;D4:($B2,$D4,$00,$DD,$01,$10,$1B,$85)); + {$EXTERNALSYM CLSID_MOVReader} + CLSID_QuickTimeParser: TGUID = (D1:$d51bd5a0;D2:$7548;D3:$11cf;D4:($a5,$20,$00,$80,$c7,$7e,$f5,$8a)); + {$EXTERNALSYM CLSID_QuickTimeParser} + CLSID_QTDec: TGUID = (D1:$fdfe9681;D2:$74a3;D3:$11d0;D4:($af,$a7,$00,$aa,$00,$b6,$7a,$42)); + {$EXTERNALSYM CLSID_QTDec} + CLSID_AVIDoc: TGUID = (D1:$D3588AB0;D2:$0781;D3:$11CE;D4:($B0,$3A,$00,$20,$AF,$0B,$A7,$70)); + {$EXTERNALSYM CLSID_AVIDoc} +//---dxmedia + CLSID_AVIDocWriter: TGUID = (D1:$D3588AB1;D2:$0781;D3:$11CE;D4:($B0,$3A,$00,$20,$AF,$0B,$A7,$70)); + {$EXTERNALSYM CLSID_AVIDocWriter} +//--- + CLSID_VideoRenderer: TGUID = (D1:$70E102B0;D2:$5556;D3:$11CE;D4:($97,$C0,$00,$AA,$00,$55,$59,$5A)); + {$EXTERNALSYM CLSID_VideoRenderer} + CLSID_Colour: TGUID = (D1:$1643E180;D2:$90F5;D3:$11CE;D4:($97,$D5,$00,$AA,$00,$55,$59,$5A)); + {$EXTERNALSYM CLSID_Colour} + CLSID_Dither: TGUID = (D1:$1DA08500;D2:$9EDC;D3:$11CF;D4:($BC,$10,$00,$AA,$00,$AC,$74,$F6)); + {$EXTERNALSYM CLSID_Dither} + CLSID_ModexRenderer: TGUID = (D1:$07167665;D2:$5011;D3:$11CF;D4:($BF,$33,$00,$AA,$00,$55,$59,$5A)); + {$EXTERNALSYM CLSID_ModexRenderer} + CLSID_AudioRender: TGUID = (D1:$E30629D1;D2:$27E5;D3:$11CE;D4:($87,$5D,$00,$60,$8C,$B7,$80,$66)); + {$EXTERNALSYM CLSID_AudioRender} + CLSID_AudioProperties: TGUID = (D1:$05589FAF;D2:$C356;D3:$11CE;D4:($BF,$01,$00,$AA,$00,$55,$59,$5A)); + {$EXTERNALSYM CLSID_AudioProperties} + + CLSID_DSoundRender: TGUID = (D1:$79376820;D2:$07D0;D3:$11CF;D4:($A2,$4D,$00,$20,$AF,$D7,$97,$67)); + {$EXTERNALSYM CLSID_DSoundRender} + CLSID_AudioRecord: TGUID = (D1:$E30629D2;D2:$27E5;D3:$11CE;D4:($87,$5D,$00,$60,$8C,$B7,$80,$66)); + {$EXTERNALSYM CLSID_AudioRecord} + CLSID_AudioInputMixerProperties: TGUID = (D1:$2ca8ca52;D2:$3c3f;D3:$11d2;D4:($b7,$3d,$00,$c0,$4f,$b6,$bd,$3d)); + {$EXTERNALSYM CLSID_AudioInputMixerProperties} + CLSID_AVIDec: TGUID = (D1:$CF49D4E0;D2:$1115;D3:$11CE;D4:($B0,$3A,$00,$20,$AF,$0B,$A7,$70)); + {$EXTERNALSYM CLSID_AVIDec} + CLSID_AVIDraw: TGUID = (D1:$a888df60;D2:$1e90;D3:$11cf;D4:($ac,$98,$00,$aa,$00,$4c,$f,$a9)); + {$EXTERNALSYM CLSID_AVIDraw} + CLSID_ACMWrapper: TGUID = (D1:$6A08CF80;D2:$0E18;D3:$11CF;D4:($A2,$4D,$00,$20,$AF,$D7,$97,$67)); + {$EXTERNALSYM CLSID_ACMWrapper} + CLSID_AsyncReader: TGUID = (D1:$E436EBB5;D2:$524F;D3:$11CE;D4:($9F,$53,$00,$20,$AF,$0B,$A7,$70)); + {$EXTERNALSYM CLSID_AsyncReader} + CLSID_URLReader: TGUID = (D1:$E436EBB6;D2:$524F;D3:$11CE;D4:($9F,$53,$00,$20,$AF,$0B,$A7,$70)); + {$EXTERNALSYM CLSID_URLReader} + CLSID_PersistMonikerPID: TGUID = (D1:$E436EBB7;D2:$524F;D3:$11CE;D4:($9F,$53,$00,$20,$AF,$0B,$A7,$70)); + {$EXTERNALSYM CLSID_PersistMonikerPID} + CLSID_AMovie: TGUID = (D1:$5F2759C0;D2:$7685;D3:$11CF;D4:($8B,$23,$00,$80,$5F,$6C,$EF,$60)); + {$EXTERNALSYM CLSID_AMovie} + CLSID_AVICo: TGUID = (D1:$D76E2820;D2:$1563;D3:$11CF;D4:($AC,$98,$00,$AA,$00,$4C,$0F,$A9)); + {$EXTERNALSYM CLSID_AVICo} + CLSID_FileWriter: TGUID = (D1:$8596E5F0;D2:$0DA5;D3:$11D0;D4:($BD,$21,$00,$A0,$C9,$11,$CE,$86)); + {$EXTERNALSYM CLSID_FileWriter} + + CLSID_AviDest: TGUID = (D1:$E2510970;D2:$F137;D3:$11CE;D4:($8B,$67,$00,$AA,$00,$A3,$F1,$A6)); + {$EXTERNALSYM CLSID_AviDest} + CLSID_AviMuxProptyPage: TGUID = (D1:$C647B5C0;D2:$157C;D3:$11D0;D4:($BD,$23,$00,$A0,$C9,$11,$CE,$86)); + {$EXTERNALSYM CLSID_AviMuxProptyPage} + CLSID_AviMuxProptyPage1: TGUID = (D1:$0A9AE910;D2:$85C0;D3:$11D0;D4:($BD,$42,$00,$A0,$C9,$11,$CE,$86)); + {$EXTERNALSYM CLSID_AviMuxProptyPage1} + CLSID_AVIMIDIRender: TGUID = (D1:$07B65360;D2:$C445;D3:$11CE;D4:($AF,$DE,$00,$AA,$00,$6C,$14,$F4)); + {$EXTERNALSYM CLSID_AVIMIDIRender} + CLSID_WMAsfReader: TGUID = (D1:$187463a0;D2:$5bb7;D3:$11d3;D4:($ac,$be,$00,$80,$c7,$5e,$24,$6e)); + {$EXTERNALSYM CLSID_WMAsfReader} + CLSID_WMAsfWriter: TGUID = (D1:$7c23220e;D2:$55bb;D3:$11d3;D4:($8b,$16,$00,$c0,$4f,$b6,$bd,$3d)); + {$EXTERNALSYM CLSID_WMAsfWriter} + CLSID_MPEG2Demultiplexer: TGUID = (D1:$afb6c280;D2:$2c41;D3:$11d3;D4:($8a,$60,$00,$00,$f8,$1e,$0e,$4a)); + {$EXTERNALSYM CLSID_MPEG2Demultiplexer} + CLSID_MMSPLITTER: TGUID = (D1:$3ae86b20;D2:$7be8;D3:$11d1;D4:($ab,$e6,$00,$a0,$c9,$05,$f3,$75)); + {$EXTERNALSYM CLSID_MMSPLITTER} + + CLSID_StreamBufferSink : TGUID = '{2DB47AE5-CF39-43c2-B4D6-0CD8D90946F4}'; + {$EXTERNALSYM CLSID_StreamBufferSink} + CLSID_StreamBufferSource : TGUID = '{C9F5FE02-F851-4eb5-99EE-AD602AF1E619}'; + {$EXTERNALSYM CLSID_StreamBufferSource} + CLSID_StreamBufferConfig : TGUID = '{FA8A68B2-C864-4ba2-AD53-D3876A87494B}'; + {$EXTERNALSYM CLSID_StreamBufferConfig} + CLSID_Mpeg2VideoStreamAnalyzer : TGUID = '{6CFAD761-735D-4aa5-8AFC-AF91A7D61EBA}'; + {$EXTERNALSYM CLSID_Mpeg2VideoStreamAnalyzer} + CLSID_StreamBufferRecordingAttributes : TGUID = '{CCAA63AC-1057-4778-AE92-1206AB9ACEE6}'; + {$EXTERNALSYM CLSID_StreamBufferRecordingAttributes} + CLSID_StreamBufferComposeRecording : TGUID = '{D682C4BA-A90A-42fe-B9E1-03109849C423}'; + {$EXTERNALSYM CLSID_StreamBufferComposeRecording} + + CLSID_DVVideoCodec: TGUID = (D1:$B1B77C00;D2:$C3E4;D3:$11CF;D4:($AF,$79,$00,$AA,$00,$B6,$7A,$42)); + {$EXTERNALSYM CLSID_DVVideoCodec} + CLSID_DVVideoEnc: TGUID = (D1:$13AA3650;D2:$BB6F;D3:$11D0;D4:($AF,$B9,$00,$AA,$00,$B6,$7A,$42)); + {$EXTERNALSYM CLSID_DVVideoEnc} + CLSID_DVSplitter: TGUID = (D1:$4EB31670;D2:$9FC6;D3:$11CF;D4:($AF,$6E,$00,$AA,$00,$B6,$7A,$42)); + {$EXTERNALSYM CLSID_DVSplitter} + CLSID_DVMux: TGUID = (D1:$129D7E40;D2:$C10D;D3:$11D0;D4:($AF,$B9,$00,$AA,$00,$B6,$7A,$42)); + {$EXTERNALSYM CLSID_DVMux} + CLSID_SeekingPassThru: TGUID = (D1:$060AF76C;D2:$68DD;D3:$11D0;D4:($8F,$C1,$00,$C0,$4F,$D9,$18,$9D)); + {$EXTERNALSYM CLSID_SeekingPassThru} + CLSID_Line21Decoder : TGUID = (D1:$6E8D4A20;D2:$310C;D3:$11D0;D4:($B7,$9A,$00,$AA,$00,$37,$67,$A7)); + {$EXTERNALSYM CLSID_Line21Decoder} + CLSID_Line21Decoder2 : TGUID = '{E4206432-01A1-4BEE-B3E1-3702C8EDC574}'; //Line21 (CC) Decoder v2 + {$EXTERNALSYM CLSID_Line21Decoder2} + CLSID_OverlayMixer: TGUID = (D1:$CD8743A1;D2:$3736;D3:$11D0;D4:($9E,$69,$00,$C0,$4F,$D7,$C1,$5B)); + {$EXTERNALSYM CLSID_OverlayMixer} + CLSID_OverlayMixer2: TGUID = '{A0025E90-E45B-11D1-ABE9-00A0C905F375}'; //Overlay Mixer v2 + {$EXTERNALSYM CLSID_OverlayMixer2} + CLSID_VBISurfaces: TGUID = (D1:$814B9800;D2:$1C88;D3:$11D1;D4:($BA,$D9,$00,$60,$97,$44,$11,$1A)); + {$EXTERNALSYM CLSID_VBISurfaces} + CLSID_WSTDecoder : TGUID = '{70BC06E0-5666-11d3-A184-00105AEF9F33}'; //WST Teletext Decoder + {$EXTERNALSYM CLSID_WSTDecoder} + CLSID_MjpegDec : TGUID = '{301056D0-6DFF-11d2-9EEB-006008039E37}'; + {$EXTERNALSYM CLSID_MjpegDec} + CLSID_MJPGEnc : TGUID = '{B80AB0A0-7416-11d2-9EEB-006008039E37}'; + {$EXTERNALSYM CLSID_MJPGEnc} + +// pnp objects and categories + CLSID_SystemDeviceEnum: TGUID = (D1:$62BE5D10;D2:$60EB;D3:$11D0;D4:($BD,$3B,$00,$A0,$C9,$11,$CE,$86)); + {$EXTERNALSYM CLSID_SystemDeviceEnum} + CLSID_CDeviceMoniker: TGUID = (D1:$4315D437;D2:$5B8C;D3:$11D0;D4:($BD,$3B,$00,$A0,$C9,$11,$CE,$86)); + {$EXTERNALSYM CLSID_CDeviceMoniker} + CLSID_VideoInputDeviceCategory: TGUID = (D1:$860BB310;D2:$5D01;D3:$11D0;D4:($BD,$3B,$00,$A0,$C9,$11,$CE,$86)); + {$EXTERNALSYM CLSID_VideoInputDeviceCategory} + CLSID_CVidCapClassManager: TGUID = (D1:$860BB310;D2:$5D01;D3:$11D0;D4:($BD,$3B,$00,$A0,$C9,$11,$CE,$86)); + {$EXTERNALSYM CLSID_CVidCapClassManager} + CLSID_LegacyAmFilterCategory: TGUID = (D1:$083863F1;D2:$70DE;D3:$11D0;D4:($BD,$40,$00,$A0,$C9,$11,$CE,$86)); + {$EXTERNALSYM CLSID_LegacyAmFilterCategory} + CLSID_CQzFilterClassManager: TGUID = (D1:$083863F1;D2:$70DE;D3:$11D0;D4:($BD,$40,$00,$A0,$C9,$11,$CE,$86)); + {$EXTERNALSYM CLSID_CQzFilterClassManager} + CLSID_VideoCompressorCategory: TGUID = (D1:$33D9A760;D2:$90C8;D3:$11D0;D4:($BD,$43,$00,$A0,$C9,$11,$CE,$86)); + {$EXTERNALSYM CLSID_VideoCompressorCategory} + CLSID_CIcmCoClassManager: TGUID = (D1:$33D9A760;D2:$90C8;D3:$11D0;D4:($BD,$43,$00,$A0,$C9,$11,$CE,$86)); + {$EXTERNALSYM CLSID_CIcmCoClassManager} + CLSID_AudioCompressorCategory: TGUID = (D1:$33D9A761;D2:$90C8;D3:$11D0;D4:($BD,$43,$00,$A0,$C9,$11,$CE,$86)); + {$EXTERNALSYM CLSID_AudioCompressorCategory} + CLSID_CAcmCoClassManager: TGUID = (D1:$33D9A761;D2:$90C8;D3:$11D0;D4:($BD,$43,$00,$A0,$C9,$11,$CE,$86)); + {$EXTERNALSYM CLSID_CAcmCoClassManager} + CLSID_AudioInputDeviceCategory: TGUID = (D1:$33D9A762;D2:$90C8;D3:$11D0;D4:($BD,$43,$00,$A0,$C9,$11,$CE,$86)); + {$EXTERNALSYM CLSID_AudioInputDeviceCategory} + CLSID_CWaveinClassManager: TGUID = (D1:$33D9A762;D2:$90C8;D3:$11D0;D4:($BD,$43,$00,$A0,$C9,$11,$CE,$86)); + {$EXTERNALSYM CLSID_CWaveinClassManager} + CLSID_AudioRendererCategory: TGUID = (D1:$E0F158E1;D2:$CB04;D3:$11D0;D4:($BD,$4E,$00,$A0,$C9,$11,$CE,$86)); + {$EXTERNALSYM CLSID_AudioRendererCategory} + CLSID_CWaveOutClassManager: TGUID = (D1:$E0F158E1;D2:$CB04;D3:$11D0;D4:($BD,$4E,$00,$A0,$C9,$11,$CE,$86)); + {$EXTERNALSYM CLSID_CWaveOutClassManager} + CLSID_MidiRendererCategory: TGUID = (D1:$4EFE2452;D2:$168A;D3:$11D1;D4:($BC,$76,$00,$C0,$4F,$B9,$45,$3B)); + {$EXTERNALSYM CLSID_MidiRendererCategory} + CLSID_CMidiOutClassManager: TGUID = (D1:$4EFE2452;D2:$168A;D3:$11D1;D4:($BC,$76,$00,$C0,$4F,$B9,$45,$3B)); + {$EXTERNALSYM CLSID_CMidiOutClassManager} + CLSID_TransmitCategory: TGUID = (D1:$cc7bfb41;D2:$f175;D3:$11d1;D4:($a3,$92,$00,$e0,$29,$1f,$39,$59)); + {$EXTERNALSYM CLSID_TransmitCategory} + CLSID_DeviceControlCategory: TGUID = (D1:$cc7bfb46;D2:$f175;D3:$11d1;D4:($a3,$92,$00,$e0,$29,$1f,$39,$59)); + {$EXTERNALSYM CLSID_DeviceControlCategory} + CLSID_ActiveMovieCategories: TGUID = (D1:$DA4E3DA0;D2:$D07D;D3:$11D0;D4:($BD,$50,$00,$A0,$C9,$11,$CE,$86)); + {$EXTERNALSYM CLSID_ActiveMovieCategories} + CLSID_DVDHWDecodersCategory: TGUID = (D1:$2721AE20;D2:$7E70;D3:$11D0;D4:($A5,$D6,$28,$DB,$04,$C1,$00,$00)); + {$EXTERNALSYM CLSID_DVDHWDecodersCategory} + + CLSID_MediaEncoderCategory : TGUID = '{7D22E920-5CA9-4787-8C2B-A6779BD11781}'; // Encoder API encoder category + {$EXTERNALSYM CLSID_MediaEncoderCategory} + CLSID_MediaMultiplexerCategory : TGUID = '{236C9559-ADCE-4736-BF72-BAB34E392196}'; // Encoder API multiplexer category + {$EXTERNALSYM CLSID_MediaMultiplexerCategory} + + CLSID_FilterMapper2: TGUID = (D1:$CDA42200;D2:$BD88;D3:$11D0;D4:($BD,$4E,$00,$A0,$C9,$11,$CE,$86)); + {$EXTERNALSYM CLSID_FilterMapper2} + CLSID_MemoryAllocator: TGUID = (D1:$1E651CC0;D2:$B199;D3:$11D0;D4:($82,$12,$00,$C0,$4F,$C3,$2C,$45)); + {$EXTERNALSYM CLSID_MemoryAllocator} + CLSID_MediaPropertyBag: TGUID = (D1:$CDBD8D00;D2:$C193;D3:$11D0;D4:($BD,$4E,$00,$A0,$C9,$11,$CE,$86)); + {$EXTERNALSYM CLSID_MediaPropertyBag} + CLSID_DvdGraphBuilder: TGUID = (D1:$FCC152B7;D2:$F372;D3:$11D0;D4:($8E,$00,$00,$C0,$4F,$D7,$C0,$8B)); + {$EXTERNALSYM CLSID_DvdGraphBuilder} + CLSID_DVDNavigator: TGUID = (D1:$9B8C4620;D2:$2C1A;D3:$11D0;D4:($84,$93,$00,$A0,$24,$38,$AD,$48)); + {$EXTERNALSYM CLSID_DVDNavigator} + CLSID_DVDState: TGUID = (D1:$f963c5cf;D2:$a659;D3:$4a93;D4:($96,$38,$ca,$f3,$cd,$27,$7d,$13)); + {$EXTERNALSYM CLSID_DVDState} + CLSID_SmartTee: TGUID = (D1:$cc58e280;D2:$8aa1;D3:$11d1;D4:($b3,$f1,$00,$aa,$00,$37,$61,$c5)); + {$EXTERNALSYM CLSID_SmartTee} + +// -- format types --- + FORMAT_None: TGUID = (D1:$0F6417D6;D2:$C318;D3:$11D0;D4:($A4,$3F,$00,$A0,$C9,$22,$31,$96)); + {$EXTERNALSYM FORMAT_None} + FORMAT_VideoInfo: TGUID = (D1:$05589F80;D2:$C356;D3:$11CE;D4:($BF,$01,$00,$AA,$00,$55,$59,$5A)); + {$EXTERNALSYM FORMAT_VideoInfo} + FORMAT_VideoInfo2: TGUID = (D1:$F72A76A0;D2:$EB0A;D3:$11D0;D4:($AC,$E4,$00,$00,$C0,$CC,$16,$BA)); + {$EXTERNALSYM FORMAT_VideoInfo2} + FORMAT_WaveFormatEx: TGUID = (D1:$05589F81;D2:$C356;D3:$11CE;D4:($BF,$01,$00,$AA,$00,$55,$59,$5A)); + {$EXTERNALSYM FORMAT_WaveFormatEx} + FORMAT_MPEGVideo: TGUID = (D1:$05589F82;D2:$C356;D3:$11CE;D4:($BF,$01,$00,$AA,$00,$55,$59,$5A)); + {$EXTERNALSYM FORMAT_MPEGVideo} + FORMAT_MPEGStreams: TGUID = (D1:$05589F83;D2:$C356;D3:$11CE;D4:($BF,$01,$00,$AA,$00,$55,$59,$5A)); + {$EXTERNALSYM FORMAT_MPEGStreams} + FORMAT_DvInfo: TGUID = (D1:$05589F84;D2:$C356;D3:$11CE;D4:($BF,$01,$00,$AA,$00,$55,$59,$5A)); + {$EXTERNALSYM FORMAT_DvInfo} + + +// -- Video related GUIDs --- + CLSID_DirectDrawProperties: TGUID = (D1:$944D4C00;D2:$DD52;D3:$11CE;D4:($BF,$0E,$00,$AA,$00,$55,$59,$5A)); + {$EXTERNALSYM CLSID_DirectDrawProperties} + CLSID_PerformanceProperties: TGUID = (D1:$59CE6880;D2:$ACF8;D3:$11CF;D4:($B5,$6E,$00,$80,$C7,$C4,$B6,$8A)); + {$EXTERNALSYM CLSID_PerformanceProperties} + CLSID_QualityProperties: TGUID = (D1:$418AFB70;D2:$F8B8;D3:$11CE;D4:($AA,$C6,$00,$20,$AF,$0B,$99,$A3)); + {$EXTERNALSYM CLSID_QualityProperties} + CLSID_VPObject: TGUID = (D1:$CE292861;D2:$FC88;D3:$11D0;D4:($9E,$69,$00,$C0,$4F,$D7,$C1,$5B)); + {$EXTERNALSYM CLSID_VPObject} + IID_IVPObject: TGUID = (D1:$CE292862;D2:$FC88;D3:$11D0;D4:($9E,$69,$00,$C0,$4F,$D7,$C1,$5B)); + {$EXTERNALSYM IID_IVPObject} + IID_IVPControl: TGUID = (D1:$25DF12C1;D2:$3DE0;D3:$11D1;D4:($9E,$69,$00,$C0,$4F,$D7,$C1,$5B)); + {$EXTERNALSYM IID_IVPControl} + CLSID_VPVBIObject: TGUID = (D1:$814B9801;D2:$1C88;D3:$11D1;D4:($BA,$D9,$00,$60,$97,$44,$11,$1A)); + {$EXTERNALSYM CLSID_VPVBIObject} + IID_IVPVBIObject: TGUID = (D1:$814B9802;D2:$1C88;D3:$11D1;D4:($BA,$D9,$00,$60,$97,$44,$11,$1A)); + {$EXTERNALSYM IID_IVPVBIObject} + + CLSID_ModexProperties: TGUID = (D1:$0618AA30;D2:$6BC4;D3:$11CF;D4:($BF,$36,$00,$AA,$00,$55,$59,$5A)); + {$EXTERNALSYM CLSID_ModexProperties} + +// DV decoder property + CLSID_DVDecPropertiesPage: TGUID = (D1:$101193C0;D2:$0BFE;D3:$11D0;D4:($AF,$91,$00,$AA,$00,$B6,$7A,$42)); + {$EXTERNALSYM CLSID_DVDecPropertiesPage} + +// DV encoder property + CLSID_DVEncPropertiesPage: TGUID = (D1:$4150F050;D2:$BB6F;D3:$11D0;D4:($AF,$B9,$00,$AA,$00,$B6,$7A,$42)); + {$EXTERNALSYM CLSID_DVEncPropertiesPage} + +// DV Muxer property + CLSID_DVMuxPropertyPage: TGUID = (D1:$4DB880E0;D2:$C10D;D3:$11D0;D4:($AF,$B9,$00,$AA,$00,$B6,$7A,$42)); + {$EXTERNALSYM CLSID_DVMuxPropertyPage} + + +// -- Analog video related GUIDs --- + + +// -- format types --- + FORMAT_AnalogVideo : TGUID = (D1:$0482DDE0;D2:$7817;D3:$11CF;D4:($8A,$03,$00,$AA,$00,$6E,$CB,$65)); + {$EXTERNALSYM FORMAT_AnalogVideo} + + MEDIATYPE_AnalogAudio : TGUID = '{0482DEE1-7817-11cf-8a03-00aa006ecb65}'; + {$EXTERNALSYM MEDIATYPE_AnalogAudio} + MEDIATYPE_AnalogVideo : TGUID = (D1:$0482DDE1;D2:$7817;D3:$11CF;D4:($8A,$03,$00,$AA,$00,$6E,$CB,$65)); + {$EXTERNALSYM MEDIATYPE_AnalogVideo} + MEDIASUBTYPE_AnalogVideo_NTSC_M: TGUID = (D1:$0482DDE2;D2:$7817;D3:$11CF;D4:($8A,$03,$00,$AA,$00,$6E,$CB,$65)); + {$EXTERNALSYM MEDIASUBTYPE_AnalogVideo_NTSC_M} + MEDIASUBTYPE_AnalogVideo_PAL_B: TGUID = (D1:$0482DDE5;D2:$7817;D3:$11CF;D4:($8A,$03,$00,$AA,$00,$6E,$CB,$65)); + {$EXTERNALSYM MEDIASUBTYPE_AnalogVideo_PAL_B} + MEDIASUBTYPE_AnalogVideo_PAL_D: TGUID = (D1:$0482DDE6;D2:$7817;D3:$11CF;D4:($8A,$03,$00,$AA,$00,$6E,$CB,$65)); + {$EXTERNALSYM MEDIASUBTYPE_AnalogVideo_PAL_D} + MEDIASUBTYPE_AnalogVideo_PAL_G: TGUID = (D1:$0482DDE7;D2:$7817;D3:$11CF;D4:($8A,$03,$00,$AA,$00,$6E,$CB,$65)); + {$EXTERNALSYM MEDIASUBTYPE_AnalogVideo_PAL_G} + MEDIASUBTYPE_AnalogVideo_PAL_H: TGUID = (D1:$0482DDE8;D2:$7817;D3:$11CF;D4:($8A,$03,$00,$AA,$00,$6E,$CB,$65)); + {$EXTERNALSYM MEDIASUBTYPE_AnalogVideo_PAL_H} + MEDIASUBTYPE_AnalogVideo_PAL_I: TGUID = (D1:$0482DDE9;D2:$7817;D3:$11CF;D4:($8A,$03,$00,$AA,$00,$6E,$CB,$65)); + {$EXTERNALSYM MEDIASUBTYPE_AnalogVideo_PAL_I} + MEDIASUBTYPE_AnalogVideo_PAL_M: TGUID = (D1:$0482DDEA;D2:$7817;D3:$11CF;D4:($8A,$03,$00,$AA,$00,$6E,$CB,$65)); + {$EXTERNALSYM MEDIASUBTYPE_AnalogVideo_PAL_M} + MEDIASUBTYPE_AnalogVideo_PAL_N : TGUID = (D1:$0482DDEB;D2:$7817;D3:$11CF;D4:($8A,$03,$00,$AA,$00,$6E,$CB,$65)); + {$EXTERNALSYM MEDIASUBTYPE_AnalogVideo_PAL_N} + MEDIASUBTYPE_AnalogVideo_PAL_N_COMBO: TGUID = (D1:$482ddec;D2:$7817;D3:$11cf;D4:($8a,$3,$00,$aa,$00,$6e,$cb,$65)); + {$EXTERNALSYM MEDIASUBTYPE_AnalogVideo_PAL_N_COMBO} + +// -- Analog Video subtypes, SECAM + MEDIASUBTYPE_AnalogVideo_SECAM_B: TGUID = (D1:$0482DDF0;D2:$7817;D3:$11CF;D4:($8A,$03,$00,$AA,$00,$6E,$CB,$65)); + {$EXTERNALSYM MEDIASUBTYPE_AnalogVideo_SECAM_B} + MEDIASUBTYPE_AnalogVideo_SECAM_D: TGUID = (D1:$0482DDF1;D2:$7817;D3:$11CF;D4:($8A,$03,$00,$AA,$00,$6E,$CB,$65)); + {$EXTERNALSYM MEDIASUBTYPE_AnalogVideo_SECAM_D} + MEDIASUBTYPE_AnalogVideo_SECAM_G: TGUID = (D1:$0482DDF2;D2:$7817;D3:$11CF;D4:($8A,$03,$00,$AA,$00,$6E,$CB,$65)); + {$EXTERNALSYM MEDIASUBTYPE_AnalogVideo_SECAM_G} + MEDIASUBTYPE_AnalogVideo_SECAM_H: TGUID = (D1:$0482DDF3;D2:$7817;D3:$11CF;D4:($8A,$03,$00,$AA,$00,$6E,$CB,$65)); + {$EXTERNALSYM MEDIASUBTYPE_AnalogVideo_SECAM_H} + MEDIASUBTYPE_AnalogVideo_SECAM_K: TGUID = (D1:$0482DDF4;D2:$7817;D3:$11CF;D4:($8A,$03,$00,$AA,$00,$6E,$CB,$65)); + {$EXTERNALSYM MEDIASUBTYPE_AnalogVideo_SECAM_K} + MEDIASUBTYPE_AnalogVideo_SECAM_K1: TGUID = (D1:$0482DDF5;D2:$7817;D3:$11CF;D4:($8A,$03,$00,$AA,$00,$6E,$CB,$65)); + {$EXTERNALSYM MEDIASUBTYPE_AnalogVideo_SECAM_K1} + MEDIASUBTYPE_AnalogVideo_SECAM_L: TGUID = (D1:$0482DDF6;D2:$7817;D3:$11CF;D4:($8A,$03,$00,$AA,$00,$6E,$CB,$65)); + {$EXTERNALSYM MEDIASUBTYPE_AnalogVideo_SECAM_L} + +// -- Well known time format GUIDs --- + TIME_FORMAT_NONE: TGUID = (D1:$00000000;D2:$0000;D3:$0000;D4:($00,$00,$00,$00,$00,$00,$00,$00)); + {$EXTERNALSYM TIME_FORMAT_NONE} + TIME_FORMAT_FRAME: TGUID = (D1:$7B785570;D2:$8C82;D3:$11CF;D4:($BC,$0C,$00,$AA,$00,$AC,$74,$F6)); + {$EXTERNALSYM TIME_FORMAT_FRAME} + TIME_FORMAT_BYTE: TGUID = (D1:$7B785571;D2:$8C82;D3:$11CF;D4:($BC,$0C,$00,$AA,$00,$AC,$74,$F6)); + {$EXTERNALSYM TIME_FORMAT_BYTE} + TIME_FORMAT_SAMPLE: TGUID = (D1:$7B785572;D2:$8C82;D3:$11CF;D4:($BC,$0C,$00,$AA,$00,$AC,$74,$F6)); + {$EXTERNALSYM TIME_FORMAT_SAMPLE} + TIME_FORMAT_FIELD: TGUID = (D1:$7B785573;D2:$8C82;D3:$11CF;D4:($BC,$0C,$00,$AA,$00,$AC,$74,$F6)); + {$EXTERNALSYM TIME_FORMAT_FIELD} + TIME_FORMAT_MEDIA_TIME: TGUID = (D1:$7B785574;D2:$8C82;D3:$11CF;D4:($BC,$0C,$00,$AA,$00,$AC,$74,$F6)); + {$EXTERNALSYM TIME_FORMAT_MEDIA_TIME} + +// for IKsPropertySet + AMPROPSETID_Pin: TGUID = (D1:$9B00F101;D2:$1567;D3:$11D1;D4:($B3,$F1,$00,$AA,$00,$37,$61,$C5)); + {$EXTERNALSYM AMPROPSETID_Pin} + PIN_CATEGORY_CAPTURE: TGUID = (D1:$FB6C4281;D2:$0353;D3:$11D1;D4:($90,$5F,$00,$00,$C0,$CC,$16,$BA)); + {$EXTERNALSYM PIN_CATEGORY_CAPTURE} + PIN_CATEGORY_PREVIEW: TGUID = (D1:$FB6C4282;D2:$0353;D3:$11D1;D4:($90,$5F,$00,$00,$C0,$CC,$16,$BA)); + {$EXTERNALSYM PIN_CATEGORY_PREVIEW} + PIN_CATEGORY_ANALOGVIDEOIN: TGUID = (D1:$FB6C4283;D2:$0353;D3:$11D1;D4:($90,$5F,$00,$00,$C0,$CC,$16,$BA)); + {$EXTERNALSYM PIN_CATEGORY_ANALOGVIDEOIN} + PIN_CATEGORY_VBI: TGUID = (D1:$FB6C4284;D2:$0353;D3:$11D1;D4:($90,$5F,$00,$00,$C0,$CC,$16,$BA)); + {$EXTERNALSYM PIN_CATEGORY_VBI} + PIN_CATEGORY_VIDEOPORT: TGUID = (D1:$FB6C4285;D2:$0353;D3:$11D1;D4:($90,$5F,$00,$00,$C0,$CC,$16,$BA)); + {$EXTERNALSYM PIN_CATEGORY_VIDEOPORT} + PIN_CATEGORY_NABTS: TGUID = (D1:$FB6C4286;D2:$0353;D3:$11D1;D4:($90,$5F,$00,$00,$C0,$CC,$16,$BA)); + {$EXTERNALSYM PIN_CATEGORY_NABTS} + PIN_CATEGORY_EDS: TGUID = (D1:$FB6C4287;D2:$0353;D3:$11D1;D4:($90,$5F,$00,$00,$C0,$CC,$16,$BA)); + {$EXTERNALSYM PIN_CATEGORY_EDS} + PIN_CATEGORY_TELETEXT: TGUID = (D1:$FB6C4288;D2:$0353;D3:$11D1;D4:($90,$5F,$00,$00,$C0,$CC,$16,$BA)); + {$EXTERNALSYM PIN_CATEGORY_TELETEXT} + PIN_CATEGORY_CC: TGUID = (D1:$FB6C4289;D2:$0353;D3:$11D1;D4:($90,$5F,$00,$00,$C0,$CC,$16,$BA)); + {$EXTERNALSYM PIN_CATEGORY_CC} + PIN_CATEGORY_STILL: TGUID = (D1:$FB6C428A;D2:$0353;D3:$11D1;D4:($90,$5F,$00,$00,$C0,$CC,$16,$BA)); + {$EXTERNALSYM PIN_CATEGORY_STILL} + PIN_CATEGORY_TIMECODE: TGUID = (D1:$FB6C428B;D2:$0353;D3:$11D1;D4:($90,$5F,$00,$00,$C0,$CC,$16,$BA)); + {$EXTERNALSYM PIN_CATEGORY_TIMECODE} + PIN_CATEGORY_VIDEOPORT_VBI: TGUID = (D1:$FB6C428C;D2:$0353;D3:$11D1;D4:($90,$5F,$00,$00,$C0,$CC,$16,$BA)); + {$EXTERNALSYM PIN_CATEGORY_VIDEOPORT_VBI} + +// the following special GUIDS are used by ICaptureGraphBuilder::FindInterface + LOOK_UPSTREAM_ONLY: TGUID = (D1:$ac798be0;D2:$98e3;D3:$11d1;D4:($b3,$f1,$0,$aa,$0,$37,$61,$c5)); + {$EXTERNALSYM LOOK_UPSTREAM_ONLY} + LOOK_DOWNSTREAM_ONLY: TGUID = (D1:$ac798be1;D2:$98e3;D3:$11d1;D4:($b3,$f1,$0,$aa,$0,$37,$61,$c5)); + {$EXTERNALSYM LOOK_DOWNSTREAM_ONLY} + +// ------------------------------------------------------------------------- +// KSProxy GUIDS +// ------------------------------------------------------------------------- + + CLSID_TVTunerFilterPropertyPage: TGUID = (D1:$266EEE41;D2:$6C63;D3:$11CF;D4:($8A,$03,$00,$AA,$00,$6E,$CB,$65)); + {$EXTERNALSYM CLSID_TVTunerFilterPropertyPage} + CLSID_CrossbarFilterPropertyPage: TGUID = (D1:$71F96461;D2:$78F3;D3:$11D0;D4:($A1,$8C,$00,$A0,$C9,$11,$89,$56)); + {$EXTERNALSYM CLSID_CrossbarFilterPropertyPage} + CLSID_TVAudioFilterPropertyPage: TGUID = (D1:$71F96463;D2:$78F3;D3:$11D0;D4:($A1,$8C,$00,$A0,$C9,$11,$89,$56)); + {$EXTERNALSYM CLSID_TVAudioFilterPropertyPage} + CLSID_VideoProcAmpPropertyPage: TGUID = (D1:$71F96464;D2:$78F3;D3:$11D0;D4:($A1,$8C,$00,$A0,$C9,$11,$89,$56)); + {$EXTERNALSYM CLSID_VideoProcAmpPropertyPage} + CLSID_CameraControlPropertyPage: TGUID = (D1:$71F96465;D2:$78F3;D3:$11D0;D4:($A1,$8C,$00,$A0,$C9,$11,$89,$56)); + {$EXTERNALSYM CLSID_CameraControlPropertyPage} + CLSID_AnalogVideoDecoderPropertyPage: TGUID = (D1:$71F96466;D2:$78F3;D3:$11D0;D4:($A1,$8C,$00,$A0,$C9,$11,$89,$56)); + {$EXTERNALSYM CLSID_AnalogVideoDecoderPropertyPage} + CLSID_VideoStreamConfigPropertyPage: TGUID = (D1:$71F96467;D2:$78F3;D3:$11D0;D4:($A1,$8C,$00,$A0,$C9,$11,$89,$56)); + {$EXTERNALSYM CLSID_VideoStreamConfigPropertyPage} + CLSID_AudioRendererAdvancedProperties: TGUID = (D1:$37e92a92;D2:$d9aa;D3:$11d2;D4:($bf,$84,$8e,$f2,$b1,$55,$5a,$ed)); + {$EXTERNALSYM CLSID_AudioRendererAdvancedProperties} + +// ------------------------------------------------------------------------- +// VMRender GUIDS DX8 +// ------------------------------------------------------------------------- + CLSID_VideoMixingRenderer : TGUID = (D1:$B87BEB7B;D2:$8D29;D3:$423f;D4:($AE,$4D,$65,$82,$C1,$01,$75,$AC)); + {$EXTERNALSYM CLSID_VideoMixingRenderer} + CLSID_VideoRendererDefault : TGUID = '{6BC1CFFA-8FC1-4261-AC22-CFB4CC38DB50}'; + {$EXTERNALSYM CLSID_VideoRendererDefault} + CLSID_AllocPresenter : TGUID = '{99d54f63-1a69-41ae-aa4d-c976eb3f0713}'; + {$EXTERNALSYM CLSID_AllocPresenter} + CLSID_AllocPresenterDDXclMode : TGUID = '{4444ac9e-242e-471b-a3c7-45dcd46352bc}'; + {$EXTERNALSYM CLSID_AllocPresenterDDXclMode} + CLSID_VideoPortManager : TGUID = '{6f26a6cd-967b-47fd-874a-7aed2c9d25a2}'; + {$EXTERNALSYM CLSID_VideoPortManager} + CLSID_ImageSynchronization : TGUID = '{7D8AA343-6E63-4663-BE90-6B80F66540A3}'; + {$EXTERNALSYM CLSID_ImageSynchronization} + CLSID_VideoMixer : TGUID = '{06b32aee-77da-484b-973b-5d64f47201b0}'; + {$EXTERNALSYM CLSID_VideoMixer} +// ------------------------------------------------------------------------- +// VMR GUIDS for DX9 +// ------------------------------------------------------------------------- + + CLSID_VideoMixingRenderer9 : TGUID = '{51b4abf3-748f-4e3b-a276-c828330e926a}'; + {$EXTERNALSYM CLSID_VideoMixingRenderer9} + CLSID_AllocPresenter9 : TGUID = '{2D2E24CB-0CD5-458F-86EA-3E6FA22C8E64}'; // Found in Registry, Should'nt be used directly + {$EXTERNALSYM CLSID_AllocPresenter9} + CLSID_ImageSynchronization9 : TGUID = '{E4979309-7A32-495E-8A92-7B014AAD4961}'; // Found in Registry + {$EXTERNALSYM CLSID_ImageSynchronization9} + +// ------------------------------------------------------------------------- +// BDA Network Provider GUIDS +// ------------------------------------------------------------------------- + CLSID_ATSCNetworkProvider : TGUID = (D1:$0dad2fdd;D2:$5fd7;D3:$11d3;D4:($8f,$50,$00,$c0,$4f,$79,$71,$e2)); + {$EXTERNALSYM CLSID_ATSCNetworkProvider} + CLSID_ATSCNetworkPropertyPage: TGUID = (D1:$e3444d16;D2:$5ac4;D3:$4386;D4:($88,$df,$13,$fd,$23,$0e,$1d,$da)); + {$EXTERNALSYM CLSID_ATSCNetworkPropertyPage} + CLSID_DVBSNetworkProvider : TGUID = (D1:$fa4b375a;D2:$45b4;D3:$4d45;D4:($84,$40,$26,$39,$57,$b1,$16,$23)); + {$EXTERNALSYM CLSID_DVBSNetworkProvider} + CLSID_DVBTNetworkProvider : TGUID = '{216C62DF-6D7F-4e9a-8571-05F14EDB766A}'; + {$EXTERNALSYM CLSID_DVBTNetworkProvider} + CLSID_DVBCNetworkProvider : TGUID = '{DC0C0FE7-0485-4266-B93F-68FBF80ED834}'; + {$EXTERNALSYM CLSID_DVBCNetworkProvider} + + +// --- WST Decoder interface GUID --- + IID_IAMWstDecoder : TGUID = '{C056DE21-75C2-11d3-A184-00105AEF9F33}'; // IID_IAMWstDecoder + {$EXTERNALSYM IID_IAMWstDecoder} +// --- WST Decoder Property Page --- + CLSID_WstDecoderPropertyPage : TGUID = '{04E27F80-91E4-11d3-A184-00105AEF9F33}'; // WST Decoder Property Page + {$EXTERNALSYM CLSID_WstDecoderPropertyPage} + +// ------------------------------------------------------------------------- +// TVE Receiver filter guids +// ------------------------------------------------------------------------- + +// The CLSID used by the TVE Receiver filter + CLSID_DShowTVEFilter : TGUID = '{05500280-FAA5-4DF9-8246-BFC23AC5CEA8}'; + {$EXTERNALSYM CLSID_DShowTVEFilter} + CLSID_TVEFilterTuneProperties : TGUID = '{05500281-FAA5-4DF9-8246-BFC23AC5CEA8}'; + {$EXTERNALSYM CLSID_TVEFilterTuneProperties} + CLSID_TVEFilterCCProperties : TGUID = '{05500282-FAA5-4DF9-8246-BFC23AC5CEA8}'; + {$EXTERNALSYM CLSID_TVEFilterCCProperties} + CLSID_TVEFilterStatsProperties : TGUID = '{05500283-FAA5-4DF9-8246-BFC23AC5CEA8}'; + {$EXTERNALSYM CLSID_TVEFilterStatsProperties} + +// ------------------------------------------------------------------------- +// Defined ENCAPI parameter GUIDs +// ------------------------------------------------------------------------- + + // The CLSID for the original IVideoEncoder proxy plug-in + CLSID_IVideoEncoderProxy : TGUID = '{B43C4EEC-8C32-4791-9102-508ADA5EE8E7}'; + {$EXTERNALSYM CLSID_IVideoEncoderProxy} + + // The CLSID for the ICodecAPI proxy plug-in + CLSID_ICodecAPIProxy : TGUID = '{7ff0997a-1999-4286-a73c-622b8814e7eb}'; + {$EXTERNALSYM CLSID_ICodecAPIProxy} + + // The CLSID for the combination ICodecAPI/IVideoEncoder proxy plug-in + CLSID_IVideoEncoderCodecAPIProxy : TGUID = '{b05dabd9-56e5-4fdc-afa4-8a47e91f1c9c}'; + {$EXTERNALSYM CLSID_IVideoEncoderCodecAPIProxy} + + ENCAPIPARAM_BITRATE : TGUID = '{49CC4C43-CA83-4ad4-A9AF-F3696AF666DF}'; + {$EXTERNALSYM ENCAPIPARAM_BITRATE} + ENCAPIPARAM_PEAK_BITRATE : TGUID = '{703F16A9-3D48-44a1-B077-018DFF915D19}'; + {$EXTERNALSYM ENCAPIPARAM_PEAK_BITRATE} + ENCAPIPARAM_BITRATE_MODE : TGUID = '{EE5FB25C-C713-40d1-9D58-C0D7241E250F}'; + {$EXTERNALSYM ENCAPIPARAM_BITRATE_MODE} + + // for kernel control + + CODECAPI_CHANGELISTS : TGUID = '{62b12acf-f6b0-47d9-9456-96f22c4e0b9d}'; + {$EXTERNALSYM CODECAPI_CHANGELISTS} + CODECAPI_VIDEO_ENCODER : TGUID = '{7112e8e1-3d03-47ef-8e60-03f1cf537301}'; + {$EXTERNALSYM CODECAPI_VIDEO_ENCODER} + CODECAPI_AUDIO_ENCODER : TGUID = '{b9d19a3e-f897-429c-bc46-8138b7272b2d}'; + {$EXTERNALSYM CODECAPI_AUDIO_ENCODER} + CODECAPI_SETALLDEFAULTS : TGUID = '{6c5e6a7c-acf8-4f55-a999-1a628109051b}'; + {$EXTERNALSYM CODECAPI_SETALLDEFAULTS} + CODECAPI_ALLSETTINGS : TGUID = '{6a577e92-83e1-4113-adc2-4fcec32f83a1}'; + {$EXTERNALSYM CODECAPI_ALLSETTINGS} + CODECAPI_SUPPORTSEVENTS : TGUID = '{0581af97-7693-4dbd-9dca-3f9ebd6585a1}'; + {$EXTERNALSYM CODECAPI_SUPPORTSEVENTS} + CODECAPI_CURRENTCHANGELIST : TGUID = '{1cb14e83-7d72-4657-83fd-47a2c5b9d13d}'; + {$EXTERNALSYM CODECAPI_CURRENTCHANGELIST} + +(*==========================================================================; + * + * Copyright (C) 1996-1997 Microsoft Corporation. All Rights Reserved. + * + * File: ksuuids.h + * + ***************************************************************************) +// contains the GUIDs for the MediaType type, subtype fields and format types +// for DVD/MPEG2 media types. + +const +// --- MPEG 2 definitions --- + MEDIATYPE_MPEG2_PACK: TGUID = (D1:$36523B13;D2:$8EE5;D3:$11d1;D4:($8C,$A3,$00,$60,$B0,$57,$66,$4A)); + {$EXTERNALSYM MEDIATYPE_MPEG2_PACK} + MEDIATYPE_MPEG2_PES: TGUID = (D1:$e06d8020;D2:$db46;D3:$11cf;D4:($b4,$d1,$00,$80,$5f,$6c,$bb,$ea)); + {$EXTERNALSYM MEDIATYPE_MPEG2_PES} + MEDIATYPE_CONTROL: TGUID = (D1:$e06d8021;D2:$db46;D3:$11cf;D4:($b4,$d1,$00,$80,$5f,$6c,$bb,$ea)); + {$EXTERNALSYM MEDIATYPE_CONTROL} + MEDIASUBTYPE_MPEG2_VIDEO: TGUID = (D1:$e06d8026;D2:$db46;D3:$11cf;D4:($b4,$d1,$00,$80,$5f,$6c,$bb,$ea)); + {$EXTERNALSYM MEDIASUBTYPE_MPEG2_VIDEO} + + MEDIATYPE_MPEG2_SECTIONS : TGUID = '{455f176c-4b06-47ce-9aef-8caef73df7b5}'; + {$EXTERNALSYM MEDIATYPE_MPEG2_SECTIONS} + MEDIASUBTYPE_ATSC_SI : TGUID = '{b3c7397c-d303-414d-b33c-4ed2c9d29733}'; + {$EXTERNALSYM MEDIASUBTYPE_ATSC_SI} + MEDIASUBTYPE_DVB_SI : TGUID = '{e9dd31a3-221d-4adb-8532-9af309c1a408}'; + {$EXTERNALSYM MEDIASUBTYPE_DVB_SI} + MEDIASUBTYPE_MPEG2DATA : TGUID = '{C892E55B-252D-42b5-A316-D997E7A5D995}'; + {$EXTERNALSYM MEDIASUBTYPE_MPEG2DATA} + + +// use MPEG2VIDEOINFO (defined below) with FORMAT_MPEG2_VIDEO + FORMAT_MPEG2_VIDEO: TGUID = (D1:$e06d80e3;D2:$db46;D3:$11cf;D4:($b4,$d1,$00,$80,$5f,$6c,$bb,$ea)); + {$EXTERNALSYM FORMAT_MPEG2_VIDEO} + +// MPEG2 Other subtypes + MEDIASUBTYPE_MPEG2_PROGRAM: TGUID = (D1:$e06d8022;D2:$db46;D3:$11cf;D4:($b4,$d1,$00,$80,$05f,$6c,$bb,$ea)); + {$EXTERNALSYM MEDIASUBTYPE_MPEG2_PROGRAM} + MEDIASUBTYPE_MPEG2_TRANSPORT: TGUID = (D1:$e06d8023;D2:$db46;D3:$11cf;D4:($b4,$d1,$00,$80,$05f,$6c,$bb,$ea)); + {$EXTERNALSYM MEDIASUBTYPE_MPEG2_TRANSPORT} + MEDIASUBTYPE_MPEG2_AUDIO: TGUID = (D1:$E06D802B;D2:$DB46;D3:$11CF;D4:($B4,$D1,$00,$80,$005F,$6C,$BB,$EA)); + {$EXTERNALSYM MEDIASUBTYPE_MPEG2_AUDIO} + MEDIASUBTYPE_DOLBY_AC3: TGUID = (D1:$E06D802C;D2:$DB46;D3:$11CF;D4:($B4,$D1,$00,$80,$005F,$6C,$BB,$EA)); + {$EXTERNALSYM MEDIASUBTYPE_DOLBY_AC3} + MEDIASUBTYPE_DVD_SUBPICTURE: TGUID = (D1:$E06D802D;D2:$DB46;D3:$11CF;D4:($B4,$D1,$00,$80,$005F,$6C,$BB,$EA)); + {$EXTERNALSYM MEDIASUBTYPE_DVD_SUBPICTURE} + MEDIASUBTYPE_DVD_LPCM_AUDIO: TGUID = (D1:$E06D8032;D2:$DB46;D3:$11CF;D4:($B4,$D1,$00,$80,$005F,$6C,$BB,$EA)); + {$EXTERNALSYM MEDIASUBTYPE_DVD_LPCM_AUDIO} + MEDIASUBTYPE_DTS: TGUID = (D1:$e06d8033;D2:$db46;D3:$11cf;D4:($b4,$d1,$00,$80,$5f,$6c,$bb,$ea)); + {$EXTERNALSYM MEDIASUBTYPE_DTS} + MEDIASUBTYPE_SDDS: TGUID = (D1:$e06d8034;D2:$db46;D3:$11cf;D4:($b4,$d1,$00,$80,$5f,$6c,$bb,$ea)); + {$EXTERNALSYM MEDIASUBTYPE_SDDS} + +// DVD-related mediatypes + MEDIATYPE_DVD_ENCRYPTED_PACK: TGUID = (D1:$ED0B916A;D2:$044D;D3:$11D1;D4:($AA,$78,$00,$C0,$004F,$C3,$1D,$60)); + {$EXTERNALSYM MEDIATYPE_DVD_ENCRYPTED_PACK} + MEDIATYPE_DVD_NAVIGATION: TGUID = (D1:$E06D802E;D2:$DB46;D3:$11CF;D4:($B4,$D1,$00,$80,$005F,$6C,$BB,$EA)); + {$EXTERNALSYM MEDIATYPE_DVD_NAVIGATION} + MEDIASUBTYPE_DVD_NAVIGATION_PCI: TGUID = (D1:$E06D802F;D2:$DB46;D3:$11CF;D4:($B4,$D1,$00,$80,$005F,$6C,$BB,$EA)); + {$EXTERNALSYM MEDIASUBTYPE_DVD_NAVIGATION_PCI} + MEDIASUBTYPE_DVD_NAVIGATION_DSI: TGUID = (D1:$E06D8030;D2:$DB46;D3:$11CF;D4:($B4,$D1,$00,$80,$005F,$6C,$BB,$EA)); + {$EXTERNALSYM MEDIASUBTYPE_DVD_NAVIGATION_DSI} + MEDIASUBTYPE_DVD_NAVIGATION_PROVIDER: TGUID = (D1:$E06D8031;D2:$DB46;D3:$11CF;D4:($B4,$D1,$00,$80,$005F,$6C,$BB,$EA)); + {$EXTERNALSYM MEDIASUBTYPE_DVD_NAVIGATION_PROVIDER} + +// +// DVD - MPEG2/AC3-related Formats +// + + FORMAT_MPEG2Video: TGUID = (D1:$E06D80E3;D2:$DB46;D3:$11CF;D4:($B4,$D1,$00,$80,$005F,$6C,$BB,$EA)); + {$EXTERNALSYM FORMAT_MPEG2Video} + FORMAT_DolbyAC3: TGUID = (D1:$E06D80E4;D2:$DB46;D3:$11CF;D4:($B4,$D1,$00,$80,$005F,$6C,$BB,$EA)); + {$EXTERNALSYM FORMAT_DolbyAC3} + FORMAT_MPEG2Audio: TGUID = (D1:$E06D80E5;D2:$DB46;D3:$11CF;D4:($B4,$D1,$00,$80,$005F,$6C,$BB,$EA)); + {$EXTERNALSYM FORMAT_MPEG2Audio} + FORMAT_DVD_LPCMAudio: TGUID = (D1:$E06D80E6;D2:$DB46;D3:$11CF;D4:($B4,$D1,$00,$80,$005F,$6C,$BB,$EA)); + {$EXTERNALSYM FORMAT_DVD_LPCMAudio} + +// +// KS Property Set Id (to communicate with the WDM Proxy filter) -- from +// ksmedia.h of WDM DDK. +// + + AM_KSPROPSETID_AC3: TGUID = (D1:$BFABE720;D2:$6E1F;D3:$11D0;D4:($BC,$F2,$44,$45,$53,$54,$00,$00)); + {$EXTERNALSYM AM_KSPROPSETID_AC3} + AM_KSPROPSETID_DvdSubPic: TGUID = (D1:$AC390460;D2:$43AF;D3:$11D0;D4:($BD,$6A,$00,$35,$05,$C1,$03,$A9)); + {$EXTERNALSYM AM_KSPROPSETID_DvdSubPic} + AM_KSPROPSETID_CopyProt: TGUID = (D1:$0E8A0A40;D2:$6AEF;D3:$11D0;D4:($9E,$D0,$00,$A0,$24,$CA,$19,$B3)); + {$EXTERNALSYM AM_KSPROPSETID_CopyProt} + AM_KSPROPSETID_TSRateChange: TGUID = (D1:$A503C5C0;D2:$1D1D;D3:$11D1;D4:($AD,$80,$44,$45,$53,$54,$00,$00)); + {$EXTERNALSYM AM_KSPROPSETID_TSRateChange} + AM_KSPROPSETID_DVD_RateChange: TGUID = (D1:$3577eb09;D2:$9582;D3:$477f;D4:($b2,$9c,$b0,$c4,$52,$a4,$ff,$9a)); + {$EXTERNALSYM AM_KSPROPSETID_DVD_RateChange} + AM_KSPROPSETID_DvdKaraoke: TGUID = (D1:$ae4720ae;D2:$aa71;D3:$42d8;D4:($b8,$2a,$ff,$fd,$f5,$8b,$76,$fd)); + {$EXTERNALSYM AM_KSPROPSETID_DvdKaraoke} + AM_KSPROPSETID_FrameStep: TGUID = (D1:$c830acbd;D2:$ab07;D3:$492f;D4:($88,$52,$45,$b6,$98,$7c,$29,$79)); + {$EXTERNALSYM AM_KSPROPSETID_FrameStep} +// +// KS categories from ks.h and ksmedia.h +// +// + + AM_KSCATEGORY_CAPTURE: TGUID = (D1:$65E8773D;D2:$8F56;D3:$11D0;D4:($A3,$B9,$00,$A0,$C9,$22,$31,$96)); + {$EXTERNALSYM AM_KSCATEGORY_CAPTURE} + AM_KSCATEGORY_RENDER: TGUID = (D1:$65E8773E;D2:$8F56;D3:$11D0;D4:($A3,$B9,$00,$A0,$C9,$22,$31,$96)); + {$EXTERNALSYM AM_KSCATEGORY_RENDER} + AM_KSCATEGORY_DATACOMPRESSOR: TGUID = (D1:$1E84C900;D2:$7E70;D3:$11D0;D4:($A5,$D6,$28,$DB,$04,$C1,$00,$00)); + {$EXTERNALSYM AM_KSCATEGORY_DATACOMPRESSOR} + AM_KSCATEGORY_AUDIO: TGUID = (D1:$6994AD04;D2:$93EF;D3:$11D0;D4:($A3,$CC,$00,$A0,$C9,$22,$31,$96)); + {$EXTERNALSYM AM_KSCATEGORY_AUDIO} + AM_KSCATEGORY_VIDEO: TGUID = (D1:$6994AD05;D2:$93EF;D3:$11D0;D4:($A3,$CC,$00,$A0,$C9,$22,$31,$96)); + {$EXTERNALSYM AM_KSCATEGORY_VIDEO} + AM_KSCATEGORY_TVTUNER: TGUID = (D1:$A799A800;D2:$A46D;D3:$11D0;D4:($A1,$8C,$00,$A0,$24,$01,$DC,$D4)); + {$EXTERNALSYM AM_KSCATEGORY_TVTUNER} + AM_KSCATEGORY_CROSSBAR: TGUID = (D1:$A799A801;D2:$A46D;D3:$11D0;D4:($A1,$8C,$00,$A0,$24,$01,$DC,$D4)); + {$EXTERNALSYM AM_KSCATEGORY_CROSSBAR} + AM_KSCATEGORY_TVAUDIO: TGUID = (D1:$A799A802;D2:$A46D;D3:$11D0;D4:($A1,$8C,$00,$A0,$24,$01,$DC,$D4)); + {$EXTERNALSYM AM_KSCATEGORY_TVAUDIO} + AM_KSCATEGORY_VBICODEC: TGUID = (D1:$07dad660;D2:$22f1;D3:$11d1;D4:($a9,$f4,$00,$c0,$4f,$bb,$de,$8f)); + {$EXTERNALSYM AM_KSCATEGORY_VBICODEC} + AM_KSCATEGORY_SPLITTER: TGUID = (D1:$0A4252A0;D2:$7E70;D3:$11D0;D4:($A5,$D6,$28,$DB,$04,$C1,$00,$00)); + {$EXTERNALSYM AM_KSCATEGORY_SPLITTER} + +// +// guids needed to support IKsPin interface +// +// + IID_IKsInterfaceHandler: TGUID = (D1:$D3ABC7E0;D2:$9A61;D3:$11D0;D4:($A4,$0D,$00,$A0,$C9,$22,$31,$96)); + {$EXTERNALSYM IID_IKsInterfaceHandler} + STATIC_IID_IKsInterfaceHandler: TGUID = (D1:$D3ABC7E0;D2:$9A61;D3:$11D0;D4:($A4,$0D,$00,$A0,$C9,$22,$31,$96)); + {$EXTERNALSYM STATIC_IID_IKsInterfaceHandler} + + IID_IKsDataTypeHandler: TGUID = (D1:$5FFBAA02;D2:$49A3;D3:$11D0;D4:($9F,$36,$00,$AA,$00,$A2,$16,$A1)); + {$EXTERNALSYM IID_IKsDataTypeHandler} + STATIC_IID_IKsDataTypeHandler: TGUID = (D1:$5FFBAA02;D2:$49A3;D3:$11D0;D4:($9F,$36,$00,$AA,$00,$A2,$16,$A1)); + {$EXTERNALSYM STATIC_IID_IKsDataTypeHandler} + + IID_IKsPin: TGUID = (D1:$B61178D1;D2:$A2D9;D3:$11CF;D4:($9E,$53,$00,$AA,$00,$A2,$16,$A1)); + {$EXTERNALSYM IID_IKsPin} + STATIC_IID_IKsPin: TGUID = (D1:$B61178D1;D2:$A2D9;D3:$11CF;D4:($9E,$53,$00,$AA,$00,$A2,$16,$A1)); + {$EXTERNALSYM STATIC_IID_IKsPin} + + IID_IKsControl: TGUID = (D1:$28F54685;D2:$06FD;D3:$11D2;D4:($B2,$7A,$00,$A0,$C9,$22,$31,$96)); + {$EXTERNALSYM IID_IKsControl} + STATIC_IID_IKsControl : TGUID = (D1:$28F54685;D2:$06FD;D3:$11D2;D4:($B2,$7A,$00,$A0,$C9,$22,$31,$96)); + + {$EXTERNALSYM STATIC_IID_IKsControl} + IID_IKsPinFactory: TGUID = (D1:$CD5EBE6B;D2:$8B6E;D3:$11D1;D4:($8A,$E0,$00,$A0,$C9,$22,$31,$96)); + {$EXTERNALSYM IID_IKsPinFactory} + AM_INTERFACESETID_Standard: TGUID = (D1:$1A8766A0;D2:$62CE;D3:$11CF;D4:($A5,$D6,$28,$DB,$04,$C1,$00,$00)); + {$EXTERNALSYM AM_INTERFACESETID_Standard} + +//------------------------------------------------------------------------------ +// File: DXVA.h +// Desc: DirectX Video Acceleration header file. +// Copyright (c) 1999 - 2000, Microsoft Corporation. All rights reserved. +//------------------------------------------------------------------------------ + +const + DXVA_ModeNone : TGUID = (D1:$1b81be00; D2:$a0c7; D3:$11d3; D4:($b9,$84,$00,$c0,$4f,$2e,$73,$c5)); + {$EXTERNALSYM DXVA_ModeNone} + DXVA_ModeH261_A : TGUID = (D1:$1b81be01; D2:$a0c7; D3:$11d3; D4:($b9,$84,$00,$c0,$4f,$2e,$73,$c5)); + {$EXTERNALSYM DXVA_ModeH261_A} + DXVA_ModeH261_B : TGUID = (D1:$1b81be02; D2:$a0c7; D3:$11d3; D4:($b9,$84,$00,$c0,$4f,$2e,$73,$c5)); + {$EXTERNALSYM DXVA_ModeH261_B} + DXVA_ModeH263_A : TGUID = (D1:$1b81be03; D2:$a0c7; D3:$11d3; D4:($b9,$84,$00,$c0,$4f,$2e,$73,$c5)); + {$EXTERNALSYM DXVA_ModeH263_A} + DXVA_ModeH263_B : TGUID = (D1:$1b81be04; D2:$a0c7; D3:$11d3; D4:($b9,$84,$00,$c0,$4f,$2e,$73,$c5)); + {$EXTERNALSYM DXVA_ModeH263_B} + DXVA_ModeH263_C : TGUID = (D1:$1b81be05; D2:$a0c7; D3:$11d3; D4:($b9,$84,$00,$c0,$4f,$2e,$73,$c5)); + {$EXTERNALSYM DXVA_ModeH263_C} + DXVA_ModeH263_D : TGUID = (D1:$1b81be06; D2:$a0c7; D3:$11d3; D4:($b9,$84,$00,$c0,$4f,$2e,$73,$c5)); + {$EXTERNALSYM DXVA_ModeH263_D} + DXVA_ModeH263_E : TGUID = (D1:$1b81be07; D2:$a0c7; D3:$11d3; D4:($b9,$84,$00,$c0,$4f,$2e,$73,$c5)); + {$EXTERNALSYM DXVA_ModeH263_E} + DXVA_ModeH263_F : TGUID = (D1:$1b81be08; D2:$a0c7; D3:$11d3; D4:($b9,$84,$00,$c0,$4f,$2e,$73,$c5)); + {$EXTERNALSYM DXVA_ModeH263_F} + DXVA_ModeMPEG1_A : TGUID = (D1:$1b81be09; D2:$a0c7; D3:$11d3; D4:($b9,$84,$00,$c0,$4f,$2e,$73,$c5)); + {$EXTERNALSYM DXVA_ModeMPEG1_A} + DXVA_ModeMPEG2_A : TGUID = (D1:$1b81be0A; D2:$a0c7; D3:$11d3; D4:($b9,$84,$00,$c0,$4f,$2e,$73,$c5)); + {$EXTERNALSYM DXVA_ModeMPEG2_A} + DXVA_ModeMPEG2_B : TGUID = (D1:$1b81be0B; D2:$a0c7; D3:$11d3; D4:($b9,$84,$00,$c0,$4f,$2e,$73,$c5)); + {$EXTERNALSYM DXVA_ModeMPEG2_B} + DXVA_ModeMPEG2_C : TGUID = (D1:$1b81be0C; D2:$a0c7; D3:$11d3; D4:($b9,$84,$00,$c0,$4f,$2e,$73,$c5)); + {$EXTERNALSYM DXVA_ModeMPEG2_C} + DXVA_ModeMPEG2_D : TGUID = (D1:$1b81be0D; D2:$a0c7; D3:$11d3; D4:($b9,$84,$00,$c0,$4f,$2e,$73,$c5)); + {$EXTERNALSYM DXVA_ModeMPEG2_D} + + DXVA_ModeWMV8_A : TGUID = (D1:$1b81be80 ;D2:$a0c7; D3:$11d3; D4:($b9,$84,$00,$c0,$4f,$2e,$73,$c5)); + {$EXTERNALSYM DXVA_ModeWMV8_A} + DXVA_ModeWMV8_B : TGUID = (D1:$1b81be81 ;D2:$a0c7; D3:$11d3; D4:($b9,$84,$00,$c0,$4f,$2e,$73,$c5)); + {$EXTERNALSYM DXVA_ModeWMV8_B} + + DXVA_ModeWMV9_A : TGUID = (D1:$1b81be90 ;D2:$a0c7; D3:$11d3; D4:($b9,$84,$00,$c0,$4f,$2e,$73,$c5)); + {$EXTERNALSYM DXVA_ModeWMV9_A} + DXVA_ModeWMV9_B : TGUID = (D1:$1b81be91 ;D2:$a0c7; D3:$11d3; D4:($b9,$84,$00,$c0,$4f,$2e,$73,$c5)); + {$EXTERNALSYM DXVA_ModeWMV9_B} + DXVA_ModeWMV9_Ai : TGUID = (D1:$1b81be92 ;D2:$a0c7; D3:$11d3; D4:($b9,$84,$00,$c0,$4f,$2e,$73,$c5)); + {$EXTERNALSYM DXVA_ModeWMV9_Ai} + DXVA_ModeWMV9_Bi : TGUID = (D1:$1b81be93 ;D2:$a0c7; D3:$11d3; D4:($b9,$84,$00,$c0,$4f,$2e,$73,$c5)); + {$EXTERNALSYM DXVA_ModeWMV9_Bi} + + DXVA_NoEncrypt : TGUID = (D1:$1b81beD0;D2:$a0c7;D3:$11d3;D4:($b9,$84,$00,$c0,$4f,$2e,$73,$c5)); + {$EXTERNALSYM DXVA_NoEncrypt} + //DXVA_EncryptProt1 : TGUID = (D1:$1b81beD1;D2:$a0c7;D3:$11d3;D4:($b9,$84,$00,$c0,$4f,$2e,$73,$c5)); + + DXVA_RESTRICTED_MODE_UNRESTRICTED = $FFFF; + {$EXTERNALSYM DXVA_RESTRICTED_MODE_UNRESTRICTED} + DXVA_RESTRICTED_MODE_H261_A = 1; + {$EXTERNALSYM DXVA_RESTRICTED_MODE_H261_A} + DXVA_RESTRICTED_MODE_H261_B = 2; + {$EXTERNALSYM DXVA_RESTRICTED_MODE_H261_B} + DXVA_RESTRICTED_MODE_H263_A = 3; + {$EXTERNALSYM DXVA_RESTRICTED_MODE_H263_A} + DXVA_RESTRICTED_MODE_H263_B = 4; + {$EXTERNALSYM DXVA_RESTRICTED_MODE_H263_B} + DXVA_RESTRICTED_MODE_H263_C = 5; + {$EXTERNALSYM DXVA_RESTRICTED_MODE_H263_C} + DXVA_RESTRICTED_MODE_H263_D = 6; + {$EXTERNALSYM DXVA_RESTRICTED_MODE_H263_D} + DXVA_RESTRICTED_MODE_H263_E = 7; + {$EXTERNALSYM DXVA_RESTRICTED_MODE_H263_E} + DXVA_RESTRICTED_MODE_H263_F = 8; + {$EXTERNALSYM DXVA_RESTRICTED_MODE_H263_F} + DXVA_RESTRICTED_MODE_MPEG1_A = 9; + {$EXTERNALSYM DXVA_RESTRICTED_MODE_MPEG1_A} + DXVA_RESTRICTED_MODE_MPEG2_A = $A; + {$EXTERNALSYM DXVA_RESTRICTED_MODE_MPEG2_A} + DXVA_RESTRICTED_MODE_MPEG2_B = $B; + {$EXTERNALSYM DXVA_RESTRICTED_MODE_MPEG2_B} + DXVA_RESTRICTED_MODE_MPEG2_C = $C; + {$EXTERNALSYM DXVA_RESTRICTED_MODE_MPEG2_C} + DXVA_RESTRICTED_MODE_MPEG2_D = $D; + {$EXTERNALSYM DXVA_RESTRICTED_MODE_MPEG2_D} + + DXVA_RESTRICTED_MODE_WMV8_A = $80; + {$EXTERNALSYM DXVA_RESTRICTED_MODE_WMV8_A} + DXVA_RESTRICTED_MODE_WMV8_B = $81; + {$EXTERNALSYM DXVA_RESTRICTED_MODE_WMV8_B} + + DXVA_RESTRICTED_MODE_WMV9_A = $90; + {$EXTERNALSYM DXVA_RESTRICTED_MODE_WMV9_A} + DXVA_RESTRICTED_MODE_WMV9_B = $91; + {$EXTERNALSYM DXVA_RESTRICTED_MODE_WMV9_B} + DXVA_RESTRICTED_MODE_WMV9_Ai = $92; + {$EXTERNALSYM DXVA_RESTRICTED_MODE_WMV9_Ai} + DXVA_RESTRICTED_MODE_WMV9_Bi = $93; + {$EXTERNALSYM DXVA_RESTRICTED_MODE_WMV9_Bi} + + + DXVA_COMPBUFFER_TYPE_THAT_IS_NOT_USED = 0; + {$EXTERNALSYM DXVA_COMPBUFFER_TYPE_THAT_IS_NOT_USED} + DXVA_PICTURE_DECODE_BUFFER = 1; + {$EXTERNALSYM DXVA_PICTURE_DECODE_BUFFER} + DXVA_MACROBLOCK_CONTROL_BUFFER = 2; + {$EXTERNALSYM DXVA_MACROBLOCK_CONTROL_BUFFER} + DXVA_RESIDUAL_DIFFERENCE_BUFFER = 3; + {$EXTERNALSYM DXVA_RESIDUAL_DIFFERENCE_BUFFER} + DXVA_DEBLOCKING_CONTROL_BUFFER = 4; + {$EXTERNALSYM DXVA_DEBLOCKING_CONTROL_BUFFER} + DXVA_INVERSE_QUANTIZATION_MATRIX_BUFFER = 5; + {$EXTERNALSYM DXVA_INVERSE_QUANTIZATION_MATRIX_BUFFER} + DXVA_SLICE_CONTROL_BUFFER = 6; + {$EXTERNALSYM DXVA_SLICE_CONTROL_BUFFER} + DXVA_BITSTREAM_DATA_BUFFER = 7; + {$EXTERNALSYM DXVA_BITSTREAM_DATA_BUFFER} + DXVA_AYUV_BUFFER = 8; + {$EXTERNALSYM DXVA_AYUV_BUFFER} + DXVA_IA44_SURFACE_BUFFER = 9; + {$EXTERNALSYM DXVA_IA44_SURFACE_BUFFER} + DXVA_DPXD_SURFACE_BUFFER = 10; + {$EXTERNALSYM DXVA_DPXD_SURFACE_BUFFER} + DXVA_HIGHLIGHT_BUFFER = 11; + {$EXTERNALSYM DXVA_HIGHLIGHT_BUFFER} + DXVA_DCCMD_SURFACE_BUFFER = 12; + {$EXTERNALSYM DXVA_DCCMD_SURFACE_BUFFER} + DXVA_ALPHA_BLEND_COMBINATION_BUFFER = 13; + {$EXTERNALSYM DXVA_ALPHA_BLEND_COMBINATION_BUFFER} + DXVA_PICTURE_RESAMPLE_BUFFER = 14; + {$EXTERNALSYM DXVA_PICTURE_RESAMPLE_BUFFER} + DXVA_READ_BACK_BUFFER = 15; + {$EXTERNALSYM DXVA_READ_BACK_BUFFER} + + DXVA_NUM_TYPES_COMP_BUFFERS = 16; + {$EXTERNALSYM DXVA_NUM_TYPES_COMP_BUFFERS} + + // values for bDXVA_Func + DXVA_PICTURE_DECODING_FUNCTION = 1; + {$EXTERNALSYM DXVA_PICTURE_DECODING_FUNCTION} + DXVA_ALPHA_BLEND_DATA_LOAD_FUNCTION = 2; + {$EXTERNALSYM DXVA_ALPHA_BLEND_DATA_LOAD_FUNCTION} + DXVA_ALPHA_BLEND_COMBINATION_FUNCTION = 3; + {$EXTERNALSYM DXVA_ALPHA_BLEND_COMBINATION_FUNCTION} + DXVA_PICTURE_RESAMPLE_FUNCTION = 4; + {$EXTERNALSYM DXVA_PICTURE_RESAMPLE_FUNCTION} + + // values returned from Execute command in absence of read-back + DXVA_EXECUTE_RETURN_OK = 0; + {$EXTERNALSYM DXVA_EXECUTE_RETURN_OK} + DXVA_EXECUTE_RETURN_DATA_ERROR_MINOR = 1; + {$EXTERNALSYM DXVA_EXECUTE_RETURN_DATA_ERROR_MINOR} + DXVA_EXECUTE_RETURN_DATA_ERROR_SIGNIF = 2; + {$EXTERNALSYM DXVA_EXECUTE_RETURN_DATA_ERROR_SIGNIF} + DXVA_EXECUTE_RETURN_DATA_ERROR_SEVERE = 3; + {$EXTERNALSYM DXVA_EXECUTE_RETURN_DATA_ERROR_SEVERE} + DXVA_EXECUTE_RETURN_OTHER_ERROR_SEVERE = 4; + {$EXTERNALSYM DXVA_EXECUTE_RETURN_OTHER_ERROR_SEVERE} + +type + PDXVAConnectMode = ^TDXVAConnectMode; + _DXVA_ConnectMode = record + guidMode : TGUID; + wRestrictedMode : WORD; + end; + {$EXTERNALSYM _DXVA_ConnectMode} + DXVA_ConnectMode = _DXVA_ConnectMode; + {$EXTERNALSYM DXVA_ConnectMode} + LPDXVA_ConnectMode = ^DXVA_ConnectMode; + {$EXTERNALSYM LPDXVA_ConnectMode} + TDXVAConnectMode = _DXVA_ConnectMode; + + DXVA_ConfigQueryOrReplyFunc = {$IFDEF TYPE_IDENTITY}type {$ENDIF} DWORD; + {$EXTERNALSYM DXVA_ConfigQueryOrReplyFunc} + LPDXVA_ConfigQueryOrReplyFunc = ^DXVA_ConfigQueryOrReplyFunc; + {$EXTERNALSYM LPDXVA_ConfigQueryOrReplyFunc} + +const + DXVA_QUERYORREPLYFUNCFLAG_DECODER_PROBE_QUERY = $FFFFF1; + {$EXTERNALSYM DXVA_QUERYORREPLYFUNCFLAG_DECODER_PROBE_QUERY} + DXVA_QUERYORREPLYFUNCFLAG_DECODER_LOCK_QUERY = $FFFFF5; + {$EXTERNALSYM DXVA_QUERYORREPLYFUNCFLAG_DECODER_LOCK_QUERY} + DXVA_QUERYORREPLYFUNCFLAG_ACCEL_PROBE_OK_COPY = $FFFFF8; + {$EXTERNALSYM DXVA_QUERYORREPLYFUNCFLAG_ACCEL_PROBE_OK_COPY} + DXVA_QUERYORREPLYFUNCFLAG_ACCEL_PROBE_OK_PLUS = $FFFFF9; + {$EXTERNALSYM DXVA_QUERYORREPLYFUNCFLAG_ACCEL_PROBE_OK_PLUS} + DXVA_QUERYORREPLYFUNCFLAG_ACCEL_LOCK_OK_COPY = $FFFFFC; + {$EXTERNALSYM DXVA_QUERYORREPLYFUNCFLAG_ACCEL_LOCK_OK_COPY} + DXVA_QUERYORREPLYFUNCFLAG_ACCEL_PROBE_FALSE_PLUS = $FFFFFB; + {$EXTERNALSYM DXVA_QUERYORREPLYFUNCFLAG_ACCEL_PROBE_FALSE_PLUS} + DXVA_QUERYORREPLYFUNCFLAG_ACCEL_LOCK_FALSE_PLUS = $FFFFFF; + {$EXTERNALSYM DXVA_QUERYORREPLYFUNCFLAG_ACCEL_LOCK_FALSE_PLUS} + +{ +#define readDXVA_QueryOrReplyFuncFlag(ptr) ((*(ptr)) >> 8) +#define readDXVA_QueryOrReplyFuncFlag_ACCEL(ptr) (((*(ptr)) >> 11) & 1) +#define readDXVA_QueryOrReplyFuncFlag_LOCK(ptr) (((*(ptr)) >> 10) & 1) +#define readDXVA_QueryOrReplyFuncFlag_BAD(ptr) (((*(ptr)) >> 9) & 1) +#define readDXVA_QueryOrReplyFuncFlag_PLUS(ptr) (((*(ptr)) >> 8) & 1) +#define readDXVA_QueryOrReplyFuncFunc(ptr) ((*(ptr)) & 0xFF) +#define writeDXVA_QueryOrReplyFunc(ptr, flg, fnc) ((*(ptr)) = ((flg) << 8) | (fnc)) +#define setDXVA_QueryOrReplyFuncFlag(ptr, flg) ((*(ptr)) |= ((flg) << 8)) +#define setDXVA_QueryOrReplyFuncFunc(ptr, fnc) ((*(ptr)) |= (fnc)); +} + +type + DXVA_EncryptProtocolFunc = {$IFDEF TYPE_IDENTITY}type {$ENDIF} DWORD; + {$EXTERNALSYM DXVA_EncryptProtocolFunc} + LPDXVA_EncryptProtocolFunc = ^DXVA_EncryptProtocolFunc; + {$EXTERNALSYM LPDXVA_EncryptProtocolFunc} + +const + DXVA_ENCRYPTPROTOCOLFUNCFLAG_HOST = $FFFF00; + {$EXTERNALSYM DXVA_ENCRYPTPROTOCOLFUNCFLAG_HOST} + DXVA_ENCRYPTPROTOCOLFUNCFLAG_ACCEL = $FFFF08; + {$EXTERNALSYM DXVA_ENCRYPTPROTOCOLFUNCFLAG_ACCEL} + +{ +#define readDXVA_EncryptProtocolFuncFlag(ptr) ((*(ptr)) >> 8) +#define readDXVA_EncryptProtocolFuncFlag_ACCEL(ptr) (((*(ptr)) >> 11) & 1) +#define readDXVA_EncryptProtocolFuncFunc(ptr) ((*(ptr)) & 0xFF) +#define writeDXVA_EncryptProtocolFunc(ptr, flg, fnc) ((*(ptr)) = ((flg) << 8) | (fnc)) +#define setDXVA_EncryptProtocolFuncFlag(ptr, flg) ((*(ptr)) |= ((flg) << 8)) +#define setDXVA_EncryptProtocolFuncFunc(ptr, fnc) ((*(ptr)) |= (fnc)); +} + +type + PDXVAEncryptProtocolHeader = ^TDXVAEncryptProtocolHeader; + _DXVA_EncryptProtocolHeader = record + dwFunction : DXVA_EncryptProtocolFunc; + ReservedBits : array [0..2] of LongWord; + guidEncryptProtocol : TGUID; + end; + {$EXTERNALSYM _DXVA_EncryptProtocolHeader} + DXVA_EncryptProtocolHeader = _DXVA_EncryptProtocolHeader; + {$EXTERNALSYM DXVA_EncryptProtocolHeader} + LPDXVA_EncryptProtocolHeader = ^DXVA_EncryptProtocolHeader; + {$EXTERNALSYM LPDXVA_EncryptProtocolHeader} + TDXVAEncryptProtocolHeader = _DXVA_EncryptProtocolHeader; + + PDXVAConfigPictureDecode = ^TDXVAConfigPictureDecode; + _DXVA_ConfigPictureDecode = record + // Operation Indicated + dwFunction: DXVA_ConfigQueryOrReplyFunc; + // Alignment + dwReservedBits : array[0..2] of DWORD; + // Encryption GUIDs + guidConfigBitstreamEncryption : TGUID; + guidConfigMBcontrolEncryption : TGUID; + guidConfigResidDiffEncryption : TGUID; + // Bitstream Processing Indicator + bConfigBitstreamRaw : BYTE; + // Macroblock Control Config + bConfigMBcontrolRasterOrder : BYTE; + // Host Resid Diff Config + bConfigResidDiffHost : BYTE; + bConfigSpatialResid8 : BYTE; + bConfigResid8Subtraction : BYTE; + bConfigSpatialHost8or9Clipping : BYTE; + bConfigSpatialResidInterleaved : BYTE; + bConfigIntraResidUnsigned : BYTE; + // Accelerator Resid Diff Config + bConfigResidDiffAccelerator : BYTE; + bConfigHostInverseScan : BYTE; + bConfigSpecificIDCT : BYTE; + bConfig4GroupedCoefs : BYTE; + end; + {$EXTERNALSYM _DXVA_ConfigPictureDecode} + DXVA_ConfigPictureDecode = _DXVA_ConfigPictureDecode; + {$EXTERNALSYM DXVA_ConfigPictureDecode} + LPDXVA_ConfigPictureDecode = ^DXVA_ConfigPictureDecode; + {$EXTERNALSYM LPDXVA_ConfigPictureDecode} + TDXVAConfigPictureDecode = _DXVA_ConfigPictureDecode; + + // Picture Decoding Parameters + PDXVAPictureParameters = ^TDXVAPictureParameters; + _DXVA_PictureParameters = record + wDecodedPictureIndex : WORD; + wDeblockedPictureIndex : WORD; + wForwardRefPictureIndex : WORD; + wBackwardRefPictureIndex : WORD; + wPicWidthInMBminus1 : WORD; + wPicHeightInMBminus1 : WORD; + bMacroblockWidthMinus1 : BYTE; + bMacroblockHeightMinus1 : BYTE; + bBlockWidthMinus1 : BYTE; + bBlockHeightMinus1 : BYTE; + bBPPminus1 : BYTE; + bPicStructure : BYTE; + bSecondField : BYTE; + bPicIntra : BYTE; + bPicBackwardPrediction : BYTE; + bBidirectionalAveragingMode : BYTE; + bMVprecisionAndChromaRelation : BYTE; + bChromaFormat : BYTE; + bPicScanFixed : BYTE; + bPicScanMethod : BYTE; + bPicReadbackRequests : BYTE; + bRcontrol : BYTE; + bPicSpatialResid8 : BYTE; + bPicOverflowBlocks : BYTE; + bPicExtrapolation : BYTE; + bPicDeblocked : BYTE; + bPicDeblockConfined : BYTE; + bPic4MVallowed : BYTE; + bPicOBMC : BYTE; + bPicBinPB : BYTE; + bMV_RPS : BYTE; + bReservedBits : BYTE; + wBitstreamFcodes : WORD; + wBitstreamPCEelements : WORD; + bBitstreamConcealmentNeed : BYTE; + bBitstreamConcealmentMethod : BYTE; + end; + {$EXTERNALSYM _DXVA_PictureParameters} + DXVA_PictureParameters = _DXVA_PictureParameters; + {$EXTERNALSYM DXVA_PictureParameters} + LPDXVA_PictureParameters = ^DXVA_PictureParameters; + {$EXTERNALSYM LPDXVA_PictureParameters} + TDXVAPictureParameters = _DXVA_PictureParameters; + + // Picture Resampling + PDXVAPicResample = ^TDXVAPicResample; + _DXVA_PicResample = record + wPicResampleSourcePicIndex : WORD; + wPicResampleDestPicIndex : WORD; + wPicResampleRcontrol : WORD; + bPicResampleExtrapWidth : BYTE; + bPicResampleExtrapHeight : BYTE; + dwPicResampleSourceWidth : DWORD; + dwPicResampleSourceHeight : DWORD; + dwPicResampleDestWidth : DWORD; + dwPicResampleDestHeight : DWORD; + dwPicResampleFullDestWidth : DWORD; + dwPicResampleFullDestHeight : DWORD; + end; + {$EXTERNALSYM _DXVA_PicResample} + DXVA_PicResample = _DXVA_PicResample; + {$EXTERNALSYM DXVA_PicResample} + LPDXVA_PicResample = ^DXVA_PicResample; + {$EXTERNALSYM LPDXVA_PicResample} + TDXVAPicResample = _DXVA_PicResample; + +const + DXVA_CHROMA_FORMAT_420 = 1; + {$EXTERNALSYM DXVA_CHROMA_FORMAT_420} + DXVA_CHROMA_FORMAT_422 = 2; + {$EXTERNALSYM DXVA_CHROMA_FORMAT_422} + DXVA_CHROMA_FORMAT_444 = 3; + {$EXTERNALSYM DXVA_CHROMA_FORMAT_444} + + DXVA_PICTURE_STRUCTURE_TOP_FIELD = 1; + {$EXTERNALSYM DXVA_PICTURE_STRUCTURE_TOP_FIELD} + DXVA_PICTURE_STRUCTURE_BOTTOM_FIELD = 2; + {$EXTERNALSYM DXVA_PICTURE_STRUCTURE_BOTTOM_FIELD} + DXVA_PICTURE_STRUCTURE_FRAME = 3; + {$EXTERNALSYM DXVA_PICTURE_STRUCTURE_FRAME} + + DXVA_BIDIRECTIONAL_AVERAGING_MPEG2_ROUND = 0; + {$EXTERNALSYM DXVA_BIDIRECTIONAL_AVERAGING_MPEG2_ROUND} + DXVA_BIDIRECTIONAL_AVERAGING_H263_TRUNC = 1; + {$EXTERNALSYM DXVA_BIDIRECTIONAL_AVERAGING_H263_TRUNC} + + DXVA_MV_PRECISION_AND_CHROMA_RELATION_MPEG2 = 0; + {$EXTERNALSYM DXVA_MV_PRECISION_AND_CHROMA_RELATION_MPEG2} + DXVA_MV_PRECISION_AND_CHROMA_RELATION_H263 = 1; + {$EXTERNALSYM DXVA_MV_PRECISION_AND_CHROMA_RELATION_H263} + DXVA_MV_PRECISION_AND_CHROMA_RELATION_H261 = 2; + {$EXTERNALSYM DXVA_MV_PRECISION_AND_CHROMA_RELATION_H261} + + DXVA_SCAN_METHOD_ZIG_ZAG = 0; + {$EXTERNALSYM DXVA_SCAN_METHOD_ZIG_ZAG} + DXVA_SCAN_METHOD_ALTERNATE_VERTICAL = 1; + {$EXTERNALSYM DXVA_SCAN_METHOD_ALTERNATE_VERTICAL} + DXVA_SCAN_METHOD_ALTERNATE_HORIZONTAL = 2; + {$EXTERNALSYM DXVA_SCAN_METHOD_ALTERNATE_HORIZONTAL} + DXVA_SCAN_METHOD_ARBITRARY = 3; + {$EXTERNALSYM DXVA_SCAN_METHOD_ARBITRARY} + + DXVA_BITSTREAM_CONCEALMENT_NEED_UNLIKELY = 0; + {$EXTERNALSYM DXVA_BITSTREAM_CONCEALMENT_NEED_UNLIKELY} + DXVA_BITSTREAM_CONCEALMENT_NEED_MILD = 1; + {$EXTERNALSYM DXVA_BITSTREAM_CONCEALMENT_NEED_MILD} + DXVA_BITSTREAM_CONCEALMENT_NEED_LIKELY = 2; + {$EXTERNALSYM DXVA_BITSTREAM_CONCEALMENT_NEED_LIKELY} + DXVA_BITSTREAM_CONCEALMENT_NEED_SEVERE = 3; + {$EXTERNALSYM DXVA_BITSTREAM_CONCEALMENT_NEED_SEVERE} + + DXVA_BITSTREAM_CONCEALMENT_METHOD_UNSPECIFIED = 0; + {$EXTERNALSYM DXVA_BITSTREAM_CONCEALMENT_METHOD_UNSPECIFIED} + DXVA_BITSTREAM_CONCEALMENT_METHOD_INTRA = 1; + {$EXTERNALSYM DXVA_BITSTREAM_CONCEALMENT_METHOD_INTRA} + DXVA_BITSTREAM_CONCEALMENT_METHOD_FORWARD = 2; + {$EXTERNALSYM DXVA_BITSTREAM_CONCEALMENT_METHOD_FORWARD} + DXVA_BITSTREAM_CONCEALMENT_METHOD_BACKWARD = 3; + {$EXTERNALSYM DXVA_BITSTREAM_CONCEALMENT_METHOD_BACKWARD} + + +Type + // Buffer Description Data + PDXVABufferDescription = ^TDXVABufferDescription; + _DXVA_BufferDescription = record + dwTypeIndex : DWORD; + dwBufferIndex : DWORD; + dwDataOffset : DWORD; + dwDataSize : DWORD; + dwFirstMBaddress : DWORD; + dwNumMBsInBuffer : DWORD; + dwWidth : DWORD; + dwHeight : DWORD; + dwStride : DWORD; + dwReservedBits : DWORD; + end; + {$EXTERNALSYM _DXVA_BufferDescription} + DXVA_BufferDescription = _DXVA_BufferDescription; + {$EXTERNALSYM DXVA_BufferDescription} + LPDXVA_BufferDescription = ^DXVA_BufferDescription; + {$EXTERNALSYM LPDXVA_BufferDescription} + TDXVABufferDescription = _DXVA_BufferDescription; + + // Off-Host IDCT Coefficient Data Structures + PDXVATCoef4Group = ^TDXVATCoef4Group; + _DXVA_TCoef4Group = record + TCoefIDX : array [0..3] of BYTE; + TCoefValue : array [0..3] of smallint; + end; + {$EXTERNALSYM _DXVA_TCoef4Group} + DXVA_TCoef4Group = _DXVA_TCoef4Group; + {$EXTERNALSYM DXVA_TCoef4Group} + LPDXVA_TCoef4Group = ^DXVA_TCoef4Group; + {$EXTERNALSYM LPDXVA_TCoef4Group} + TDXVATCoef4Group = _DXVA_TCoef4Group; + + PDXVATCoefSingle = ^TDXVATCoefSingle; + _DXVA_TCoefSingle = record + wIndexWithEOB : WORD; + TCoefValue : smallint; + end; + {$EXTERNALSYM _DXVA_TCoefSingle} + DXVA_TCoefSingle = _DXVA_TCoefSingle; + {$EXTERNALSYM DXVA_TCoefSingle} + LPDXVA_TCoefSingle = ^DXVA_TCoefSingle; + {$EXTERNALSYM LPDXVA_TCoefSingle} + TDXVATCoefSingle = _DXVA_TCoefSingle; + +// Macros for Reading EOB and Index Values +{ +#define readDXVA_TCoefSingleIDX(ptr) ((ptr)->wIndexWithEOB >> 1) +#define readDXVA_TCoefSingleEOB(ptr) ((ptr)->wIndexWithEOB & 1) +} +// Macro for Writing EOB and Index Values +{ +#define writeDXVA_TCoefSingleIndexWithEOB(ptr, idx, eob) ((ptr)->wIndexWithEOB = ((idx) << 1) | (eob)) +#define setDXVA_TCoefSingleIDX(ptr, idx) ((ptr)->wIndexWithEOB |= ((idx) << 1)) +#define setDXVA_TCoefSingleEOB(ptr) ((ptr)->wIndexWithEOB |= 1) +} + +const + // Spatial-Domain Residual Difference Blocks + DXVA_USUAL_BLOCK_WIDTH = 8; + {$EXTERNALSYM DXVA_USUAL_BLOCK_WIDTH} + DXVA_USUAL_BLOCK_HEIGHT = 8; + {$EXTERNALSYM DXVA_USUAL_BLOCK_HEIGHT} + DXVA_USUAL_BLOCK_SIZE = (DXVA_USUAL_BLOCK_WIDTH * DXVA_USUAL_BLOCK_HEIGHT); + {$EXTERNALSYM DXVA_USUAL_BLOCK_SIZE} + +type + DXVA_Sample16 = array[0..DXVA_USUAL_BLOCK_SIZE-1] of smallint; + {$EXTERNALSYM DXVA_Sample16} + DXVA_Sample8 = array[0..DXVA_USUAL_BLOCK_SIZE-1] of Shortint; + {$EXTERNALSYM DXVA_Sample8} + + // Deblocking Filter Control Structure + DXVA_DeblockingEdgeControl = {$IFDEF TYPE_IDENTITY}type {$ENDIF} BYTE; + {$EXTERNALSYM DXVA_DeblockingEdgeControl} + LPDXVA_DeblockingEdgeControl= ^DXVA_DeblockingEdgeControl; + {$EXTERNALSYM LPDXVA_DeblockingEdgeControl} + +// Macros for Reading STRENGTH and FilterOn +{ +#define readDXVA_EdgeFilterStrength(ptr) ((*(ptr)) >> 1) +#define readDXVA_EdgeFilterOn(ptr) ((*(ptr)) & 1) +} +// Macro for Writing STRENGTH and FilterOn +{ +#define writeDXVA_DeblockingEdgeControl(ptr, str, fon) ((*(ptr)) = ((str) << 1) | (fon)) +#define setDXVA_EdgeFilterStrength(ptr, str) ((*(ptr)) |= ((str) << 1)) +#define setDXVA_EdgeFilterOn(ptr) ((*(ptr)) |= 1) +} + + // Macroblock Control Command Data Structures */ + PDXVAMVvalue = ^TDXVAMVvalue; + _DXVA_MVvalue = record + horz,vert : smallint; + end; + {$EXTERNALSYM _DXVA_MVvalue} + DXVA_MVvalue = _DXVA_MVvalue; + {$EXTERNALSYM DXVA_MVvalue} + LPDXVA_MVvalue = ^DXVA_MVvalue; + {$EXTERNALSYM LPDXVA_MVvalue} + TDXVAMVvalue = _DXVA_MVvalue; + + // Inverse Quantization Matrices + PDXVAQmatrixData = ^TDXVAQmatrixData; + _DXVA_QmatrixData = record + bNewQmatrix : array [0..3] of BYTE; + // intra Y, inter Y, intra chroma, inter chroma + Qmatrix : array [0..3,0..(DXVA_USUAL_BLOCK_WIDTH*DXVA_USUAL_BLOCK_HEIGHT)-1] of WORD; + end; + {$EXTERNALSYM _DXVA_QmatrixData} + DXVA_QmatrixData = _DXVA_QmatrixData; + {$EXTERNALSYM DXVA_QmatrixData} + LPDXVA_QmatrixData = ^DXVA_QmatrixData; + {$EXTERNALSYM LPDXVA_QmatrixData} + TDXVAQmatrixData = _DXVA_QmatrixData; + + // Slice Control Buffer Data + PDXVASliceInfo = ^TDXVASliceInfo; + _DXVA_SliceInfo = record + wHorizontalPosition : WORD; + wVerticalPosition : WORD; + dwSliceBitsInBuffer : LongWord; + dwSliceDataLocation : LongWord; + bStartCodeBitOffset : BYTE; + bReservedBits : BYTE; + wMBbitOffset : WORD; + wNumberMBsInSlice : WORD; + wQuantizerScaleCode : WORD; + wBadSliceChopping : WORD; + end; + {$EXTERNALSYM _DXVA_SliceInfo} + DXVA_SliceInfo = _DXVA_SliceInfo; + {$EXTERNALSYM DXVA_SliceInfo} + LPDXVA_SliceInfo = ^DXVA_SliceInfo; + {$EXTERNALSYM LPDXVA_SliceInfo} + TDXVASliceInfo = _DXVA_SliceInfo; + +const + DXVA_NumMV_OBMC_off_BinPBwith4MV_off = 4; + {$EXTERNALSYM DXVA_NumMV_OBMC_off_BinPBwith4MV_off} + DXVA_NumMV_OBMC_off_BinPBwith4MV_on = (4+1); + {$EXTERNALSYM DXVA_NumMV_OBMC_off_BinPBwith4MV_on} + DXVA_NumMV_OBMC_on__BinPB_off = (10); + {$EXTERNALSYM DXVA_NumMV_OBMC_on__BinPB_off} + DXVA_NumMV_OBMC_on__BinPB_on = (11); // not current standards + {$EXTERNALSYM DXVA_NumMV_OBMC_on__BinPB_on} + + DXVA_NumBlocksPerMB_420 = (4+2+0); + {$EXTERNALSYM DXVA_NumBlocksPerMB_420} + DXVA_NumBlocksPerMB_422 = (4+2+2); + {$EXTERNALSYM DXVA_NumBlocksPerMB_422} + DXVA_NumBlocksPerMB_444 = (4+4+4); + {$EXTERNALSYM DXVA_NumBlocksPerMB_444} + +type + // Basic form for I pictures + // Host Residual Differences + _DXVA_MBctrl_I_HostResidDiff_1 = record + wMBaddress : WORD; + wMBtype : WORD; + dwMB_SNL : LongWord; + wPatternCode : WORD; + wPC_Overflow : WORD; + // zero if not overflow format + dwReservedBits2 : LongWord; + end; + {$EXTERNALSYM _DXVA_MBctrl_I_HostResidDiff_1} + DXVA_MBctrl_I_HostResidDiff_1 = _DXVA_MBctrl_I_HostResidDiff_1; + {$EXTERNALSYM DXVA_MBctrl_I_HostResidDiff_1} + TDXVAMBctrlIHostResidDiff1 = _DXVA_MBctrl_I_HostResidDiff_1; + + // Basic form for I pictures + // Off-Host IDCT, 4:2:0 sampling + _DXVA_MBctrl_I_OffHostIDCT_1 = record + wMBaddress : WORD; + wMBtype : WORD; + dwMB_SNL : LongWord; + wPatternCode : WORD; + bNumCoef : array [0..DXVA_NumBlocksPerMB_420-1] of BYTE; + end; + {$EXTERNALSYM _DXVA_MBctrl_I_OffHostIDCT_1} + DXVA_MBctrl_I_OffHostIDCT_1 = _DXVA_MBctrl_I_OffHostIDCT_1; + {$EXTERNALSYM DXVA_MBctrl_I_OffHostIDCT_1} + TDXVAMBctrlIOffHostIDCT1 = _DXVA_MBctrl_I_OffHostIDCT_1; + + // Basic form for P and B pictures + // Should also be used for concealment MVs in MPEG-2 I pictures + // Without OBMC, without BinPB and 4MV together, without MV RPS + // Host Residual Differences + _DXVA_MBctrl_P_HostResidDiff_1 = record + wMBaddress : WORD; + wMBtype : WORD; + dwMB_SNL : LongWord; + wPatternCode : WORD; + wPC_Overflow : WORD; + // zero if not overflow format + dwReservedBits2 : LongWord; + MVector : array [0..DXVA_NumMV_OBMC_off_BinPBwith4MV_off-1] of TDXVAMVvalue; + end; + {$EXTERNALSYM _DXVA_MBctrl_P_HostResidDiff_1} + DXVA_MBctrl_P_HostResidDiff_1 = _DXVA_MBctrl_P_HostResidDiff_1; + {$EXTERNALSYM DXVA_MBctrl_P_HostResidDiff_1} + TDXVAMBctrlPHostResidDiff1 = _DXVA_MBctrl_P_HostResidDiff_1; + + // Basic form for P and B pictures + // Without OBMC, without BinPB and 4MV together, without MV RPS + // Off-Host IDCT, 4:2:0 sampling + _DXVA_MBctrl_P_OffHostIDCT_1 = record + wMBaddress : WORD; + wMBtype : WORD; + dwMB_SNL : LongWord; + wPatternCode : WORD; + bNumCoef : array [0..DXVA_NumBlocksPerMB_420-1] of BYTE; + MVector : array [0..DXVA_NumMV_OBMC_off_BinPBwith4MV_off-1] of TDXVAMVvalue; + end; + {$EXTERNALSYM _DXVA_MBctrl_P_OffHostIDCT_1} + DXVA_MBctrl_P_OffHostIDCT_1 = _DXVA_MBctrl_P_OffHostIDCT_1; + {$EXTERNALSYM DXVA_MBctrl_P_OffHostIDCT_1} + TDXVAMBctrlPOffHostIDCT1 = _DXVA_MBctrl_P_OffHostIDCT_1; + + // How to load alpha blending graphic data + PDXVAConfigAlphaLoad = ^TDXVAConfigAlphaLoad; + _DXVA_ConfigAlphaLoad = record + // Operation Indicated + dwFunction: DXVA_ConfigQueryOrReplyFunc ; + // Alignment + dwReservedBits: array[0..2] of DWORD; + bConfigDataType: BYTE; + end; + {$EXTERNALSYM _DXVA_ConfigAlphaLoad} + DXVA_ConfigAlphaLoad = _DXVA_ConfigAlphaLoad; + {$EXTERNALSYM DXVA_ConfigAlphaLoad} + LPDXVA_ConfigAlphaLoad = ^DXVA_ConfigAlphaLoad; + {$EXTERNALSYM LPDXVA_ConfigAlphaLoad} + TDXVAConfigAlphaLoad = _DXVA_ConfigAlphaLoad; + +const + DXVA_CONFIG_DATA_TYPE_IA44 = 0; + {$EXTERNALSYM DXVA_CONFIG_DATA_TYPE_IA44} + DXVA_CONFIG_DATA_TYPE_AI44 = 1; + {$EXTERNALSYM DXVA_CONFIG_DATA_TYPE_AI44} + DXVA_CONFIG_DATA_TYPE_DPXD = 2; + {$EXTERNALSYM DXVA_CONFIG_DATA_TYPE_DPXD} + DXVA_CONFIG_DATA_TYPE_AYUV = 3; + {$EXTERNALSYM DXVA_CONFIG_DATA_TYPE_AYUV} + + +// How to combine alpha blending graphic data +type + PDXVAConfigAlphaCombine = ^TDXVAConfigAlphaCombine; + _DXVA_ConfigAlphaCombine = record + // Operation Indicated + dwFunction: DXVA_ConfigQueryOrReplyFunc; + // Alignment + dwReservedBits: array[0..2] of DWORD; + bConfigBlendType: BYTE; + bConfigPictureResizing: BYTE; + bConfigOnlyUsePicDestRectArea: BYTE; + bConfigGraphicResizing: BYTE; + bConfigWholePlaneAlpha: BYTE; + end; + {$EXTERNALSYM _DXVA_ConfigAlphaCombine} + DXVA_ConfigAlphaCombine = _DXVA_ConfigAlphaCombine; + {$EXTERNALSYM DXVA_ConfigAlphaCombine} + LPDXVA_ConfigAlphaCombine = ^DXVA_ConfigAlphaCombine; + {$EXTERNALSYM LPDXVA_ConfigAlphaCombine} + TDXVAConfigAlphaCombine = _DXVA_ConfigAlphaCombine; + +const + DXVA_CONFIG_BLEND_TYPE_FRONT_BUFFER = 0; + {$EXTERNALSYM DXVA_CONFIG_BLEND_TYPE_FRONT_BUFFER} + DXVA_CONFIG_BLEND_TYPE_BACK_HARDWARE = 1; + {$EXTERNALSYM DXVA_CONFIG_BLEND_TYPE_BACK_HARDWARE} + +// AYUV sample for 16-entry YUV palette or graphic surface +type + PDXVAAYUVsample2 = ^TDXVAAYUVsample2; + _DXVA_AYUVsample2 = record + bCrValue : BYTE; + bCbValue : BYTE; + bY_Value : BYTE; + bSampleAlpha8 : BYTE; + end; + {$EXTERNALSYM _DXVA_AYUVsample2} + DXVA_AYUVsample2 = _DXVA_AYUVsample2; + {$EXTERNALSYM DXVA_AYUVsample2} + LPDXVA_AYUVsample2 = ^DXVA_AYUVsample2; + {$EXTERNALSYM LPDXVA_AYUVsample2} + TDXVAAYUVsample2 = _DXVA_AYUVsample2; + + // Macros for IA44 alpha blending surface samples + DXVA_AI44sample = {$IFDEF TYPE_IDENTITY}type {$ENDIF} BYTE; + {$EXTERNALSYM DXVA_AI44sample} + LPDXVA_AI44sample = ^DXVA_AI44sample; + {$EXTERNALSYM LPDXVA_AI44sample} + +{ +#define readDXVA_AI44index(ptr) ((*(ptr)) & 0x0F) +#define readDXVA_AI44alpha(ptr) (((*(ptr)) & 0xF0) >> 4) +#define writeDXVA_AI44(ptr, idx, alpha) ((*(ptr)) = (((alpha) << 4) | (idx))) +#define setDXVA_AI44index(ptr, idx) ((*(ptr)) |= (idx)) +#define setDXVA_AI44alpha(ptr, alpha) ((*(ptr)) |= ((alpha) << 4)) +} + + // Highlight data structure + PDXVAHighlight = ^TDXVAHighlight; + _DXVA_Highlight = record + wHighlightActive : WORD; + wHighlightIndices : WORD; + wHighlightAlphas : WORD; + HighlightRect : TRect; + end; + {$EXTERNALSYM _DXVA_Highlight} + DXVA_Highlight = _DXVA_Highlight; + {$EXTERNALSYM DXVA_Highlight} + LPDXVA_Highlight = ^DXVA_Highlight; + {$EXTERNALSYM LPDXVA_Highlight} + TDXVAHighlight = _DXVA_Highlight; + + DXVA_DPXD = {$IFDEF TYPE_IDENTITY}type {$ENDIF} BYTE; + {$EXTERNALSYM DXVA_DPXD} + LPDXVA_DPXD = ^DXVA_DPXD; + {$EXTERNALSYM LPDXVA_DPXD} + DXVA_DCCMD = {$IFDEF TYPE_IDENTITY}type {$ENDIF} WORD; + {$EXTERNALSYM DXVA_DCCMD} + LPDXVA_DCCMD = ^DXVA_DCCMD; + {$EXTERNALSYM LPDXVA_DCCMD} + + // Alpha blend combination + PDXVABlendCombination = ^TDXVABlendCombination; + _DXVA_BlendCombination = record + wPictureSourceIndex : WORD; + wBlendedDestinationIndex : WORD; + PictureSourceRect16thPel : TRECT; + PictureDestinationRect : TRECT; + GraphicSourceRect : TRECT; + GraphicDestinationRect : TRECT; + wBlendDelay : WORD; + bBlendOn : BYTE; + bWholePlaneAlpha : BYTE; + OutsideYUVcolor : TDXVAAYUVsample2; + end; + {$EXTERNALSYM _DXVA_BlendCombination} + DXVA_BlendCombination = _DXVA_BlendCombination; + {$EXTERNALSYM DXVA_BlendCombination} + LPDXVA_BlendCombination = ^DXVA_BlendCombination; + {$EXTERNALSYM LPDXVA_BlendCombination} + TDXVABlendCombination = _DXVA_BlendCombination; + + LPDXVA_MBctrl_I_HostResidDiff_1 = ^DXVA_MBctrl_I_HostResidDiff_1; + {$EXTERNALSYM LPDXVA_MBctrl_I_HostResidDiff_1} + LPDXVA_MBctrl_I_OffHostIDCT_1 = ^DXVA_MBctrl_I_OffHostIDCT_1; + {$EXTERNALSYM LPDXVA_MBctrl_I_OffHostIDCT_1} + LPDXVA_MBctrl_P_HostResidDiff_1 = ^DXVA_MBctrl_P_HostResidDiff_1; + {$EXTERNALSYM LPDXVA_MBctrl_P_HostResidDiff_1} + LPDXVA_MBctrl_P_OffHostIDCT_1 = ^DXVA_MBctrl_P_OffHostIDCT_1; + {$EXTERNALSYM LPDXVA_MBctrl_P_OffHostIDCT_1} + +//#pragma pack(pop) + +// +// Other forms of pictures are constructed in the obvious way +// from the above by adjusting the number of residual difference +// blocks, the number of motion vectors per macroblock, etc. +// +{ +#define readDXVA_MBskipsFollowing(ptr) (((ptr)->dwMB_SNL & 0xFF000000) >> 24) +#define readDXVA_MBdataLocation(ptr) (((ptr)->dwMB_SNL & 0x00FFFFFF)) + +#define writeDXVA_MB_SNL(ptr, skips, dloc) ((ptr)->dwMB_SNL = (((skips) << 24) | (dloc))) +#define setDXVA_MBskipsFollowing(ptr, skips) ((ptr)->dwMB_SNL |= ((skips) << 24)) +#define setDXVA_MBdataLocation(ptr, dloc) ((ptr)->dwMB_SNL |= (dloc)) + +#define readDXVA_MvertFieldSel_3(ptr) (((ptr)->wMBtype & 0x8000) >> 15) +#define readDXVA_MvertFieldSel_2(ptr) (((ptr)->wMBtype & 0x4000) >> 14) +#define readDXVA_MvertFieldSel_1(ptr) (((ptr)->wMBtype & 0x2000) >> 13) +#define readDXVA_MvertFieldSel_0(ptr) (((ptr)->wMBtype & 0x1000) >> 12) +#define readDXVA_ReservedBits(ptr) (((ptr)->wMBtype & 0x0800) >> 11) +#define readDXVA_HostResidDiff(ptr) (((ptr)->wMBtype & 0x0400) >> 10) +#define readDXVA_MotionType(ptr) (((ptr)->wMBtype & 0x0300) >> 8) +#define readDXVA_MBscanMethod(ptr) (((ptr)->wMBtype & 0x00C0) >> 6) +#define readDXVA_FieldResidual(ptr) (((ptr)->wMBtype & 0x0020) >> 5) +#define readDXVA_H261LoopFilter(ptr) (((ptr)->wMBtype & 0x0010) >> 4) +#define readDXVA_Motion4MV(ptr) (((ptr)->wMBtype & 0x0008) >> 3) +#define readDXVA_MotionBackward(ptr) (((ptr)->wMBtype & 0x0004) >> 2) +#define readDXVA_MotionForward(ptr) (((ptr)->wMBtype & 0x0002) >> 1) +#define readDXVA_IntraMacroblock(ptr) (((ptr)->wMBtype & 0x0001)) + +#define setDXVA_MvertFieldSel_3(ptr) ((ptr)->wMBtype |= 0x8000) +#define setDXVA_MvertFieldSel_2(ptr) ((ptr)->wMBtype |= 0x4000) +#define setDXVA_MvertFieldSel_1(ptr) ((ptr)->wMBtype |= 0x2000) +#define setDXVA_MvertFieldSel_0(ptr) ((ptr)->wMBtype |= 0x1000) +#define setDXVA_ReservedBits(ptr) ((ptr)->wMBtype |= 0x0800) +#define setDXVA_HostResidDiff(ptr) ((ptr)->wMBtype |= 0x0400) +#define setDXVA_MotionType(ptr, value) ((ptr)->wMBtype |= ((value) << 8)) +#define setDXVA_MBscanMethod(ptr, value) ((ptr)->wMBtype |= ((value) << 6)) +#define setDXVA_FieldResidual(ptr) ((ptr)->wMBtype |= 0x0020) +#define setDXVA_H261LoopFilter(ptr) ((ptr)->wMBtype |= 0x0010) +#define setDXVA_Motion4MV(ptr) ((ptr)->wMBtype |= 0x0008) +#define setDXVA_MotionBackward(ptr) ((ptr)->wMBtype |= 0x0004) +#define setDXVA_MotionForward(ptr) ((ptr)->wMBtype |= 0x0002) +#define setDXVA_IntraMacroblock(ptr) ((ptr)->wMBtype |= 0x0001) + +#define readDXVA_Y___0coded(ptr) (((ptr)->wPatternCode & 0x0800) >> 11) +#define readDXVA_Y___1coded(ptr) (((ptr)->wPatternCode & 0x0400) >> 10) +#define readDXVA_Y___2coded(ptr) (((ptr)->wPatternCode & 0x0200) >> 9) +#define readDXVA_Y___3coded(ptr) (((ptr)->wPatternCode & 0x0100) >> 8) +#define readDXVA_Cb__4coded(ptr) (((ptr)->wPatternCode & 0x0080) >> 7) +#define readDXVA_Cr__5coded(ptr) (((ptr)->wPatternCode & 0x0040) >> 6) +#define readDXVA_Cb__6coded(ptr) (((ptr)->wPatternCode & 0x0020) >> 5) +#define readDXVA_Cr__7coded(ptr) (((ptr)->wPatternCode & 0x0010) >> 4) +#define readDXVA_Cb__8coded(ptr) (((ptr)->wPatternCode & 0x0008) >> 3) +#define readDXVA_Cb__9coded(ptr) (((ptr)->wPatternCode & 0x0004) >> 2) +#define readDXVA_Cr_10coded(ptr) (((ptr)->wPatternCode & 0x0002) >> 1) +#define readDXVA_Cr_11coded(ptr) (((ptr)->wPatternCode & 0x0001)) + +#define readDXVA_Y___0oflow(ptr) (((ptr)->wPC_Overflow & 0x0800) >> 11) +#define readDXVA_Y___1oflow(ptr) (((ptr)->wPC_Overflow & 0x0400) >> 10) +#define readDXVA_Y___2oflow(ptr) (((ptr)->wPC_Overflow & 0x0200) >> 9) +#define readDXVA_Y___3oflow(ptr) (((ptr)->wPC_Overflow & 0x0100) >> 8) +#define readDXVA_Cb__4oflow(ptr) (((ptr)->wPC_Overflow & 0x0080) >> 7) +#define readDXVA_Cr__5oflow(ptr) (((ptr)->wPC_Overflow & 0x0040) >> 6) +#define readDXVA_Cb__6oflow(ptr) (((ptr)->wPC_Overflow & 0x0020) >> 5) +#define readDXVA_Cr__7oflow(ptr) (((ptr)->wPC_Overflow & 0x0010) >> 4) +#define readDXVA_Cb__8oflow(ptr) (((ptr)->wPC_Overflow & 0x0008) >> 3) +#define readDXVA_Cb__9oflow(ptr) (((ptr)->wPC_Overflow & 0x0004) >> 2) +#define readDXVA_Cr_10oflow(ptr) (((ptr)->wPC_Overflow & 0x0002) >> 1) +#define readDXVA_Cr_11oflow(ptr) (((ptr)->wPC_Overflow & 0x0001)) +} + +// ------------------------------------------------------------------------- +// +// D3DFORMAT describes a pixel memory layout, DXVA sample format contains +// additional information that describes how the pixels should be interpreted. +// +// ------------------------------------------------------------------------- + +//#define DXVABit(__x) (1 << __x) +const + DXVA_SampleFormatMask = $FF; // 8 bits used for DXVA Sample format + {$EXTERNALSYM DXVA_SampleFormatMask} + +type + DXVA_SampleFormat = ( + DXVA_SampleUnknown, + DXVA_SamplePreviousFrame, + DXVA_SampleProgressiveFrame, + DXVA_SampleFieldInterleavedEvenFirst, + DXVA_SampleFieldInterleavedOddFirst, + DXVA_SampleFieldSingleEven, + DXVA_SampleFieldSingleOdd, + DXVA_SampleSubStream + ); + {$EXTERNALSYM DXVA_SampleFormat} + TDXVASampleFormat = DXVA_SampleFormat; + +//#define DXVA_ExtractSampleFormat(_sf) ((_sf) & (DXVA_SampleFormatMask)) + +// ------------------------------------------------------------------------- +// +// DXVA Extended color data - occupies the HIWORD of the SampleFormat DWORD +// use the DXVA_ExtractExtColorData macro to extract the individual color +// data fields. +// +// The packed form is: +// VideoTransferFunction (bits 15..12) +// VideoPrimaries (bits 11..8) +// VideoLighting (bits 7..5) +// VideoTransferMatrix (Y'Cb'Cr') OR VideoNominalRange (RGB images) (bits 4..2) +// VideoChromaSubsampling (bits 1..0) +// +// ------------------------------------------------------------------------- + +//#define DXVA_ExtractExtColorData(_sf, _Mask, _Shift) \ +// (((_sf) >> (_Shift)) & (_Mask)) + +const + DXVA_ExtColorData_ShiftBase = 16; + {$EXTERNALSYM DXVA_ExtColorData_ShiftBase} + + DXVA_VideoTransFuncMask = (1 shl 15) or (1 shl 14) or (1 shl 13) or (1 shl 12); + {$EXTERNALSYM DXVA_VideoTransFuncMask} + DXVA_VideoTransFuncShift = (DXVA_ExtColorData_ShiftBase + 12); + {$EXTERNALSYM DXVA_VideoTransFuncShift} + +type + DXVA_VideoTransferFunction = ( + DXVA_VideoTransFunc_Unknown, + DXVA_VideoTransFunc_10, + DXVA_VideoTransFunc_18, + DXVA_VideoTransFunc_20, + DXVA_VideoTransFunc_22, + DXVA_VideoTransFunc_22_8bit, + DXVA_VideoTransFunc_22_8bit_240M, + DXVA_VideoTransFunc_24_8bit_sRGB, + DXVA_VideoTransFunc_28 + ); + {$EXTERNALSYM DXVA_VideoTransferFunction} + TDXVAVideoTransferFunction = DXVA_VideoTransferFunction; + +const + DXVA_VideoPrimariesMask = (1 shl 11)or (1 shl 10) or (1 shl 9) or (1 shl 8); + {$EXTERNALSYM DXVA_VideoPrimariesMask} + DXVA_VideoPrimariesShift = (DXVA_ExtColorData_ShiftBase + 8); + {$EXTERNALSYM DXVA_VideoPrimariesShift} + +type + DXVA_VideoPrimaries = ( + DXVA_VideoPrimaries_Unknown, + DXVA_VideoPrimaries_BT601, + DXVA_VideoPrimaries_BT709, + DXVA_VideoPrimaries_BT470_2_SysM, + DXVA_VideoPrimaries_BT470_2_SysBG, + DXVA_VideoPrimaries_SMPTE170M, + DXVA_VideoPrimaries_SMPTE240M, + DXVA_VideoPrimaries_EBU3213, + DXVA_VideoPrimaries_SMPTE_C + ); + {$EXTERNALSYM DXVA_VideoPrimaries} + TDXVAVideoPrimaries = DXVA_VideoPrimaries; + +const + DXVA_VideoLightingMask = (1 shl 7)or (1 shl 6) or (1 shl 5); + {$EXTERNALSYM DXVA_VideoLightingMask} + DXVA_VideoLightingShift = (DXVA_ExtColorData_ShiftBase + 5); + {$EXTERNALSYM DXVA_VideoLightingShift} + +type + DXVA_VideoLighting = ( + DXVA_VideoLighting_Unknown, + DXVA_VideoLighting_bright, + DXVA_VideoLighting_office, + DXVA_VideoLighting_dim, + DXVA_VideoLighting_dark + ); + {$EXTERNALSYM DXVA_VideoLighting} + TDXVAVideoLighting = DXVA_VideoLighting; + +// ------------------------------------------------------------------------- +// Note: +// +// DXVA_NominalRange and DXVA_VideoTransferMatrix are unioned together. +// +// ------------------------------------------------------------------------- +// + +const + DXVA_VideoTransferMatrixMask = (1 shl 4) or (1 shl 3) or (1 shl 2); + {$EXTERNALSYM DXVA_VideoTransferMatrixMask} + DXVA_VideoTransferMatrixShift = (DXVA_ExtColorData_ShiftBase + 2); + {$EXTERNALSYM DXVA_VideoTransferMatrixShift} + +type + DXVA_VideoTransferMatrix = ( + DXVA_VideoTransferMatrix_Unknown, + DXVA_VideoTransferMatrix_BT709, + DXVA_VideoTransferMatrix_BT601, + DXVA_VideoTransferMatrix_SMPTE240M + ); + {$EXTERNALSYM DXVA_VideoTransferMatrix} + TDXVAVideoTransferMatrix = DXVA_VideoTransferMatrix; + +const + DXVA_NominalRangeMask = (1 shl 4) or (1 shl 3) or (1 shl 2); + {$EXTERNALSYM DXVA_NominalRangeMask} + DXVA_NominalRangeShift = (DXVA_ExtColorData_ShiftBase + 2); + {$EXTERNALSYM DXVA_NominalRangeShift} + +type + DXVA_NominalRange = ( + DXVA_NominalRange_Normal, + DXVA_NominalRange_Wide + ); + {$EXTERNALSYM DXVA_NominalRange} + TDXVANominalRange = DXVA_NominalRange; + +const + DXVA_VideoChromaSubsamplingMask = (1 shl 1) or (1 shl 0); + {$EXTERNALSYM DXVA_VideoChromaSubsamplingMask} + DXVA_VideoChromaSubsamplingShift = (DXVA_ExtColorData_ShiftBase + 0); + {$EXTERNALSYM DXVA_VideoChromaSubsamplingShift} + +type + DXVA_VideoChromaSubsampling = ( + DXVA_VideoChromaSubsampling_Unknown, + DXVA_VideoChromaSubsampling_non_cosited, + DXVA_VideoChromaSubsampling_cosited + ); + {$EXTERNALSYM DXVA_VideoChromaSubsampling} + TDXVAVideoChromaSubsampling = DXVA_VideoChromaSubsampling; + +// ------------------------------------------------------------------------- +// +// The definitions that follow describe the video de-interlace interface +// between the VMR and the graphics device driver. This interface is not +// accessable via the IAMVideoAccelerator interface. +// +// ------------------------------------------------------------------------- +// +const + DXVA_DeinterlaceBobDevice : TGUID = '{335aa36e-7884-43a4-9c91-7f87faf3e37e}'; + {$EXTERNALSYM DXVA_DeinterlaceBobDevice} + DXVA_DeinterlaceContainerDevice : TGUID = '{0e85cb93-3046-4ff0-aecc-d58cb5f035fd}'; + {$EXTERNALSYM DXVA_DeinterlaceContainerDevice} + +type + _DXVA_Frequency = record + Numerator : DWORD; + Denominator : DWORD; + end; + {$EXTERNALSYM _DXVA_Frequency} + DXVA_Frequency = _DXVA_Frequency; + {$EXTERNALSYM DXVA_Frequency} + TDXVAFrequency = _DXVA_Frequency; + + PDXVAVideoDesc = ^TDXVAVideoDesc; + _DXVA_VideoDesc = record + Size : DWORD; + SampleWidth : DWORD; + SampleHeight : DWORD; + SampleFormat : DWORD; // also contains extend color data + d3dFormat : TD3DFORMAT; + InputSampleFreq : TDXVAFrequency; + OutputFrameFreq : TDXVAFrequency; + end; + {$EXTERNALSYM _DXVA_VideoDesc} + DXVA_VideoDesc = _DXVA_VideoDesc; + {$EXTERNALSYM DXVA_VideoDesc} + LPDXVA_VideoDesc = ^DXVA_VideoDesc; + {$EXTERNALSYM LPDXVA_VideoDesc} + TDXVAVideoDesc = _DXVA_VideoDesc; + + DXVA_VideoProcessCaps = {$IFDEF TYPE_IDENTITY}type {$ENDIF} LongWord; + {$EXTERNALSYM DXVA_VideoProcessCaps} +const + DXVA_VideoProcess_None = $0000; + {$EXTERNALSYM DXVA_VideoProcess_None} + DXVA_VideoProcess_YUV2RGB = $0001; + {$EXTERNALSYM DXVA_VideoProcess_YUV2RGB} + DXVA_VideoProcess_StretchX = $0002; + {$EXTERNALSYM DXVA_VideoProcess_StretchX} + DXVA_VideoProcess_StretchY = $0004; + {$EXTERNALSYM DXVA_VideoProcess_StretchY} + DXVA_VideoProcess_AlphaBlend = $0008; + {$EXTERNALSYM DXVA_VideoProcess_AlphaBlend} + DXVA_VideoProcess_SubRects = $0010; + {$EXTERNALSYM DXVA_VideoProcess_SubRects} + DXVA_VideoProcess_SubStreams = $0020; + {$EXTERNALSYM DXVA_VideoProcess_SubStreams} + DXVA_VideoProcess_SubStreamsExtended = $0040; + {$EXTERNALSYM DXVA_VideoProcess_SubStreamsExtended} + DXVA_VideoProcess_YUV2RGBExtended = $0080; + {$EXTERNALSYM DXVA_VideoProcess_YUV2RGBExtended} + DXVA_VideoProcess_AlphaBlendExtended = $0100; + {$EXTERNALSYM DXVA_VideoProcess_AlphaBlendExtended} + +type + DXVA_DeinterlaceTech = {$IFDEF TYPE_IDENTITY}type {$ENDIF} LongWord; + {$EXTERNALSYM DXVA_DeinterlaceTech} + const + // the algorithm is unknown or proprietary + DXVA_DeinterlaceTech_Unknown = $0000; + {$EXTERNALSYM DXVA_DeinterlaceTech_Unknown} + + // the algorithm creates the missing lines by repeating + // the line either above or below it - this method will look very jaggy and + // isn't recommended + DXVA_DeinterlaceTech_BOBLineReplicate = $0001; + {$EXTERNALSYM DXVA_DeinterlaceTech_BOBLineReplicate} + + // The algorithm creates the missing lines by vertically stretching each + // video field by a factor of two by averaging two lines + DXVA_DeinterlaceTech_BOBVerticalStretch = $0002; + {$EXTERNALSYM DXVA_DeinterlaceTech_BOBVerticalStretch} + + // or using a [-1, 9, 9, -1]/16 filter across four lines. + DXVA_DeinterlaceTech_BOBVerticalStretch4Tap = $0100; + {$EXTERNALSYM DXVA_DeinterlaceTech_BOBVerticalStretch4Tap} + + // the pixels in the missing line are recreated by a median filtering operation + DXVA_DeinterlaceTech_MedianFiltering = $0004; + {$EXTERNALSYM DXVA_DeinterlaceTech_MedianFiltering} + + // the pixels in the missing line are recreated by an edge filter. + // In this process, spatial directional filters are applied to determine + // the orientation of edges in the picture content, and missing + // pixels are created by filtering along (rather than across) the + // detected edges. + DXVA_DeinterlaceTech_EdgeFiltering = $0010; + {$EXTERNALSYM DXVA_DeinterlaceTech_EdgeFiltering} + + // the pixels in the missing line are recreated by switching on a field by + // field basis between using either spatial or temporal interpolation + // depending on the amount of motion. + DXVA_DeinterlaceTech_FieldAdaptive = $0020; + {$EXTERNALSYM DXVA_DeinterlaceTech_FieldAdaptive} + + // the pixels in the missing line are recreated by switching on a pixel by pixel + // basis between using either spatial or temporal interpolation depending on + // the amount of motion.. + DXVA_DeinterlaceTech_PixelAdaptive = $0040; + {$EXTERNALSYM DXVA_DeinterlaceTech_PixelAdaptive} + + // Motion Vector Steering identifies objects within a sequence of video + // fields. The missing pixels are recreated after first aligning the + // movement axes of the individual objects in the scene to make them + // parallel with the time axis. + DXVA_DeinterlaceTech_MotionVectorSteered = $0080; + {$EXTERNALSYM DXVA_DeinterlaceTech_MotionVectorSteered} + +type + PDXVAVideoSample = ^TDXVAVideoSample; + _DXVA_VideoSample = record + rtStart : TReferenceTime; + rtEnd : TReferenceTime; + SampleFormat : TDXVASampleFormat; // only lower 8 bits used + lpDDSSrcSurface : Pointer; + end; + {$EXTERNALSYM _DXVA_VideoSample} + DXVA_VideoSample = _DXVA_VideoSample; + {$EXTERNALSYM DXVA_VideoSample} + LPDXVA_VideoSample = ^DXVA_VideoSample; + {$EXTERNALSYM LPDXVA_VideoSample} + TDXVAVideoSample = _DXVA_VideoSample; + + +// ------------------------------------------------------------------------- +// DeinterlaceBltEx declarations +// ------------------------------------------------------------------------- +// +type + DXVA_SampleFlags = LongWord; + {$EXTERNALSYM DXVA_SampleFlags} +const + DXVA_SampleFlagsMask = (1 shl 3) or (1 shl 2) or (1 shl 1) or (1 shl 0); + {$EXTERNALSYM DXVA_SampleFlagsMask} + DXVA_SampleFlag_Palette_Changed = $0001; + {$EXTERNALSYM DXVA_SampleFlag_Palette_Changed} + DXVA_SampleFlag_SrcRect_Changed = $0002; + {$EXTERNALSYM DXVA_SampleFlag_SrcRect_Changed} + DXVA_SampleFlag_DstRect_Changed = $0004; + {$EXTERNALSYM DXVA_SampleFlag_DstRect_Changed} + DXVA_SampleFlag_ColorData_Changed = $0008; + {$EXTERNALSYM DXVA_SampleFlag_ColorData_Changed} + +type + DXVA_DestinationFlags = LongWord; +const + DXVA_DestinationFlagMask = (1 shl 3) or (1 shl 2) or (1 shl 1) or (1 shl 0); + {$EXTERNALSYM DXVA_DestinationFlagMask} + DXVA_DestinationFlag_Background_Changed = $0001; + {$EXTERNALSYM DXVA_DestinationFlag_Background_Changed} + DXVA_DestinationFlag_TargetRect_Changed = $0002; + {$EXTERNALSYM DXVA_DestinationFlag_TargetRect_Changed} + DXVA_DestinationFlag_ColorData_Changed = $0004; + {$EXTERNALSYM DXVA_DestinationFlag_ColorData_Changed} + DXVA_DestinationFlag_Alpha_Changed = $0008; + {$EXTERNALSYM DXVA_DestinationFlag_Alpha_Changed} + +type + PDXVAVideoSample2 = ^TDXVAVideoSample2; + DXVA_VideoSample2 = record + rtStart: REFERENCE_TIME; + rtEnd: REFERENCE_TIME; + SampleFormat: DWORD; + SampleFlags: DWORD; + lpDDSSrcSurface: Pointer; + rcSrc: TRect; + rcDst: TRect; + Palette: array[0..15] of TDXVAAYUVsample2; + end; + {$EXTERNALSYM DXVA_VideoSample2} + LPDXVA_VideoSample2 = ^DXVA_VideoSample2; + {$EXTERNALSYM LPDXVA_VideoSample2} + TDXVAVideoSample2 = DXVA_VideoSample2; + + PDXVADeinterlaceCaps = ^TDXVADeinterlaceCaps; + _DXVA_DeinterlaceCaps = record + Size : DWORD; + NumPreviousOutputFrames : DWORD; + InputPool : DWORD; + NumForwardRefSamples : DWORD; + NumBackwardRefSamples : DWORD; + d3dOutputFormat : TD3DFORMAT; + VideoProcessingCaps : DXVA_VideoProcessCaps; + DeinterlaceTechnology : DXVA_DeinterlaceTech; + end; + {$EXTERNALSYM _DXVA_DeinterlaceCaps} + DXVA_DeinterlaceCaps = _DXVA_DeinterlaceCaps; + {$EXTERNALSYM DXVA_DeinterlaceCaps} + LPDXVA_DeinterlaceCaps = ^DXVA_DeinterlaceCaps; + {$EXTERNALSYM LPDXVA_DeinterlaceCaps} + TDXVADeinterlaceCaps = _DXVA_DeinterlaceCaps; + + +// ------------------------------------------------------------------------- +// Data types used with RenderMoComp in kernel mode +// ------------------------------------------------------------------------- + +const + // Function codes for RenderMoComp + MAX_DEINTERLACE_SURFACES = 32; + {$EXTERNALSYM MAX_DEINTERLACE_SURFACES} + +type + PDXVADeinterlaceBlt = ^TDXVADeinterlaceBlt; + _DXVA_DeinterlaceBlt = record + Size : DWORD; + Reserved : DWORD; + rtTarget : TReferenceTime; + DstRect : TRECT; + SrcRect : TRECT; + NumSourceSurfaces : DWORD; + Alpha : Single; + Source: array[0..MAX_DEINTERLACE_SURFACES-1] of TDXVAVideoSample; + end; + {$EXTERNALSYM _DXVA_DeinterlaceBlt} + DXVA_DeinterlaceBlt = _DXVA_DeinterlaceBlt; + {$EXTERNALSYM DXVA_DeinterlaceBlt} + TDXVADeinterlaceBlt = _DXVA_DeinterlaceBlt; + +const + DXVA_DeinterlaceBltFnCode = $01; + {$EXTERNALSYM DXVA_DeinterlaceBltFnCode} + // lpInput => DXVA_DeinterlaceBlt* + // lpOuput => NULL /* not currently used */ + +type + DXVA_DeinterlaceBltEx = record + Size: DWORD; + BackgroundColor : DXVA_AYUVsample2; + rcTarget : TRect; + rtTarget : REFERENCE_TIME; + NumSourceSurfaces : DWORD; + Alpha : Single; + Source : array[0..MAX_DEINTERLACE_SURFACES-1] of DXVA_VideoSample2; + DestinationFormat : DWORD; + DestinationFlags : DWORD; + end; + {$EXTERNALSYM DXVA_DeinterlaceBltEx} + +const + DXVA_DeinterlaceBltExFnCode = $02; + {$EXTERNALSYM DXVA_DeinterlaceBltExFnCode} +// lpInput => DXVA_DeinterlaceBltEx* +// lpOuput => NULL /* not currently used */ + + + MAX_DEINTERLACE_DEVICE_GUIDS = 32; + {$EXTERNALSYM MAX_DEINTERLACE_DEVICE_GUIDS} + +type + PDXVADeinterlaceQueryAvailableModes = ^TDXVADeinterlaceQueryAvailableModes; + _DXVA_DeinterlaceQueryAvailableModes = record + Size : DWORD; + NumGuids : DWORD; + Guids: array[0..MAX_DEINTERLACE_DEVICE_GUIDS-1] of TGUID; + end; + {$EXTERNALSYM _DXVA_DeinterlaceQueryAvailableModes} + DXVA_DeinterlaceQueryAvailableModes = _DXVA_DeinterlaceQueryAvailableModes; + {$EXTERNALSYM DXVA_DeinterlaceQueryAvailableModes} + TDXVADeinterlaceQueryAvailableModes = _DXVA_DeinterlaceQueryAvailableModes; + +const + TDXVA_DeinterlaceQueryAvailableModesFnCode = $01; + {$EXTERNALSYM TDXVA_DeinterlaceQueryAvailableModesFnCode} + // lpInput => DXVA_VideoDesc* + // lpOuput => DXVA_DeinterlaceQueryAvailableModes* + +type + PDXVADeinterlaceQueryModeCaps = ^TDXVADeinterlaceQueryModeCaps; + _DXVA_DeinterlaceQueryModeCaps = record + Size : DWORD; + Guid : TGUID; + VideoDesc : TDXVAVideoDesc; + end; + {$EXTERNALSYM _DXVA_DeinterlaceQueryModeCaps} + DXVA_DeinterlaceQueryModeCaps = _DXVA_DeinterlaceQueryModeCaps; + {$EXTERNALSYM DXVA_DeinterlaceQueryModeCaps} + TDXVADeinterlaceQueryModeCaps = _DXVA_DeinterlaceQueryModeCaps; + +const + DXVA_DeinterlaceQueryModeCapsFnCode = $02; + {$EXTERNALSYM DXVA_DeinterlaceQueryModeCapsFnCode} + // lpInput => DXVA_DeinterlaceQueryModeCaps* + // lpOuput => DXVA_DeinterlaceCaps* + +// ------------------------------------------------------------------------- +// +// The definitions that follow describe the video ProcAmp interface +// between the VMR and the graphics device driver. This interface is not +// accessable via the IAMVideoAccelerator interface. +// +// ------------------------------------------------------------------------- +// +const + DXVA_ProcAmpControlDevice : TGUID = '{9f200913-2ffd-4056-9f1e-e1b508f22dcf}'; + {$EXTERNALSYM DXVA_ProcAmpControlDevice} + +type + DXVA_ProcAmpControlProp = {$IFDEF TYPE_IDENTITY}type {$ENDIF} LongWord; + {$EXTERNALSYM DXVA_ProcAmpControlProp} + const + DXVA_ProcAmp_None = $0000; + {$EXTERNALSYM DXVA_ProcAmp_None} + DXVA_ProcAmp_Brightness = $0001; + {$EXTERNALSYM DXVA_ProcAmp_Brightness} + DXVA_ProcAmp_Contrast = $0002; + {$EXTERNALSYM DXVA_ProcAmp_Contrast} + DXVA_ProcAmp_Hue = $0004; + {$EXTERNALSYM DXVA_ProcAmp_Hue} + DXVA_ProcAmp_Saturation = $0008; + {$EXTERNALSYM DXVA_ProcAmp_Saturation} + +type + PDXVAProcAmpControlCaps = ^TDXVAProcAmpControlCaps; + _DXVA_ProcAmpControlCaps = record + Size : DWORD; + InputPool : DWORD; + d3dOutputFormat : TD3DFORMAT; + ProcAmpControlProps : DWORD; // see DXVA_ProcAmpControlProp + VideoProcessingCaps : DWORD; // see DXVA_VideoProcessCaps + end; + {$EXTERNALSYM _DXVA_ProcAmpControlCaps} + DXVA_ProcAmpControlCaps = _DXVA_ProcAmpControlCaps; + {$EXTERNALSYM DXVA_ProcAmpControlCaps} + LPDXVA_ProcAmpControlCaps = ^DXVA_ProcAmpControlCaps; + {$EXTERNALSYM LPDXVA_ProcAmpControlCaps} + TDXVAProcAmpControlCaps = _DXVA_ProcAmpControlCaps; + +const + DXVA_ProcAmpControlQueryCapsFnCode = $03; + {$EXTERNALSYM DXVA_ProcAmpControlQueryCapsFnCode} + // lpInput => DXVA_VideoDesc* + // lpOuput => DXVA_ProcAmpControlCaps* + +type + PDXVAProcAmpControlQueryRange = ^TDXVAProcAmpControlQueryRange; + _DXVA_ProcAmpControlQueryRange = record + Size : DWORD; + ProcAmpControlProp : DXVA_ProcAmpControlProp; + VideoDesc : TDXVAVideoDesc; + end; + {$EXTERNALSYM _DXVA_ProcAmpControlQueryRange} + DXVA_ProcAmpControlQueryRange = _DXVA_ProcAmpControlQueryRange; + {$EXTERNALSYM DXVA_ProcAmpControlQueryRange} + LPDXVA_ProcAmpControlQueryRange = ^DXVA_ProcAmpControlQueryRange; + {$EXTERNALSYM LPDXVA_ProcAmpControlQueryRange} + TDXVAProcAmpControlQueryRange = _DXVA_ProcAmpControlQueryRange; + + PDXVAVideoPropertyRange = ^TDXVAVideoPropertyRange; + _DXVA_VideoPropertyRange = record + MinValue : Single; + MaxValue : Single; + DefaultValue : Single; + StepSize : Single; + end; + {$EXTERNALSYM _DXVA_VideoPropertyRange} + DXVA_VideoPropertyRange = _DXVA_VideoPropertyRange; + {$EXTERNALSYM DXVA_VideoPropertyRange} + LPDXVA_VideoPropertyRange = ^DXVA_VideoPropertyRange; + {$EXTERNALSYM LPDXVA_VideoPropertyRange} + TDXVAVideoPropertyRange = _DXVA_VideoPropertyRange; + +const + DXVA_ProcAmpControlQueryRangeFnCode = $04; + {$EXTERNALSYM DXVA_ProcAmpControlQueryRangeFnCode} + // lpInput => DXVA_ProcAmpControlQueryRange* + // lpOuput => DXVA_VideoPropertyRange* + +type + PDXVAProcAmpControlBlt = ^TDXVAProcAmpControlBlt; + _DXVA_ProcAmpControlBlt = record + Size : DWORD; + DstRect : TRECT; + SrcRect : TRECT; + Alpha : Single; + Brightness : Single; + Contrast : Single; + Hue : Single; + Saturation : Single; + end; + {$EXTERNALSYM _DXVA_ProcAmpControlBlt} + DXVA_ProcAmpControlBlt = _DXVA_ProcAmpControlBlt; + {$EXTERNALSYM DXVA_ProcAmpControlBlt} + TDXVAProcAmpControlBlt = _DXVA_ProcAmpControlBlt; + +const + DXVA_ProcAmpControlBltFnCode = $01; + {$EXTERNALSYM DXVA_ProcAmpControlBltFnCode} + // lpInput => DXVA_ProcAmpControlBlt* + // lpOuput => NULL /* not currently used */ + +// ------------------------------------------------------------------------- +// +// The definitions that follow describe the Certified Output Protection +// Protocol between the VMR and the graphics device driver. This interface +// is not accessable via the IAMVideoAccelerator interface. +// +// ------------------------------------------------------------------------- +// + +const + DXVA_COPPDevice : TGUID = '{D2457ADD-8999-45ED-8A8A-D1AA047BA4D5}'; + {$EXTERNALSYM DXVA_COPPDevice} + + +// ------------------------------------------------------------------------- +// COPPGetCertificateLength +// ------------------------------------------------------------------------- + DXVA_COPPGetCertificateLengthFnCode = $01; + {$EXTERNALSYM DXVA_COPPGetCertificateLengthFnCode} +// lpInput => NULL +// lpOuput => DWORD* + + +// ------------------------------------------------------------------------- +// COPPKeyExchange +// ------------------------------------------------------------------------- + DXVA_COPPKeyExchangeFnCode = $02; + {$EXTERNALSYM DXVA_COPPKeyExchangeFnCode} +// lpInputData => NULL +// lpOuputData => GUID* + + +// ------------------------------------------------------------------------- +// COPPSequenceStart +// ------------------------------------------------------------------------- +type + PDXVACOPPSignature = ^TDXVACOPPSignature; + DXVA_COPPSignature = record + Signature: array[0..255] of Char; + end; + {$EXTERNALSYM DXVA_COPPSignature} + LPDXVA_COPPSignature = ^DXVA_COPPSignature; + {$EXTERNALSYM LPDXVA_COPPSignature} + TDXVACOPPSignature = DXVA_COPPSignature; + +const + DXVA_COPPSequenceStartFnCode = $03; + {$EXTERNALSYM DXVA_COPPSequenceStartFnCode} +// lpInputData => DXVA_COPPSignature* +// lpOuputData => NULL + + + +// ------------------------------------------------------------------------- +// COPPCommand +// ------------------------------------------------------------------------- +type + PDXVACOPPCommand = ^TDXVACOPPCommand; + DXVA_COPPCommand = packed record + macKDI: TGUID; // 16 bytes + guidCommandID: TGUID; // 16 bytes + dwSequence: ULONG; // 4 bytes + cbSizeData: ULONG; // 4 bytes + CommandData: array[0..4055] of Char; // 4056 bytes (4056+4+4+16+16 = 4096) + end; + {$EXTERNALSYM DXVA_COPPCommand} + LPDXVA_COPPCommand = ^DXVA_COPPCommand; + {$EXTERNALSYM LPDXVA_COPPCommand} + TDXVACOPPCommand = DXVA_COPPCommand; + +const + DXVA_COPPCommandFnCode = $04; + {$EXTERNALSYM DXVA_COPPCommandFnCode} +// lpInputData => DXVA_COPPCommand* +// lpOuputData => NULL + + DXVA_COPPSetProtectionLevel : TGUID = '{9bb9327c-4eb5-4727-9f00-b42b0919c0da}'; + {$EXTERNALSYM DXVA_COPPSetProtectionLevel} + +type + PDXVACOPPSetProtectionLevelCmdData = ^TDXVACOPPSetProtectionLevelCmdData; + DXVA_COPPSetProtectionLevelCmdData = packed record + ProtType: ULONG; + ProtLevel: ULONG; + TypeSpecificMask: ULONG; + TypeSpecificInfo: ULONG; + end; + {$EXTERNALSYM DXVA_COPPSetProtectionLevelCmdData} + TDXVACOPPSetProtectionLevelCmdData = DXVA_COPPSetProtectionLevelCmdData; + + +// Set the HDCP protection level - (0 - 1 DWORD, 4 bytes) + + COPP_HDCP_Protection_Level = LongWord; + {$EXTERNALSYM COPP_HDCP_Protection_Level} +const + COPP_HDCP_Level0 = 0; + {$EXTERNALSYM COPP_HDCP_Level0} + COPP_HDCP_LevelMin = COPP_HDCP_Level0; + {$EXTERNALSYM COPP_HDCP_LevelMin} + COPP_HDCP_Level1 = 1; + {$EXTERNALSYM COPP_HDCP_Level1} + COPP_HDCP_LevelMax = COPP_HDCP_Level1; + {$EXTERNALSYM COPP_HDCP_LevelMax} + COPP_HDCP_ForceDWORD = $7fffffff; + {$EXTERNALSYM COPP_HDCP_ForceDWORD} + +type + COPP_CGMSA_Protection_Level = LongWord; + {$EXTERNALSYM COPP_CGMSA_Protection_Level} +const + COPP_CGMSA_CopyFreely = 0; + {$EXTERNALSYM COPP_CGMSA_CopyFreely} + COPP_CGMSA_LevelMin = COPP_CGMSA_CopyFreely; + {$EXTERNALSYM COPP_CGMSA_LevelMin} + COPP_CGMSA_CopyOneGeneration = 2; + {$EXTERNALSYM COPP_CGMSA_CopyOneGeneration} + COPP_CGMSA_CopyNever = 3; + {$EXTERNALSYM COPP_CGMSA_CopyNever} + COPP_CGMSA_RedistributionControlRequired = $04; + {$EXTERNALSYM COPP_CGMSA_RedistributionControlRequired} + COPP_CGMSA_LevelMax = (COPP_CGMSA_RedistributionControlRequired + COPP_CGMSA_CopyNever); + {$EXTERNALSYM COPP_CGMSA_LevelMax} + COPP_CGMSA_ForceDWORD = $7fffffff; + {$EXTERNALSYM COPP_CGMSA_ForceDWORD} + + COPP_WSS_FLAG = $01; // used with DXVA_COPPSetProtectionLevelCmdData::TypeSpecificInfo + {$EXTERNALSYM COPP_WSS_FLAG} + +type + COPP_ACP_Protection_Level = LongWord; + {$EXTERNALSYM COPP_ACP_Protection_Level} +const + COPP_ACP_Level0 = 0; + {$EXTERNALSYM COPP_ACP_Level0} + COPP_ACP_LevelMin = COPP_ACP_Level0; + {$EXTERNALSYM COPP_ACP_LevelMin} + COPP_ACP_Level1 = 1; + {$EXTERNALSYM COPP_ACP_Level1} + COPP_ACP_Level2 = 2; + {$EXTERNALSYM COPP_ACP_Level2} + COPP_ACP_Level3 = 3; + {$EXTERNALSYM COPP_ACP_Level3} + COPP_ACP_LevelMax = COPP_ACP_Level3; + {$EXTERNALSYM COPP_ACP_LevelMax} + COPP_ACP_ForceDWORD = $7fffffff; + {$EXTERNALSYM COPP_ACP_ForceDWORD} + + COPP_NoProtectionLevelAvailable = -1; + {$EXTERNALSYM COPP_NoProtectionLevelAvailable} + COPP_DefaultProtectionLevel = 0; + {$EXTERNALSYM COPP_DefaultProtectionLevel} + + +// +// Bit flags of possible protection types. Note that it is possible to apply +// different protection settings to a single connector. +// + COPP_ProtectionType_Unknown = $80000000; + {$EXTERNALSYM COPP_ProtectionType_Unknown} + COPP_ProtectionType_None = $00000000; + {$EXTERNALSYM COPP_ProtectionType_None} + COPP_ProtectionType_HDCP = $00000001; + {$EXTERNALSYM COPP_ProtectionType_HDCP} + COPP_ProtectionType_ACP = $00000002; + {$EXTERNALSYM COPP_ProtectionType_ACP} + COPP_ProtectionType_CGMSA = $00000004; + {$EXTERNALSYM COPP_ProtectionType_CGMSA} + COPP_ProtectionType_Mask = $80000007; + {$EXTERNALSYM COPP_ProtectionType_Mask} + COPP_ProtectionType_Reserved = $7FFFFFF8; + {$EXTERNALSYM COPP_ProtectionType_Reserved} + +// ------------------------------------------------------------------------- +// COPPQueryStatus +// ------------------------------------------------------------------------- +type + PDXVACOPPStatusInput = ^TDXVACOPPStatusInput; + DXVA_COPPStatusInput = packed record + rApp : TGUID; // 16 bytes + guidStatusRequestID : TGUID; // 16 bytes + dwSequence : ULONG; // 4 bytes + cbSizeData : ULONG; // 4 bytes + StatusData: array[0..4055] of char; // 4056 bytes (4056+4+4+16+16 = 4096) + end; + {$EXTERNALSYM DXVA_COPPStatusInput} + LPDXVA_COPPStatusInput = ^DXVA_COPPStatusInput; + {$EXTERNALSYM LPDXVA_COPPStatusInput} + TDXVACOPPStatusInput = DXVA_COPPStatusInput; + + PDXVACOPPStatusOutput = ^TDXVACOPPStatusOutput; + DXVA_COPPStatusOutput = packed record + macKDI : TGUID; // 16 bytes + cbSizeData : ULONG; // 4 bytes + COPPStatus : array[0..4075] of Char; // 4076 bytes (4076+16+4 = 4096) + end; + {$EXTERNALSYM DXVA_COPPStatusOutput} + LPDXVA_COPPStatusOutput = ^DXVA_COPPStatusOutput; + {$EXTERNALSYM LPDXVA_COPPStatusOutput} + TDXVACOPPStatusOutput = DXVA_COPPStatusOutput; + +type + COPP_StatusFlags = ( + COPP_StatusNormal, + COPP_LinkLost, + COPP_RenegotiationRequired + ); + {$EXTERNALSYM COPP_StatusFlags} + TCOPPStatusFlags = COPP_StatusFlags; + +const + COPP_StatusFlagsReserved = $FFFFFFFC; + {$EXTERNALSYM COPP_StatusFlagsReserved} + +type + PDXVACOPPStatusData = ^TDXVACOPPStatusData; + DXVA_COPPStatusData = packed record + rApp : TGUID; + dwFlags : ULONG; // See COPP_StatusFlags above + dwData : ULONG; + TypeSpecificMask : ULONG; + TypeSpecificInfo : ULONG; + end; + {$EXTERNALSYM DXVA_COPPStatusData} + TDXVACOPPStatusData = DXVA_COPPStatusData; + + DXVA_COPPStatusDisplayData = packed record + rApp: TGUID; + dwFlags: ULONG; // See COPP_StatusFlags above + DisplayWidth: ULONG; + Displayheight: ULONG; + Format: ULONG; // also contains extended color data + d3dFormat: ULONG; + FreqNumerator: ULONG; + FreqDenominator: ULONG; + end; + {$EXTERNALSYM DXVA_COPPStatusDisplayData} + + COPP_StatusHDCPFlags = ( + COPP_HDCPReceiver, + COPP_HDCPRepeater + ); + {$EXTERNALSYM COPP_StatusHDCPFlags} + TCOPPStatusHDCPFlags = COPP_StatusHDCPFlags; + + PDXVACOPPStatusHDCPKeyData = ^TDXVACOPPStatusHDCPKeyData; + DXVA_COPPStatusHDCPKeyData = packed record + rApp: TGUID; + dwFlags: ULONG; // See COPP_StatusFlags above + dwHDCPFlags: ULONG; // See COPP_StatusHDCPFlags above + BKey: TGUID; // Lower 40 bits + reserved1: TGUID; + reserved2: TGUID; + end; + {$EXTERNALSYM DXVA_COPPStatusHDCPKeyData} + TDXVACOPPStatusHDCPKeyData = DXVA_COPPStatusHDCPKeyData; + +const + DXVA_COPPQueryStatusFnCode = $05; + {$EXTERNALSYM DXVA_COPPQueryStatusFnCode} +// lpInputData => DXVA_COPPStatusInput* +// lpOuputData => DXVA_COPPStatusOutput* + + +// +// Status GUID and enumerations +// + DXVA_COPPQueryConnectorType: TGUID = '{81d0bfd5-6afe-48c2-99c0-95a08f97c5da}'; + {$EXTERNALSYM DXVA_COPPQueryConnectorType} + +const + COPP_ConnectorType_Unknown = -1; + {$EXTERNALSYM COPP_ConnectorType_Unknown} + COPP_ConnectorType_Internal = $80000000; // can be combined with the other connector types + {$EXTERNALSYM COPP_ConnectorType_Internal} +type + COPP_ConnectorType = ( + COPP_ConnectorType_VGA, + COPP_ConnectorType_SVideo, + COPP_ConnectorType_CompositeVideo, + COPP_ConnectorType_ComponentVideo, + COPP_ConnectorType_DVI, + COPP_ConnectorType_HDMI, + COPP_ConnectorType_LVDS, + COPP_ConnectorType_TMDS, + COPP_ConnectorType_D_JPN + //COPP_ConnectorType_ForceDWORD = $7fffffff; (* force 32-bit size enum *) + ); + {$EXTERNALSYM COPP_ConnectorType} + TCOPPConnectorType = COPP_ConnectorType; + +const + DXVA_COPPQueryProtectionType : TGUID = '{38f2a801-9a6c-48bb-9107-b6696e6f1797}'; + {$EXTERNALSYM DXVA_COPPQueryProtectionType} + DXVA_COPPQueryLocalProtectionLevel : TGUID = '{b2075857-3eda-4d5d-88db-748f8c1a0549}'; + {$EXTERNALSYM DXVA_COPPQueryLocalProtectionLevel} + DXVA_COPPQueryGlobalProtectionLevel : TGUID = '{1957210a-7766-452a-b99a-d27aed54f03a}'; + {$EXTERNALSYM DXVA_COPPQueryGlobalProtectionLevel} + DXVA_COPPQueryDisplayData : TGUID = '{d7bf1ba3-ad13-4f8e-af98-0dcb3ca204cc}'; + {$EXTERNALSYM DXVA_COPPQueryDisplayData} + DXVA_COPPQueryHDCPKeyData : TGUID = '{0db59d74-a992-492e-a0bd-c23fda564e00}'; + {$EXTERNALSYM DXVA_COPPQueryHDCPKeyData} + DXVA_COPPQueryBusData : TGUID = '{c6f4d673-6174-4184-8e35-f6db5200bcba}'; + {$EXTERNALSYM DXVA_COPPQueryBusData} + + COPP_BusType_Integrated = $80000000; // can be combined with the other bus types + {$EXTERNALSYM COPP_BusType_Integrated} + +type + COPP_BusType = ( + COPP_BusType_Unknown, + COPP_BusType_PCI, + COPP_BusType_PCIX, + COPP_BusType_PCIExpress, + COPP_BusType_AGP + //COPP_BusType_ForceDWORD = 0x7fffffff /* force 32-bit size enum */ + ); + {$EXTERNALSYM COPP_BusType} + TCOPPBusType = COPP_BusType; + +//------------------------------------------------------------------------------ +// File: AMVA.h +// Desc: DirectShowMotionComp include file. +// Copyright (c) 1997 - 2000, Microsoft Corporation. All rights reserved. +//------------------------------------------------------------------------------ + +const + AMVA_TYPEINDEX_OUTPUTFRAME = $FFFFFFFF; + {$EXTERNALSYM AMVA_TYPEINDEX_OUTPUTFRAME} + + // Flags for QueryRenderStatus + AMVA_QUERYRENDERSTATUSF_READ = $00000001; // Query for read + {$EXTERNALSYM AMVA_QUERYRENDERSTATUSF_READ} + // set this bit to 0 + // if query for update +type + PAMVAUncompBufferInfo = ^TAMVAUncompBufferInfo; + _tag_AMVAUncompBufferInfo = record + dwMinNumSurfaces : DWORD ; // IN min number of surfaces to be allocated + dwMaxNumSurfaces : DWORD ; // IN max number of surfaces to be allocated + ddUncompPixelFormat : TDDPixelFormat ; // IN pixel format of surfaces to be allocated + end; + {$EXTERNALSYM _tag_AMVAUncompBufferInfo} + AMVAUncompBufferInfo = _tag_AMVAUncompBufferInfo; + {$EXTERNALSYM AMVAUncompBufferInfo} + LPAMVAUncompBufferInfo = ^AMVAUncompBufferInfo; + {$EXTERNALSYM LPAMVAUncompBufferInfo} + TAMVAUncompBufferInfo = _tag_AMVAUncompBufferInfo; + + PAMVAUncompDataInfo = ^TAMVAUncompDataInfo; + _tag_AMVAUncompDataInfo = record + dwUncompWidth : DWORD ; // [in] width of uncompressed data + dwUncompHeight : DWORD ; // [in] height of uncompressed data + ddUncompPixelFormat : TDDPixelFormat ; // [in] pixel-format of uncompressed data + end; + {$EXTERNALSYM _tag_AMVAUncompDataInfo} + AMVAUncompDataInfo = _tag_AMVAUncompDataInfo; + {$EXTERNALSYM AMVAUncompDataInfo} + LPAMVAUncompDataInfo = ^AMVAUncompDataInfo; + {$EXTERNALSYM LPAMVAUncompDataInfo} + TAMVAUncompDataInfo = _tag_AMVAUncompDataInfo; + + PAMVAInternalMemInfo = ^TAMVAInternalMemInfo; + _tag_AMVAInternalMemInfo = record + dwScratchMemAlloc : DWORD ; // [out] amount of scratch memory will the hal allocate for its private use + end; + {$EXTERNALSYM _tag_AMVAInternalMemInfo} + AMVAInternalMemInfo = _tag_AMVAInternalMemInfo; + {$EXTERNALSYM AMVAInternalMemInfo} + LPAMVAInternalMemInfo = ^AMVAInternalMemInfo; + {$EXTERNALSYM LPAMVAInternalMemInfo} + TAMVAInternalMemInfo = _tag_AMVAInternalMemInfo; + + PAMVACompBufferInfo = ^TAMVACompBufferInfo; + _tag_AMVACompBufferInfo = record + dwNumCompBuffers : DWORD ; // [out] number of buffers reqd for compressed data + dwWidthToCreate : DWORD ; // [out] Width of surface to create + dwHeightToCreate : DWORD ; // [out] Height of surface to create + dwBytesToAllocate : DWORD ; // [out] Total number of bytes used by each surface + ddCompCaps : TDDSCAPS2 ; // [out] caps to create surfaces to store compressed data + ddPixelFormat : TDDPixelFormat; // [out] fourcc to create surfaces to store compressed data + end; + {$EXTERNALSYM _tag_AMVACompBufferInfo} + AMVACompBufferInfo = _tag_AMVACompBufferInfo; + {$EXTERNALSYM AMVACompBufferInfo} + LPAMVACompBufferInfo = ^AMVACompBufferInfo; + {$EXTERNALSYM LPAMVACompBufferInfo} + TAMVACompBufferInfo = _tag_AMVACompBufferInfo; + +// Note that you are NOT allowed to store any pointer in pMiscData + PAMVABeginFrameInfo = ^TAMVABeginFrameInfo; + _tag_AMVABeginFrameInfo = record + dwDestSurfaceIndex : DWORD ; // IN destination buffer in which to decoding this frame + pInputData : pointer ; // IN pointer to misc data + dwSizeInputData : DWORD ; // IN size of other misc data to begin frame + pOutputData : pointer ; // OUT pointer to data which the VGA is going to fill + dwSizeOutputData : DWORD ; // IN size of data which the VGA is going to fill + end; + {$EXTERNALSYM _tag_AMVABeginFrameInfo} + AMVABeginFrameInfo = _tag_AMVABeginFrameInfo; + {$EXTERNALSYM AMVABeginFrameInfo} + LPAMVABeginFrameInfo = ^AMVABeginFrameInfo; + {$EXTERNALSYM LPAMVABeginFrameInfo} + TAMVABeginFrameInfo = _tag_AMVABeginFrameInfo; + +// Note that you are NOT allowed to store any pointer in pMiscData + PAMVAEndFrameInfo = ^TAMVAEndFrameInfo; + _tag_AMVAEndFrameInfo = record + dwSizeMiscData : DWORD ; // [in] size of other misc data to begin frame + pMiscData : pointer; // [in] pointer to misc data + end; + {$EXTERNALSYM _tag_AMVAEndFrameInfo} + AMVAEndFrameInfo = _tag_AMVAEndFrameInfo; + {$EXTERNALSYM AMVAEndFrameInfo} + LPAMVAEndFrameInfo = ^AMVAEndFrameInfo; + {$EXTERNALSYM LPAMVAEndFrameInfo} + TAMVAEndFrameInfo = _tag_AMVAEndFrameInfo; + + PAMVABufferInfo = ^TAMVABufferInfo; + _tag_AMVABUFFERINFO = record + dwTypeIndex : DWORD; // [in] Type of buffer + dwBufferIndex : DWORD; // [in] Buffer index + dwDataOffset : DWORD; // [in] offset of relevant data from the beginning of buffer + dwDataSize : DWORD; // [in] size of relevant data + end; + {$EXTERNALSYM _tag_AMVABUFFERINFO} + AMVABUFFERINFO = _tag_AMVABUFFERINFO; + {$EXTERNALSYM AMVABUFFERINFO} + LPAMVABUFFERINFO = ^AMVABUFFERINFO; + {$EXTERNALSYM LPAMVABUFFERINFO} + TAMVABufferInfo = _tag_AMVABUFFERINFO; + +//------------------------------------------------------------------------------ +// File: videoacc.h +// Desc: DirectX Video Acceleration interfaces +// Copyright (c) 1999 - 2000, Microsoft Corporation. All rights reserved. +//------------------------------------------------------------------------------ + +const + IID_IAMVideoAcceleratorNotify : TGUID = '{256A6A21-FBAD-11d1-82BF-00A0C9696C8F}'; + {$EXTERNALSYM IID_IAMVideoAcceleratorNotify} + IID_IAMVideoAccelerator : TGUID = '{256A6A22-FBAD-11d1-82BF-00A0C9696C8F}'; + {$EXTERNALSYM IID_IAMVideoAccelerator} + +type + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMVideoAcceleratorNotify;'} + {$EXTERNALSYM IAMVideoAcceleratorNotify} + IAMVideoAcceleratorNotify = interface(IUnknown) + ['{256A6A21-FBAD-11d1-82BF-00A0C9696C8F}'] + (*** IAMVideoAcceleratorNotify methods ***) + function GetUncompSurfacesInfo(const pGuid: TGUID; var pUncompBufferInfo: PAMVAUncompBufferInfo): HResult; stdcall; + function SetUncompSurfacesInfo(dwActualUncompSurfacesAllocated: DWORD): HResult; stdcall; + function GetCreateVideoAcceleratorData(const pGuid: TGUID; out pdwSizeMiscData: PDWORD; out ppMiscData: pointer): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMVideoAccelerator;'} + {$EXTERNALSYM IAMVideoAccelerator} + IAMVideoAccelerator = interface(IUnknown) + ['{256A6A22-FBAD-11d1-82BF-00A0C9696C8F}'] + (*** IAMVideoAccelerator methods ***) + function GetVideoAcceleratorGUIDs(var pdwNumGuidsSupported: PDWORD; var pGuidsSupported: PGUID): HResult; stdcall; + function GetUncompFormatsSupported(const pGuid: TGUID; var pdwNumFormatsSupported: PDWORD; + var pFormatsSupported: PDDPixelFormat): HResult; stdcall; + function GetInternalMemInfo(const pGuid: TGUID; const pamvaUncompDataInfo: TAMVAUncompDataInfo; + var pamvaInternalMemInfo: PAMVAInternalMemInfo): HResult; stdcall; + function GetCompBufferInfo(const pGuid: TGUID; const pamvaUncompDataInfo: TAMVAUncompDataInfo ; + var pdwNumTypesCompBuffers: PDWORD; out pamvaCompBufferInfo: PAMVACompBufferInfo): HResult; stdcall; + function GetInternalCompBufferInfo(var pdwNumTypesCompBuffers: PDWORD; out pamvaCompBufferInfo: PAMVACompBufferInfo): HResult; stdcall; + function BeginFrame(const amvaBeginFrameInfo: TAMVABeginFrameInfo): HResult; stdcall; + function EndFrame(const pEndFrameInfo: TAMVAEndFrameInfo): HResult; stdcall; + function GetBuffer(dwTypeIndex, dwBufferIndex: DWORD; bReadOnly: BOOL; out ppBuffer; out lpStride: LONGINT): HResult; stdcall; + function ReleaseBuffer(dwTypeIndex, dwBufferIndex: DWORD): HResult; stdcall; + function Execute(dwFunction: DWORD; lpPrivateInputData : pointer; cbPrivateInputData: DWORD; + lpPrivateOutputDat: pointer; cbPrivateOutputData, dwNumBuffers: DWORD; + const pamvaBufferInfo: TAMVABUFFERINFO): HResult; stdcall; + function QueryRenderStatus(dwTypeIndex, dwBufferIndex, dwFlags: DWORD): HResult; stdcall; + function DisplayFrame(dwFlipToIndex: DWORD; pMediaSample: IMediaSample): HResult; stdcall; + end; + +//------------------------------------------------------------------------------ +// File: BDATypes.h +// +// Desc: Typedefs and enums needed by both the WDM drivers and the user mode +// COM interfaces. +// +// Copyright (c) 1999 - 2000, Microsoft Corporation. All rights reserved. +//------------------------------------------------------------------------------ + +// Utility Macros +const + MIN_DIMENSION = 1; + {$EXTERNALSYM MIN_DIMENSION} + NATURAL = 4; + {$EXTERNALSYM NATURAL} + CACHE_LINE = 128; + {$EXTERNALSYM CACHE_LINE} + PAGE = 4096; + {$EXTERNALSYM PAGE} + //#define ALIGN( pointer, size) (((ULONG)(pointer) + (ULONG)(size) - 1) & ~((ULONG)(size) - 1)) + //#define BDA_STRING_CONST(x) {sizeof(L##x)-2, sizeof(L##x), L##x} + +//=========================================================================== +// +// BDA Topology Structures +// +//=========================================================================== +type + PBDATemplateConnection = ^TBDATemplateConnection; + _BDA_TEMPLATE_CONNECTION = record + FromNodeType : ULONG; + FromNodePinType : ULONG; + ToNodeType : ULONG; + ToNodePinType : ULONG; + end; + {$EXTERNALSYM _BDA_TEMPLATE_CONNECTION} + BDA_TEMPLATE_CONNECTION = _BDA_TEMPLATE_CONNECTION; + {$EXTERNALSYM BDA_TEMPLATE_CONNECTION} + PBDA_TEMPLATE_CONNECTION = ^BDA_TEMPLATE_CONNECTION; + {$EXTERNALSYM PBDA_TEMPLATE_CONNECTION} + TBDATemplateConnection = _BDA_TEMPLATE_CONNECTION; + + PBDATemplatePinJoint = ^TBDATemplatePinJoint; + _BDA_TEMPLATE_PIN_JOINT = record + uliTemplateConnection : ULONG; + ulcInstancesMax : ULONG; + end; + {$EXTERNALSYM _BDA_TEMPLATE_PIN_JOINT} + BDA_TEMPLATE_PIN_JOINT = _BDA_TEMPLATE_PIN_JOINT; + {$EXTERNALSYM BDA_TEMPLATE_PIN_JOINT} + PBDA_TEMPLATE_PIN_JOINT = ^BDA_TEMPLATE_PIN_JOINT; + {$EXTERNALSYM PBDA_TEMPLATE_PIN_JOINT} + TBDATemplatePinJoint = _BDA_TEMPLATE_PIN_JOINT; + +//=========================================================================== +// BDA Events +//=========================================================================== +// In-band Event IDs + PBDAEventID = ^TBDAEventID; + BDA_EVENT_ID = ( + BDA_EVENT_SIGNAL_LOSS, + BDA_EVENT_SIGNAL_LOCK, + BDA_EVENT_DATA_START, + BDA_EVENT_DATA_STOP, + BDA_EVENT_CHANNEL_ACQUIRED, + BDA_EVENT_CHANNEL_LOST, + BDA_EVENT_CHANNEL_SOURCE_CHANGED, + BDA_EVENT_CHANNEL_ACTIVATED, + BDA_EVENT_CHANNEL_DEACTIVATED, + BDA_EVENT_SUBCHANNEL_ACQUIRED, + BDA_EVENT_SUBCHANNEL_LOST, + BDA_EVENT_SUBCHANNEL_SOURCE_CHANGED, + BDA_EVENT_SUBCHANNEL_ACTIVATED, + BDA_EVENT_SUBCHANNEL_DEACTIVATED, + BDA_EVENT_ACCESS_GRANTED, + BDA_EVENT_ACCESS_DENIED, + BDA_EVENT_OFFER_EXTENDED, + BDA_EVENT_PURCHASE_COMPLETED, + BDA_EVENT_SMART_CARD_INSERTED, + BDA_EVENT_SMART_CARD_REMOVED + ); + {$EXTERNALSYM BDA_EVENT_ID} + PBDA_EVENT_ID = ^BDA_EVENT_ID; + {$EXTERNALSYM PBDA_EVENT_ID} + TBDAEventID = BDA_EVENT_ID; + +//=========================================================================== +// +// KSSTREAM_HEADER extensions for BDA +// +//=========================================================================== + + PKSBDAFrameInfo = ^TKSBDAFrameInfo; + tagKS_BDA_FRAME_INFO = record + ExtendedHeaderSize : ULONG; // Size of this extended header + dwFrameFlags : DWORD; + ulEvent : ULONG; + ulChannelNumber : ULONG; + ulSubchannelNumber : ULONG; + ulReason : ULONG; + end; + {$EXTERNALSYM tagKS_BDA_FRAME_INFO} + KS_BDA_FRAME_INFO = tagKS_BDA_FRAME_INFO; + {$EXTERNALSYM KS_BDA_FRAME_INFO} + PKS_BDA_FRAME_INFO = ^KS_BDA_FRAME_INFO; + {$EXTERNALSYM PKS_BDA_FRAME_INFO} + TKSBDAFrameInfo = tagKS_BDA_FRAME_INFO; + +//------------------------------------------------------------ +// BDA Network Ethernet Filter Property Set +// {71985F43-1CA1-11d3-9CC8-00C04F7971E0} + + PBDAEthernetAddress = ^TBDAEthernetAddress; + _BDA_ETHERNET_ADDRESS = record + rgbAddress : array[0..5] of BYTE; + end; + {$EXTERNALSYM _BDA_ETHERNET_ADDRESS} + BDA_ETHERNET_ADDRESS = _BDA_ETHERNET_ADDRESS; + {$EXTERNALSYM BDA_ETHERNET_ADDRESS} + PBDA_ETHERNET_ADDRESS = ^BDA_ETHERNET_ADDRESS; + {$EXTERNALSYM PBDA_ETHERNET_ADDRESS} + TBDAEthernetAddress = _BDA_ETHERNET_ADDRESS; + + PBDAEthernetAddressList = ^TBDAEthernetAddressList; + _BDA_ETHERNET_ADDRESS_LIST = record + ulcAddresses : ULONG; + rgAddressl : array[0..MIN_DIMENSION-1] of TBDAEthernetAddress; + end; + {$EXTERNALSYM _BDA_ETHERNET_ADDRESS_LIST} + BDA_ETHERNET_ADDRESS_LIST = _BDA_ETHERNET_ADDRESS_LIST; + {$EXTERNALSYM BDA_ETHERNET_ADDRESS_LIST} + PBDA_ETHERNET_ADDRESS_LIST = ^BDA_ETHERNET_ADDRESS_LIST; + {$EXTERNALSYM PBDA_ETHERNET_ADDRESS_LIST} + TBDAEthernetAddressList = _BDA_ETHERNET_ADDRESS_LIST; + + PBDAMulticastMode = ^TBDAMulticastMode; + BDA_MULTICAST_MODE = ( + BDA_PROMISCUOUS_MULTICAST, + BDA_FILTERED_MULTICAST, + BDA_NO_MULTICAST + ); + {$EXTERNALSYM BDA_MULTICAST_MODE} + PBDA_MULTICAST_MODE = ^BDA_MULTICAST_MODE; + {$EXTERNALSYM PBDA_MULTICAST_MODE} + TBDAMulticastMode = BDA_MULTICAST_MODE; + +//------------------------------------------------------------ +// BDA Network IPv4 Filter Property Set +// {71985F44-1CA1-11d3-9CC8-00C04F7971E0} + + PBDAIPv4Address = ^TBDAIPv4Address; + _BDA_IPv4_ADDRESS = record + rgbAddress : array[0..3] of BYTE; + end; + {$EXTERNALSYM _BDA_IPv4_ADDRESS} + BDA_IPv4_ADDRESS = _BDA_IPv4_ADDRESS; + {$EXTERNALSYM BDA_IPv4_ADDRESS} + PBDA_IPv4_ADDRESS = ^BDA_IPv4_ADDRESS; + {$EXTERNALSYM PBDA_IPv4_ADDRESS} + TBDAIPv4Address = _BDA_IPv4_ADDRESS; + + PBDAIPv4AddressList = ^TBDAIPv4AddressList; + _BDA_IPv4_ADDRESS_LIST = record + ulcAddresses : ULONG; + rgAddressl : array[0..MIN_DIMENSION-1] of TBDAIPv4Address; + end; + {$EXTERNALSYM _BDA_IPv4_ADDRESS_LIST} + BDA_IPv4_ADDRESS_LIST = _BDA_IPv4_ADDRESS_LIST; + {$EXTERNALSYM BDA_IPv4_ADDRESS_LIST} + PBDA_IPv4_ADDRESS_LIST = ^BDA_IPv4_ADDRESS_LIST; + {$EXTERNALSYM PBDA_IPv4_ADDRESS_LIST} + TBDAIPv4AddressList = _BDA_IPv4_ADDRESS_LIST; + +//------------------------------------------------------------ +// BDA Network IPv4 Filter Property Set +// {E1785A74-2A23-4fb3-9245-A8F88017EF33} + + PBDAIPv6Address = ^TBDAIPv6Address; + _BDA_IPv6_ADDRESS = record + rgbAddress : array[0..5] of BYTE; + end; + {$EXTERNALSYM _BDA_IPv6_ADDRESS} + BDA_IPv6_ADDRESS = _BDA_IPv6_ADDRESS; + {$EXTERNALSYM BDA_IPv6_ADDRESS} + PBDA_IPv6_ADDRESS = ^BDA_IPv6_ADDRESS; + {$EXTERNALSYM PBDA_IPv6_ADDRESS} + TBDAIPv6Address = _BDA_IPv6_ADDRESS; + + PBDAIPv6AddressList = ^TBDAIPv6AddressList; + _BDA_IPv6_ADDRESS_LIST = record + ulcAddresses : ULONG; + rgAddressl : array [0..MIN_DIMENSION-1] of TBDAIPv6Address; + end; + {$EXTERNALSYM _BDA_IPv6_ADDRESS_LIST} + BDA_IPv6_ADDRESS_LIST = _BDA_IPv6_ADDRESS_LIST; + {$EXTERNALSYM BDA_IPv6_ADDRESS_LIST} + PBDA_IPv6_ADDRESS_LIST = ^BDA_IPv6_ADDRESS_LIST; + {$EXTERNALSYM PBDA_IPv6_ADDRESS_LIST} + TBDAIPv6AddressList = _BDA_IPv6_ADDRESS_LIST; + +//------------------------------------------------------------ +// BDA Signal Property Set +// {D2F1644B-B409-11d2-BC69-00A0C9EE9E16} + + PBDASignalState = ^TBDASignalState; + BDA_SIGNAL_STATE = ( + BDA_SIGNAL_UNAVAILABLE, + BDA_SIGNAL_INACTIVE, + BDA_SIGNAL_ACTIVE + ); + {$EXTERNALSYM BDA_SIGNAL_STATE} + PBDA_SIGNAL_STATE = ^BDA_SIGNAL_STATE; + {$EXTERNALSYM PBDA_SIGNAL_STATE} + TBDASignalState = BDA_SIGNAL_STATE; + +//------------------------------------------------------------ +// BDA Change Sync Method Set +// {FD0A5AF3-B41D-11d2-9C95-00C04F7971E0} + + PBDAChangeState = ^TBDAChangeState; + BDA_CHANGE_STATE = ( + BDA_CHANGES_COMPLETE, + BDA_CHANGES_PENDING + ); + {$EXTERNALSYM BDA_CHANGE_STATE} + PBDA_CHANGE_STATE = ^BDA_CHANGE_STATE; + TBDAChangeState = BDA_CHANGE_STATE; + +//------------------------------------------------------------ +// BDA Device Configuration Method Set +// {71985F45-1CA1-11d3-9CC8-00C04F7971E0} + +//------------------------------------------------------------ +// BDA Topology Property Set +// {A14EE835-0A23-11d3-9CC7-00C04F7971E0} + PBDANodeDescriptor = ^TBDANodeDescriptor; + _BDANODE_DESCRIPTOR = record + ulBdaNodeType : ULONG; // The node type as it is used + // in the BDA template topology + guidFunction : TGUID; // GUID from BdaMedia.h describing + // the node's function (e.g. + // KSNODE_BDA_RF_TUNER) + guidName : TGUID; // GUID that can be use to look up + // a displayable name for the node. + end; + {$EXTERNALSYM _BDANODE_DESCRIPTOR} + BDANODE_DESCRIPTOR = _BDANODE_DESCRIPTOR; + {$EXTERNALSYM BDANODE_DESCRIPTOR} + PBDANODE_DESCRIPTOR = ^BDANODE_DESCRIPTOR; + {$EXTERNALSYM PBDANODE_DESCRIPTOR} + TBDANodeDescriptor = _BDANODE_DESCRIPTOR; + +//------------------------------------------------------------ +// BDA Void Transform Property Set +// {71985F46-1CA1-11d3-9CC8-00C04F7971E0} + +//------------------------------------------------------------ +// BDA Null Transform Property Set +// {DDF15B0D-BD25-11d2-9CA0-00C04F7971E0} + +//------------------------------------------------------------ +// BDA Frequency Filter Property Set +// {71985F47-1CA1-11d3-9CC8-00C04F7971E0} + +//------------------------------------------------------------ +// BDA Autodemodulate Property Set +// {DDF15B12-BD25-11d2-9CA0-00C04F7971E0} + +//------------------------------------------------------------ +// BDA Table Section Property Set +// {516B99C5-971C-4aaf-B3F3-D9FDA8A15E16} + + PBDATableSection = ^TBDATableSection; + _BDA_TABLE_SECTION = record + ulPrimarySectionId : ULONG; + ulSecondarySectionId : ULONG; + ulcbSectionLength : ULONG; + argbSectionData : array[0..MIN_DIMENSION-1] of ULONG; + end; + {$EXTERNALSYM _BDA_TABLE_SECTION} + BDA_TABLE_SECTION = _BDA_TABLE_SECTION; + {$EXTERNALSYM BDA_TABLE_SECTION} + PBDA_TABLE_SECTION = ^BDA_TABLE_SECTION; + {$EXTERNALSYM PBDA_TABLE_SECTION} + TBDATableSection = _BDA_TABLE_SECTION; + +//------------------------------------------------------------ +// BDA PID Filter Property Set +// {D0A67D65-08DF-4fec-8533-E5B550410B85} + +//--------------------------------------------------------------------- +// From IEnumPIDMap interface +//--------------------------------------------------------------------- + + MEDIA_SAMPLE_CONTENT = ( + MEDIA_TRANSPORT_PACKET, // complete TS packet e.g. pass-through mode + MEDIA_ELEMENTARY_STREAM, // PES payloads; audio/video only + MEDIA_MPEG2_PSI, // PAT, PMT, CAT, Private + MEDIA_TRANSPORT_PAYLOAD // gathered TS packet payloads (PES packets, etc...) + ); + {$EXTERNALSYM MEDIA_SAMPLE_CONTENT} + TMediaSampleContent = MEDIA_SAMPLE_CONTENT; + + PID_MAP = record + ulPID : ULONG; + MediaSampleContent : TMediaSampleContent; + end; + {$EXTERNALSYM PID_MAP} + TPIDMap = PID_MAP; + + + PBDAPIDMap = ^TBDAPIDMap; + _BDA_PID_MAP = record + MediaSampleContent : TMediaSampleContent; + ulcPIDs : ULONG; + aulPIDs : array[0..MIN_DIMENSION-1] of ULONG; + end; + {$EXTERNALSYM _BDA_PID_MAP} + BDA_PID_MAP = _BDA_PID_MAP; + {$EXTERNALSYM BDA_PID_MAP} + PBDA_PID_MAP = ^BDA_PID_MAP; + TBDAPIDMap = _BDA_PID_MAP; + + PBDAPIDUnmap = ^TBDAPIDUnmap; + _BDA_PID_UNMAP = record + ulcPIDs : ULONG; + aulPIDs : array[0..MIN_DIMENSION-1] of ULONG; + end; + {$EXTERNALSYM _BDA_PID_UNMAP} + BDA_PID_UNMAP = _BDA_PID_UNMAP; + {$EXTERNALSYM BDA_PID_UNMAP} + PBDA_PID_UNMAP = ^BDA_PID_UNMAP; + {$EXTERNALSYM PBDA_PID_UNMAP} + TBDAPIDUnmap = _BDA_PID_UNMAP; + +//------------------------------------------------------------ +// BDA CA Property Set +// {B0693766-5278-4ec6-B9E1-3CE40560EF5A} + + PBDACAModuleUI = ^TBDACAModuleUI; + _BDA_CA_MODULE_UI = record + ulFormat : ULONG; + ulbcDesc : ULONG; + ulDesc : array[0..MIN_DIMENSION-1] of ULONG; + end; + {$EXTERNALSYM _BDA_CA_MODULE_UI} + BDA_CA_MODULE_UI = _BDA_CA_MODULE_UI; + {$EXTERNALSYM BDA_CA_MODULE_UI} + PBDA_CA_MODULE_UI = ^BDA_CA_MODULE_UI; + {$EXTERNALSYM PBDA_CA_MODULE_UI} + TBDACAModuleUI = _BDA_CA_MODULE_UI; + + PBDAProgramPIDList = ^TBDAProgramPIDList; + _BDA_PROGRAM_PID_LIST = record + ulProgramNumber : ULONG; + ulcPIDs : ULONG; + ulPID : array[0..MIN_DIMENSION-1] of ULONG; + end; + {$EXTERNALSYM _BDA_PROGRAM_PID_LIST} + BDA_PROGRAM_PID_LIST = _BDA_PROGRAM_PID_LIST; + {$EXTERNALSYM BDA_PROGRAM_PID_LIST} + PBDA_PROGRAM_PID_LIST = ^BDA_PROGRAM_PID_LIST; + {$EXTERNALSYM PBDA_PROGRAM_PID_LIST} + TBDAProgramPIDList = _BDA_PROGRAM_PID_LIST; + +//------------------------------------------------------------ +// BDA CA Event Set +// {488C4CCC-B768-4129-8EB1-B00A071F9068} + +//============================================================= +// +// +// BDA Tuning Model enumerations +// +// +//============================================================= + +// system type for particular DVB Tuning Space instance + DVBSystemType = ( + DVB_Cable, + DVB_Terrestrial, + DVB_Satellite + ); + {$EXTERNALSYM DVBSystemType} + TDVBSystemType = DVBSystemType; + +//------------------------------------------------------------ +// BDA Channel Tune Request + +const + BDA_UNDEFINED_CHANNEL = -1; + {$EXTERNALSYM BDA_UNDEFINED_CHANNEL} + +//------------------------------------------------------------ +// BDA Component(substream) +type + ComponentCategory = {$IFDEF TYPE_IDENTITY}type {$ENDIF} LongWord; + {$EXTERNALSYM ComponentCategory} + const + CategoryNotSet = -1; + {$EXTERNALSYM CategoryNotSet} + CategoryOther = 0; + {$EXTERNALSYM CategoryOther} + CategoryVideo = 1; + {$EXTERNALSYM CategoryVideo} + CategoryAudio = 2; + {$EXTERNALSYM CategoryAudio} + CategoryText = 3; + {$EXTERNALSYM CategoryText} + CategoryData = 4; + {$EXTERNALSYM CategoryData} + +// Component Status +type + ComponentStatus = ( + StatusActive, + StatusInactive, + StatusUnavailable + ); + {$EXTERNALSYM ComponentStatus} + TComponentStatus = ComponentStatus; + +//------------------------------------------------------------ +// +// BDA MPEG2 Component Type +// +// from the MPEG2 specification + MPEG2StreamType = {$IFDEF TYPE_IDENTITY}type {$ENDIF} LongWord; + {$EXTERNALSYM MPEG2StreamType} + const + BDA_UNITIALIZED_MPEG2STREAMTYPE = -1; + {$EXTERNALSYM BDA_UNITIALIZED_MPEG2STREAMTYPE} + Reserved1 = $0; + {$NODEFINE Reserved1} + ISO_IEC_11172_2_VIDEO = Reserved1 + 1; + {$EXTERNALSYM ISO_IEC_11172_2_VIDEO} + ISO_IEC_13818_2_VIDEO = ISO_IEC_11172_2_VIDEO + 1; + {$EXTERNALSYM ISO_IEC_13818_2_VIDEO} + ISO_IEC_11172_3_AUDIO = ISO_IEC_13818_2_VIDEO + 1; + {$EXTERNALSYM ISO_IEC_11172_3_AUDIO} + ISO_IEC_13818_3_AUDIO = ISO_IEC_11172_3_AUDIO + 1; + {$EXTERNALSYM ISO_IEC_13818_3_AUDIO} + ISO_IEC_13818_1_PRIVATE_SECTION = ISO_IEC_13818_3_AUDIO + 1; + {$EXTERNALSYM ISO_IEC_13818_1_PRIVATE_SECTION} + ISO_IEC_13818_1_PES = ISO_IEC_13818_1_PRIVATE_SECTION + 1; + {$EXTERNALSYM ISO_IEC_13818_1_PES} + ISO_IEC_13522_MHEG = ISO_IEC_13818_1_PES + 1; + {$EXTERNALSYM ISO_IEC_13522_MHEG} + ANNEX_A_DSM_CC = ISO_IEC_13522_MHEG + 1; + {$EXTERNALSYM ANNEX_A_DSM_CC} + ITU_T_REC_H_222_1 = ANNEX_A_DSM_CC + 1; + {$EXTERNALSYM ITU_T_REC_H_222_1} + ISO_IEC_13818_6_TYPE_A = ITU_T_REC_H_222_1 + 1; + {$EXTERNALSYM ISO_IEC_13818_6_TYPE_A} + ISO_IEC_13818_6_TYPE_B = ISO_IEC_13818_6_TYPE_A + 1; + {$EXTERNALSYM ISO_IEC_13818_6_TYPE_B} + ISO_IEC_13818_6_TYPE_C = ISO_IEC_13818_6_TYPE_B + 1; + {$EXTERNALSYM ISO_IEC_13818_6_TYPE_C} + ISO_IEC_13818_6_TYPE_D = ISO_IEC_13818_6_TYPE_C + 1; + {$EXTERNALSYM ISO_IEC_13818_6_TYPE_D} + ISO_IEC_13818_1_AUXILIARY = ISO_IEC_13818_6_TYPE_D + 1; + {$EXTERNALSYM ISO_IEC_13818_1_AUXILIARY} + ISO_IEC_13818_1_RESERVED = ISO_IEC_13818_1_AUXILIARY + 1; + {$EXTERNALSYM ISO_IEC_13818_1_RESERVED} + USER_PRIVATE = ISO_IEC_13818_1_RESERVED + 1; + {$EXTERNALSYM USER_PRIVATE} + +//------------------------------------------------------------ +// +// mpeg-2 transport stride format block; associated with media +// types MEDIATYPE_Stream/MEDIASUBTYPE_MPEG2_TRANSPORT_STRIDE; +// *all* format blocks associated with above media type *must* +// start with the MPEG2_TRANSPORT_STRIDE structure +// +type + PMPEG2TransportStride = ^TMPEG2TransportStride; + _MPEG2_TRANSPORT_STRIDE = record + dwOffset : DWORD; + dwPacketLength : DWORD; + dwStride : DWORD; + end; + {$EXTERNALSYM _MPEG2_TRANSPORT_STRIDE} + MPEG2_TRANSPORT_STRIDE = _MPEG2_TRANSPORT_STRIDE; + {$EXTERNALSYM MPEG2_TRANSPORT_STRIDE} + PMPEG2_TRANSPORT_STRIDE = ^MPEG2_TRANSPORT_STRIDE; + {$EXTERNALSYM PMPEG2_TRANSPORT_STRIDE} + TMPEG2TransportStride = _MPEG2_TRANSPORT_STRIDE; + +//------------------------------------------------------------ +// +// BDA ATSC Component Type +// +// +// ATSC made AC3 Audio a descriptor instead of +// defining a user private stream type. +//enum ATSCComponentTypeFlags { + // bit flags for various component type properties +const + ATSCCT_AC3 = $00000001; + {$EXTERNALSYM ATSCCT_AC3} + +//------------------------------------------------------------ +// BDA Locators + +type + BinaryConvolutionCodeRate = {$IFDEF TYPE_IDENTITY}type {$ENDIF} LongWord; + {$EXTERNALSYM BinaryConvolutionCodeRate} + const + BDA_BCC_RATE_NOT_SET = -1; + {$EXTERNALSYM BDA_BCC_RATE_NOT_SET} + BDA_BCC_RATE_NOT_DEFINED = 0; + {$EXTERNALSYM BDA_BCC_RATE_NOT_DEFINED} + BDA_BCC_RATE_1_2 = 1; // 1/2 + {$EXTERNALSYM BDA_BCC_RATE_1_2} + BDA_BCC_RATE_2_3 = 2; // 2/3 + {$EXTERNALSYM BDA_BCC_RATE_2_3} + BDA_BCC_RATE_3_4 = 3; // 3/4 + {$EXTERNALSYM BDA_BCC_RATE_3_4} + BDA_BCC_RATE_3_5 = 4; + {$EXTERNALSYM BDA_BCC_RATE_3_5} + BDA_BCC_RATE_4_5 = 5; + {$EXTERNALSYM BDA_BCC_RATE_4_5} + BDA_BCC_RATE_5_6 = 6; // 5/6 + {$EXTERNALSYM BDA_BCC_RATE_5_6} + BDA_BCC_RATE_5_11 = 7; + {$EXTERNALSYM BDA_BCC_RATE_5_11} + BDA_BCC_RATE_7_8 = 8; // 7/8 + {$EXTERNALSYM BDA_BCC_RATE_7_8} + BDA_BCC_RATE_MAX = 9; + {$EXTERNALSYM BDA_BCC_RATE_MAX} + +type + FECMethod = {$IFDEF TYPE_IDENTITY}type {$ENDIF} LongWord; + {$EXTERNALSYM FECMethod} + const + BDA_FEC_METHOD_NOT_SET = -1; + {$EXTERNALSYM BDA_FEC_METHOD_NOT_SET} + BDA_FEC_METHOD_NOT_DEFINED = 0; + {$EXTERNALSYM BDA_FEC_METHOD_NOT_DEFINED} + BDA_FEC_VITERBI = 1; // FEC is a Viterbi Binary Convolution. + {$EXTERNALSYM BDA_FEC_VITERBI} + BDA_FEC_RS_204_188 = 2; // The FEC is Reed-Solomon 204/188 (outer FEC) + {$EXTERNALSYM BDA_FEC_RS_204_188} + BDA_FEC_MAX = 3; + {$EXTERNALSYM BDA_FEC_MAX} + +type + ModulationType = {$IFDEF TYPE_IDENTITY}type {$ENDIF} LongWord; + {$EXTERNALSYM ModulationType} + const + BDA_MOD_NOT_SET = -1; + {$EXTERNALSYM BDA_MOD_NOT_SET} + BDA_MOD_NOT_DEFINED = 0; + {$EXTERNALSYM BDA_MOD_NOT_DEFINED} + BDA_MOD_16QAM = 1; + {$EXTERNALSYM BDA_MOD_16QAM} + BDA_MOD_32QAM = 2; + {$EXTERNALSYM BDA_MOD_32QAM} + BDA_MOD_64QAM = 3; + {$EXTERNALSYM BDA_MOD_64QAM} + BDA_MOD_80QAM = 4; + {$EXTERNALSYM BDA_MOD_80QAM} + BDA_MOD_96QAM = 5; + {$EXTERNALSYM BDA_MOD_96QAM} + BDA_MOD_112QAM = 6; + {$EXTERNALSYM BDA_MOD_112QAM} + BDA_MOD_128QAM = 7; + {$EXTERNALSYM BDA_MOD_128QAM} + BDA_MOD_160QAM = 8; + {$EXTERNALSYM BDA_MOD_160QAM} + BDA_MOD_192QAM = 9; + {$EXTERNALSYM BDA_MOD_192QAM} + BDA_MOD_224QAM = 10; + {$EXTERNALSYM BDA_MOD_224QAM} + BDA_MOD_256QAM = 11; + {$EXTERNALSYM BDA_MOD_256QAM} + BDA_MOD_320QAM = 12; + {$EXTERNALSYM BDA_MOD_320QAM} + BDA_MOD_384QAM = 13; + {$EXTERNALSYM BDA_MOD_384QAM} + BDA_MOD_448QAM = 14; + {$EXTERNALSYM BDA_MOD_448QAM} + BDA_MOD_512QAM = 15; + {$EXTERNALSYM BDA_MOD_512QAM} + BDA_MOD_640QAM = 16; + {$EXTERNALSYM BDA_MOD_640QAM} + BDA_MOD_768QAM = 17; + {$EXTERNALSYM BDA_MOD_768QAM} + BDA_MOD_896QAM = 18; + {$EXTERNALSYM BDA_MOD_896QAM} + BDA_MOD_1024QAM = 19; + {$EXTERNALSYM BDA_MOD_1024QAM} + BDA_MOD_QPSK = 20; + {$EXTERNALSYM BDA_MOD_QPSK} + BDA_MOD_BPSK = 21; + {$EXTERNALSYM BDA_MOD_BPSK} + BDA_MOD_OQPSK = 22; + {$EXTERNALSYM BDA_MOD_OQPSK} + BDA_MOD_8VSB = 23; + {$EXTERNALSYM BDA_MOD_8VSB} + BDA_MOD_16VSB = 24; + {$EXTERNALSYM BDA_MOD_16VSB} + BDA_MOD_ANALOG_AMPLITUDE = 25; // std am + {$EXTERNALSYM BDA_MOD_ANALOG_AMPLITUDE} + BDA_MOD_ANALOG_FREQUENCY = 26; // std fm + {$EXTERNALSYM BDA_MOD_ANALOG_FREQUENCY} + BDA_MOD_MAX = 27; + {$EXTERNALSYM BDA_MOD_MAX} + +Type + SpectralInversion = {$IFDEF TYPE_IDENTITY}type {$ENDIF} LongWord; + {$EXTERNALSYM SpectralInversion} + const + BDA_SPECTRAL_INVERSION_NOT_SET = -1; + {$EXTERNALSYM BDA_SPECTRAL_INVERSION_NOT_SET} + BDA_SPECTRAL_INVERSION_NOT_DEFINED = 0; + {$EXTERNALSYM BDA_SPECTRAL_INVERSION_NOT_DEFINED} + BDA_SPECTRAL_INVERSION_AUTOMATIC = 1; + {$EXTERNALSYM BDA_SPECTRAL_INVERSION_AUTOMATIC} + BDA_SPECTRAL_INVERSION_NORMAL = 2; + {$EXTERNALSYM BDA_SPECTRAL_INVERSION_NORMAL} + BDA_SPECTRAL_INVERSION_INVERTED = 3; + {$EXTERNALSYM BDA_SPECTRAL_INVERSION_INVERTED} + BDA_SPECTRAL_INVERSION_MAX = 4; + {$EXTERNALSYM BDA_SPECTRAL_INVERSION_MAX} + +Type + Polarisation = {$IFDEF TYPE_IDENTITY}type {$ENDIF} LongWord; + {$EXTERNALSYM Polarisation} + const + BDA_POLARISATION_NOT_SET = -1; + {$EXTERNALSYM BDA_POLARISATION_NOT_SET} + BDA_POLARISATION_NOT_DEFINED = 0; + {$EXTERNALSYM BDA_POLARISATION_NOT_DEFINED} + BDA_POLARISATION_LINEAR_H = 1; // Linear horizontal polarisation + {$EXTERNALSYM BDA_POLARISATION_LINEAR_H} + BDA_POLARISATION_LINEAR_V = 2; // Linear vertical polarisation + {$EXTERNALSYM BDA_POLARISATION_LINEAR_V} + BDA_POLARISATION_CIRCULAR_L = 3; // Circular left polarisation + {$EXTERNALSYM BDA_POLARISATION_CIRCULAR_L} + BDA_POLARISATION_CIRCULAR_R = 4; // Circular right polarisation + {$EXTERNALSYM BDA_POLARISATION_CIRCULAR_R} + BDA_POLARISATION_MAX = 5; + {$EXTERNALSYM BDA_POLARISATION_MAX} + +type + GuardInterval = {$IFDEF TYPE_IDENTITY}type {$ENDIF} LongWord; + {$EXTERNALSYM GuardInterval} + const + BDA_GUARD_NOT_SET = -1; + {$EXTERNALSYM BDA_GUARD_NOT_SET} + BDA_GUARD_NOT_DEFINED = 0; + {$EXTERNALSYM BDA_GUARD_NOT_DEFINED} + BDA_GUARD_1_32 = 1; // Guard interval is 1/32 + {$EXTERNALSYM BDA_GUARD_1_32} + BDA_GUARD_1_16 = 2; // Guard interval is 1/16 + {$EXTERNALSYM BDA_GUARD_1_16} + BDA_GUARD_1_8 = 3; // Guard interval is 1/8 + {$EXTERNALSYM BDA_GUARD_1_8} + BDA_GUARD_1_4 = 4; // Guard interval is 1/4 + {$EXTERNALSYM BDA_GUARD_1_4} + BDA_GUARD_MAX = 5; + {$EXTERNALSYM BDA_GUARD_MAX} + +type + HierarchyAlpha = {$IFDEF TYPE_IDENTITY}type {$ENDIF} LongWord; + {$EXTERNALSYM HierarchyAlpha} + const + BDA_HALPHA_NOT_SET = -1; + {$EXTERNALSYM BDA_HALPHA_NOT_SET} + BDA_HALPHA_NOT_DEFINED = 0; + {$EXTERNALSYM BDA_HALPHA_NOT_DEFINED} + BDA_HALPHA_1 = 1; // Hierarchy alpha is 1. + {$EXTERNALSYM BDA_HALPHA_1} + BDA_HALPHA_2 = 2; // Hierarchy alpha is 2. + {$EXTERNALSYM BDA_HALPHA_2} + BDA_HALPHA_4 = 3; // Hierarchy alpha is 4. + {$EXTERNALSYM BDA_HALPHA_4} + BDA_HALPHA_MAX = 4; + {$EXTERNALSYM BDA_HALPHA_MAX} + +type + TransmissionMode = {$IFDEF TYPE_IDENTITY}type {$ENDIF} LongWord; + {$EXTERNALSYM TransmissionMode} + const + BDA_XMIT_MODE_NOT_SET = -1; + {$EXTERNALSYM BDA_XMIT_MODE_NOT_SET} + BDA_XMIT_MODE_NOT_DEFINED = 0; + {$EXTERNALSYM BDA_XMIT_MODE_NOT_DEFINED} + BDA_XMIT_MODE_2K = 1; // Transmission uses 1705 carriers (use a 2K FFT) + {$EXTERNALSYM BDA_XMIT_MODE_2K} + BDA_XMIT_MODE_8K = 2; // Transmission uses 6817 carriers (use an 8K FFT) + {$EXTERNALSYM BDA_XMIT_MODE_8K} + BDA_XMIT_MODE_MAX = 3; + {$EXTERNALSYM BDA_XMIT_MODE_MAX} + + +// Settings for Tuner Frequency +// + + BDA_FREQUENCY_NOT_SET = -1; + {$EXTERNALSYM BDA_FREQUENCY_NOT_SET} + BDA_FREQUENCY_NOT_DEFINED = 0; + {$EXTERNALSYM BDA_FREQUENCY_NOT_DEFINED} + +// Settings for Tuner Range +// +// Tuner range refers to the setting of LNB High/Low as well as the +// selection of a satellite on a multiple satellite switch. +// + BDA_RANGE_NOT_SET = -1; + {$EXTERNALSYM BDA_RANGE_NOT_SET} + BDA_RANGE_NOT_DEFINED = 0; + {$EXTERNALSYM BDA_RANGE_NOT_DEFINED} + +// Settings for Tuner Channel Bandwidth +// + BDA_CHAN_BANDWITH_NOT_SET = -1; + {$EXTERNALSYM BDA_CHAN_BANDWITH_NOT_SET} + BDA_CHAN_BANDWITH_NOT_DEFINED = 0; + {$EXTERNALSYM BDA_CHAN_BANDWITH_NOT_DEFINED} + +// Settings for Tuner Frequency Multiplier +// + BDA_FREQUENCY_MULTIPLIER_NOT_SET = -1; + {$EXTERNALSYM BDA_FREQUENCY_MULTIPLIER_NOT_SET} + BDA_FREQUENCY_MULTIPLIER_NOT_DEFINED = 0; + {$EXTERNALSYM BDA_FREQUENCY_MULTIPLIER_NOT_DEFINED} + +//------------------------------------------------------------------------------ +// File: Regbag.h +// Desc: part of Tuner library +// Copyright (c) 1999 - 2000, Microsoft Corporation. All rights reserved. +//------------------------------------------------------------------------------ + +const + IID_ICreatePropBagOnRegKey : TGUID = '{8A674B48-1F63-11d3-B64C-00C04F79498E}'; + {$EXTERNALSYM IID_ICreatePropBagOnRegKey} + +type + {$HPPEMIT 'typedef System::DelphiInterface _di_ICreatePropBagOnRegKey;'} + {$EXTERNALSYM ICreatePropBagOnRegKey} + ICreatePropBagOnRegKey = interface(IUnknown) + ['{8A674B48-1F63-11d3-B64C-00C04F79498E}'] + (*** ICreatePropBagOnRegKey methods ***) + function Create(hkey: HKEY; subkey: POleStr; ulOptions, samDesired: DWORD; + const iid: TGUID; out ppBag): HResult; stdcall; + end; + +//------------------------------------------------------------------------------ +// File: Tuner.h +// Desc: Tuner library +// Copyright (c) 1999 - 2000, Microsoft Corporation. All rights reserved. +//------------------------------------------------------------------------------ + +const + IID_ITuningSpaces : TGUID = '{901284E4-33FE-4b69-8D63-634A596F3756}'; + {$EXTERNALSYM IID_ITuningSpaces} + IID_ITuningSpaceContainer : TGUID = '{5B692E84-E2F1-11d2-9493-00C04F72D980}'; + {$EXTERNALSYM IID_ITuningSpaceContainer} + IID_ITuningSpace : TGUID = '{061C6E30-E622-11d2-9493-00C04F72D980}'; + {$EXTERNALSYM IID_ITuningSpace} + IID_IEnumTuningSpaces : TGUID = '{8B8EB248-FC2B-11d2-9D8C-00C04F72D980}'; + {$EXTERNALSYM IID_IEnumTuningSpaces} + IID_IDVBTuningSpace : TGUID = '{ADA0B268-3B19-4e5b-ACC4-49F852BE13BA}'; + {$EXTERNALSYM IID_IDVBTuningSpace} + IID_IAnalogTVTuningSpace : TGUID = '{2A6E293C-2595-11d3-B64C-00C04F79498E}'; + {$EXTERNALSYM IID_IAnalogTVTuningSpace} + IID_IATSCTuningSpace : TGUID = '{0369B4E2-45B6-11d3-B650-00C04F79498E}'; + {$EXTERNALSYM IID_IATSCTuningSpace} + IID_IAnalogRadioTuningSpace : TGUID = '{2A6E293B-2595-11d3-B64C-00C04F79498E}'; + {$EXTERNALSYM IID_IAnalogRadioTuningSpace} + IID_ITuneRequest : TGUID = '{07DDC146-FC3D-11d2-9D8C-00C04F72D980}'; + {$EXTERNALSYM IID_ITuneRequest} + IID_IChannelTuneRequest : TGUID = '{0369B4E0-45B6-11d3-B650-00C04F79498E}'; + {$EXTERNALSYM IID_IChannelTuneRequest} + IID_IATSCChannelTuneRequest : TGUID = '{0369B4E1-45B6-11d3-B650-00C04F79498E}'; + {$EXTERNALSYM IID_IATSCChannelTuneRequest} + IID_IDVBTuneRequest : TGUID = '{0D6F567E-A636-42bb-83BA-CE4C1704AFA2}'; + {$EXTERNALSYM IID_IDVBTuneRequest} + IID_ITuner : TGUID = '{28C52640-018A-11d3-9D8E-00C04F72D980}'; + {$EXTERNALSYM IID_ITuner} + IID_IScanningTuner : TGUID = '{1DFD0A5C-0284-11d3-9D8E-00C04F72D980}'; + {$EXTERNALSYM IID_IScanningTuner} + IID_ITunerEvents : TGUID = '{68481420-0280-11d3-9D8E-00C04F72D980}'; + {$EXTERNALSYM IID_ITunerEvents} + IID_ISignalEvents : TGUID = '{85E2439E-0E23-11d3-9D8E-00C04F72D980}'; + {$EXTERNALSYM IID_ISignalEvents} + IID_IComponentType : TGUID = '{6A340DC0-0311-11d3-9D8E-00C04F72D980}'; + {$EXTERNALSYM IID_IComponentType} + IID_ILanguageComponentType : TGUID = '{B874C8BA-0FA2-11d3-9D8E-00C04F72D980}'; + {$EXTERNALSYM IID_ILanguageComponentType} + IID_IMPEG2ComponentType : TGUID = '{2C073D84-B51C-48c9-AA9F-68971E1F6E38}'; + {$EXTERNALSYM IID_IMPEG2ComponentType} + IID_IATSCComponentType : TGUID = '{FC189E4D-7BD4-4125-B3B3-3A76A332CC96}'; + {$EXTERNALSYM IID_IATSCComponentType} + IID_IEnumComponentTypes : TGUID = '{8A674B4A-1F63-11d3-B64C-00C04F79498E}'; + {$EXTERNALSYM IID_IEnumComponentTypes} + IID_IComponentTypes : TGUID = '{0DC13D4A-0313-11d3-9D8E-00C04F72D980}'; + {$EXTERNALSYM IID_IComponentTypes} + IID_IComponent : TGUID = '{1A5576FC-0E19-11d3-9D8E-00C04F72D980}'; + {$EXTERNALSYM IID_IComponent} + IID_IMPEG2Component : TGUID = '{1493E353-1EB6-473c-802D-8E6B8EC9D2A9}'; + {$EXTERNALSYM IID_IMPEG2Component} + IID_IEnumComponents : TGUID = '{2A6E2939-2595-11d3-B64C-00C04F79498E}'; + {$EXTERNALSYM IID_IEnumComponents} + IID_IComponents : TGUID = '{FCD01846-0E19-11d3-9D8E-00C04F72D980}'; + {$EXTERNALSYM IID_IComponents} + IID_ILocator : TGUID = '{286D7F89-760C-4F89-80C4-66841D2507AA}'; + {$EXTERNALSYM IID_ILocator} + IID_IATSCLocator : TGUID = '{BF8D986F-8C2B-4131-94D7-4D3D9FCC21EF}'; + {$EXTERNALSYM IID_IATSCLocator} + IID_IDVBTLocator : TGUID = '{8664DA16-DDA2-42ac-926A-C18F9127C302}'; + {$EXTERNALSYM IID_IDVBTLocator} + IID_IDVBSLocator : TGUID = '{3D7C353C-0D04-45f1-A742-F97CC1188DC8}'; + {$EXTERNALSYM IID_IDVBSLocator} + IID_IDVBCLocator : TGUID = '{6E42F36E-1DD2-43c4-9F78-69D25AE39034}'; + {$EXTERNALSYM IID_IDVBCLocator} + + IID_IDVBTuningSpace2 : TGUID = '{843188B4-CE62-43db-966B-8145A094E040}'; + {$EXTERNALSYM IID_IDVBTuningSpace2} + IID_IDVBSTuningSpace : TGUID = '{CDF7BE60-D954-42fd-A972-78971958E470}'; + {$EXTERNALSYM IID_IDVBSTuningSpace} + IID_IMPEG2TuneRequest : TGUID = '{EB7D987F-8A01-42AD-B8AE-574DEEE44D1A}'; + {$EXTERNALSYM IID_IMPEG2TuneRequest} + IID_IMPEG2TuneRequestFactory : TGUID = '{14E11ABD-EE37-4893-9EA1-6964DE933E39}'; + {$EXTERNALSYM IID_IMPEG2TuneRequestFactory} + IID_IMPEG2TuneRequestSupport : TGUID = '{1B9D5FC3-5BBC-4b6c-BB18-B9D10E3EEEBF}'; + {$EXTERNALSYM IID_IMPEG2TuneRequestSupport} + IID_IBroadcastEvent : TGUID = '{3B21263F-26E8-489d-AAC4-924F7EFD9511}'; + {$EXTERNALSYM IID_IBroadcastEvent} + + IID_IAuxInTuningSpace : TGUID = '{E48244B8-7E17-4f76-A763-5090FF1E2F30}'; // DX9 + {$EXTERNALSYM IID_IAuxInTuningSpace} + + CLSID_SystemTuningSpaces : TGUID = '{D02AAC50-027E-11d3-9D8E-00C04F72D980}'; + {$EXTERNALSYM CLSID_SystemTuningSpaces} + CLSID_TuningSpace : TGUID = '{5FFDC5E6-B83A-4b55-B6E8-C69E765FE9DB}'; + {$EXTERNALSYM CLSID_TuningSpace} + CLSID_ATSCTuningSpace : TGUID = '{A2E30750-6C3D-11d3-B653-00C04F79498E}'; + {$EXTERNALSYM CLSID_ATSCTuningSpace} + CLSID_AnalogRadioTuningSpace : TGUID = '{8A674B4C-1F63-11d3-B64C-00C04F79498E}'; + {$EXTERNALSYM CLSID_AnalogRadioTuningSpace} + CLSID_AnalogTVTuningSpace : TGUID = '{8A674B4D-1F63-11d3-B64C-00C04F79498E}'; + {$EXTERNALSYM CLSID_AnalogTVTuningSpace} + CLSID_DVBTuningSpace : TGUID = '{C6B14B32-76AA-4a86-A7AC-5C79AAF58DA7}'; + {$EXTERNALSYM CLSID_DVBTuningSpace} + CLSID_ComponentTypes : TGUID = '{A1A2B1C4-0E3A-11d3-9D8E-00C04F72D980}'; + {$EXTERNALSYM CLSID_ComponentTypes} + CLSID_ComponentType : TGUID = '{823535A0-0318-11d3-9D8E-00C04F72D980}'; + {$EXTERNALSYM CLSID_ComponentType} + CLSID_LanguageComponentType : TGUID = '{1BE49F30-0E1B-11d3-9D8E-00C04F72D980}'; + {$EXTERNALSYM CLSID_LanguageComponentType} + CLSID_MPEG2ComponentType : TGUID = '{418008F3-CF67-4668-9628-10DC52BE1D08}'; + {$EXTERNALSYM CLSID_MPEG2ComponentType} + CLSID_ATSCComponentType : TGUID = '{A8DCF3D5-0780-4ef4-8A83-2CFFAACB8ACE}'; + {$EXTERNALSYM CLSID_ATSCComponentType} + CLSID_Components : TGUID = '{809B6661-94C4-49e6-B6EC-3F0F862215AA}'; + {$EXTERNALSYM CLSID_Components} + CLSID_Component : TGUID = '{59DC47A8-116C-11d3-9D8E-00C04F72D980}'; + {$EXTERNALSYM CLSID_Component} + CLSID_MPEG2Component : TGUID = '{055CB2D7-2969-45cd-914B-76890722F112}'; + {$EXTERNALSYM CLSID_MPEG2Component} + CLSID_TuneRequest : TGUID = '{B46E0D38-AB35-4a06-A137-70576B01B39F}'; + {$EXTERNALSYM CLSID_TuneRequest} + CLSID_ChannelTuneRequest : TGUID = '{0369B4E5-45B6-11d3-B650-00C04F79498E}'; + {$EXTERNALSYM CLSID_ChannelTuneRequest} + CLSID_ATSCChannelTuneRequest : TGUID = '{0369B4E6-45B6-11d3-B650-00C04F79498E}'; + {$EXTERNALSYM CLSID_ATSCChannelTuneRequest} + CLSID_Locator : TGUID = '{0888C883-AC4F-4943-B516-2C38D9B34562}'; + {$EXTERNALSYM CLSID_Locator} + CLSID_ATSCLocator : TGUID = '{8872FF1B-98FA-4d7a-8D93-C9F1055F85BB}'; + {$EXTERNALSYM CLSID_ATSCLocator} + CLSID_DVBTLocator : TGUID = '{9CD64701-BDF3-4d14-8E03-F12983D86664}'; + {$EXTERNALSYM CLSID_DVBTLocator} + CLSID_DVBSLocator : TGUID = '{1DF7D126-4050-47f0-A7CF-4C4CA9241333}'; + {$EXTERNALSYM CLSID_DVBSLocator} + CLSID_DVBCLocator : TGUID = '{C531D9FD-9685-4028-8B68-6E1232079F1E}'; + {$EXTERNALSYM CLSID_DVBCLocator} + CLSID_DVBTuneRequest : TGUID = '{15D6504A-5494-499c-886C-973C9E53B9F1}'; + {$EXTERNALSYM CLSID_DVBTuneRequest} + CLSID_CreatePropBagOnRegKey : TGUID = '{8A674B49-1F63-11d3-B64C-00C04F79498E}'; + {$EXTERNALSYM CLSID_CreatePropBagOnRegKey} + + CLSID_DVBSTuningSpace : TGUID = '{B64016F3-C9A2-4066-96F0-BD9563314726}'; + {$EXTERNALSYM CLSID_DVBSTuningSpace} + CLSID_MPEG2TuneRequest : TGUID = '{0955AC62-BF2E-4CBA-A2B9-A63F772D46CF}'; + {$EXTERNALSYM CLSID_MPEG2TuneRequest} + CLSID_BroadcastEventService : TGUID = '{0B3FFB92-0919-4934-9D5B-619C719D0202}'; + {$EXTERNALSYM CLSID_BroadcastEventService} + CLSID_MPEG2TuneRequestFactory: TGUID = '{2C63E4EB-4CEA-41B8-919C-E947EA19A77C}'; + {$EXTERNALSYM CLSID_MPEG2TuneRequestFactory} + + CLSID_AuxInTuningSpace : TGUID = '{F9769A06-7ACA-4e39-9CFB-97BB35F0E77E}'; + {$EXTERNALSYM CLSID_AuxInTuningSpace} + + DISPID_TUNER_TS_UNIQUENAME = 1; + {$EXTERNALSYM DISPID_TUNER_TS_UNIQUENAME} + DISPID_TUNER_TS_FRIENDLYNAME = 2; + {$EXTERNALSYM DISPID_TUNER_TS_FRIENDLYNAME} + DISPID_TUNER_TS_CLSID = 3; + {$EXTERNALSYM DISPID_TUNER_TS_CLSID} + DISPID_TUNER_TS_NETWORKTYPE = 4; + {$EXTERNALSYM DISPID_TUNER_TS_NETWORKTYPE} + DISPID_TUNER_TS__NETWORKTYPE = 5; + {$EXTERNALSYM DISPID_TUNER_TS__NETWORKTYPE} + DISPID_TUNER_TS_CREATETUNEREQUEST = 6; + {$EXTERNALSYM DISPID_TUNER_TS_CREATETUNEREQUEST} + DISPID_TUNER_TS_ENUMCATEGORYGUIDS = 7; + {$EXTERNALSYM DISPID_TUNER_TS_ENUMCATEGORYGUIDS} + DISPID_TUNER_TS_ENUMDEVICEMONIKERS = 8; + {$EXTERNALSYM DISPID_TUNER_TS_ENUMDEVICEMONIKERS} + DISPID_TUNER_TS_DEFAULTPREFERREDCOMPONENTTYPES = 9; + {$EXTERNALSYM DISPID_TUNER_TS_DEFAULTPREFERREDCOMPONENTTYPES} + DISPID_TUNER_TS_FREQMAP = 10; + {$EXTERNALSYM DISPID_TUNER_TS_FREQMAP} + DISPID_TUNER_TS_DEFLOCATOR = 11; + {$EXTERNALSYM DISPID_TUNER_TS_DEFLOCATOR} + DISPID_TUNER_TS_CLONE = 12; + {$EXTERNALSYM DISPID_TUNER_TS_CLONE} + + // DISPIDs for ITuneRequest interface + DISPID_TUNER_TR_TUNINGSPACE = 1; + {$EXTERNALSYM DISPID_TUNER_TR_TUNINGSPACE} + DISPID_TUNER_TR_COMPONENTS = 2; + {$EXTERNALSYM DISPID_TUNER_TR_COMPONENTS} + DISPID_TUNER_TR_CLONE = 3; + {$EXTERNALSYM DISPID_TUNER_TR_CLONE} + DISPID_TUNER_TR_LOCATOR = 4; + {$EXTERNALSYM DISPID_TUNER_TR_LOCATOR} + + // DISPID for IComponentType interface + DISPID_TUNER_CT_CATEGORY = 1; + {$EXTERNALSYM DISPID_TUNER_CT_CATEGORY} + DISPID_TUNER_CT_MEDIAMAJORTYPE = 2; + {$EXTERNALSYM DISPID_TUNER_CT_MEDIAMAJORTYPE} + DISPID_TUNER_CT__MEDIAMAJORTYPE = 3; + {$EXTERNALSYM DISPID_TUNER_CT__MEDIAMAJORTYPE} + DISPID_TUNER_CT_MEDIASUBTYPE = 4; + {$EXTERNALSYM DISPID_TUNER_CT_MEDIASUBTYPE} + DISPID_TUNER_CT__MEDIASUBTYPE = 5; + {$EXTERNALSYM DISPID_TUNER_CT__MEDIASUBTYPE} + DISPID_TUNER_CT_MEDIAFORMATTYPE = 6; + {$EXTERNALSYM DISPID_TUNER_CT_MEDIAFORMATTYPE} + DISPID_TUNER_CT__MEDIAFORMATTYPE = 7; + {$EXTERNALSYM DISPID_TUNER_CT__MEDIAFORMATTYPE} + DISPID_TUNER_CT_MEDIATYPE = 8; + {$EXTERNALSYM DISPID_TUNER_CT_MEDIATYPE} + DISPID_TUNER_CT_CLONE = 9; + {$EXTERNALSYM DISPID_TUNER_CT_CLONE} + + // DISPID for ILanguageComponentType interface + DISPID_TUNER_LCT_LANGID = 100; + {$EXTERNALSYM DISPID_TUNER_LCT_LANGID} + + // DISPID for IMPEG2ComponentType interface + DISPID_TUNER_MP2CT_TYPE = 200; + {$EXTERNALSYM DISPID_TUNER_MP2CT_TYPE} + + // DISPID for IATSCComponentType interface + DISPID_TUNER_ATSCCT_FLAGS = 300; + {$EXTERNALSYM DISPID_TUNER_ATSCCT_FLAGS} + + // DISPID for ILocator interface + DISPID_TUNER_L_CARRFREQ = 1; + {$EXTERNALSYM DISPID_TUNER_L_CARRFREQ} + DISPID_TUNER_L_INNERFECMETHOD = 2; + {$EXTERNALSYM DISPID_TUNER_L_INNERFECMETHOD} + DISPID_TUNER_L_INNERFECRATE = 3; + {$EXTERNALSYM DISPID_TUNER_L_INNERFECRATE} + DISPID_TUNER_L_OUTERFECMETHOD = 4; + {$EXTERNALSYM DISPID_TUNER_L_OUTERFECMETHOD} + DISPID_TUNER_L_OUTERFECRATE = 5; + {$EXTERNALSYM DISPID_TUNER_L_OUTERFECRATE} + DISPID_TUNER_L_MOD = 6; + {$EXTERNALSYM DISPID_TUNER_L_MOD} + DISPID_TUNER_L_SYMRATE = 7; + {$EXTERNALSYM DISPID_TUNER_L_SYMRATE} + DISPID_TUNER_L_CLONE = 8; + {$EXTERNALSYM DISPID_TUNER_L_CLONE} + + // DISPID for IATSCLocator interface + DISPID_TUNER_L_ATSC_PHYS_CHANNEL = 201; + {$EXTERNALSYM DISPID_TUNER_L_ATSC_PHYS_CHANNEL} + DISPID_TUNER_L_ATSC_TSID = 202; + {$EXTERNALSYM DISPID_TUNER_L_ATSC_TSID} + + // DISPID for IDVBTLocator interface + DISPID_TUNER_L_DVBT_BANDWIDTH = 301; + {$EXTERNALSYM DISPID_TUNER_L_DVBT_BANDWIDTH} + DISPID_TUNER_L_DVBT_LPINNERFECMETHOD = 302; + {$EXTERNALSYM DISPID_TUNER_L_DVBT_LPINNERFECMETHOD} + DISPID_TUNER_L_DVBT_LPINNERFECRATE = 303; + {$EXTERNALSYM DISPID_TUNER_L_DVBT_LPINNERFECRATE} + DISPID_TUNER_L_DVBT_GUARDINTERVAL = 304; + {$EXTERNALSYM DISPID_TUNER_L_DVBT_GUARDINTERVAL} + DISPID_TUNER_L_DVBT_HALPHA = 305; + {$EXTERNALSYM DISPID_TUNER_L_DVBT_HALPHA} + DISPID_TUNER_L_DVBT_TRANSMISSIONMODE = 306; + {$EXTERNALSYM DISPID_TUNER_L_DVBT_TRANSMISSIONMODE} + DISPID_TUNER_L_DVBT_INUSE = 307; + {$EXTERNALSYM DISPID_TUNER_L_DVBT_INUSE} + + // DISPID for IDVBSLocator interface + DISPID_TUNER_L_DVBS_POLARISATION = 401; + {$EXTERNALSYM DISPID_TUNER_L_DVBS_POLARISATION} + DISPID_TUNER_L_DVBS_WEST = 402; + {$EXTERNALSYM DISPID_TUNER_L_DVBS_WEST} + DISPID_TUNER_L_DVBS_ORBITAL = 403; + {$EXTERNALSYM DISPID_TUNER_L_DVBS_ORBITAL} + DISPID_TUNER_L_DVBS_AZIMUTH = 404; + {$EXTERNALSYM DISPID_TUNER_L_DVBS_AZIMUTH} + DISPID_TUNER_L_DVBS_ELEVATION = 405; + {$EXTERNALSYM DISPID_TUNER_L_DVBS_ELEVATION} + + // DISPID for IDVBCLocator interface + + // DISPIDs for IComponent interface + DISPID_TUNER_C_TYPE = 1; + {$EXTERNALSYM DISPID_TUNER_C_TYPE} + DISPID_TUNER_C_STATUS = 2; + {$EXTERNALSYM DISPID_TUNER_C_STATUS} + DISPID_TUNER_C_LANGID = 3; + {$EXTERNALSYM DISPID_TUNER_C_LANGID} + DISPID_TUNER_C_DESCRIPTION = 4; + {$EXTERNALSYM DISPID_TUNER_C_DESCRIPTION} + DISPID_TUNER_C_CLONE = 5; + {$EXTERNALSYM DISPID_TUNER_C_CLONE} + + // DISPIDs for IMPEG2Component interface + DISPID_TUNER_C_MP2_PID = 101; + {$EXTERNALSYM DISPID_TUNER_C_MP2_PID} + DISPID_TUNER_C_MP2_PCRPID = 102; + {$EXTERNALSYM DISPID_TUNER_C_MP2_PCRPID} + DISPID_TUNER_C_MP2_PROGNO = 103; + {$EXTERNALSYM DISPID_TUNER_C_MP2_PROGNO} + DISPID_TUNER_TS_DVB_SYSTEMTYPE = 101; + {$EXTERNALSYM DISPID_TUNER_TS_DVB_SYSTEMTYPE} + + // DISPIDs for IDVBTuningSpace2 interface + DISPID_TUNER_TS_DVB2_NETWORK_ID = 102; + {$EXTERNALSYM DISPID_TUNER_TS_DVB2_NETWORK_ID} + // DISPIDs for IDVBSTuningSpace interface + DISPID_TUNER_TS_DVBS_LOW_OSC_FREQ = 1001; + {$EXTERNALSYM DISPID_TUNER_TS_DVBS_LOW_OSC_FREQ} + DISPID_TUNER_TS_DVBS_HI_OSC_FREQ = 1002; + {$EXTERNALSYM DISPID_TUNER_TS_DVBS_HI_OSC_FREQ} + DISPID_TUNER_TS_DVBS_LNB_SWITCH_FREQ = 1003; + {$EXTERNALSYM DISPID_TUNER_TS_DVBS_LNB_SWITCH_FREQ} + DISPID_TUNER_TS_DVBS_INPUT_RANGE = 1004; + {$EXTERNALSYM DISPID_TUNER_TS_DVBS_INPUT_RANGE} + DISPID_TUNER_TS_DVBS_SPECTRAL_INVERSION = 1005; + {$EXTERNALSYM DISPID_TUNER_TS_DVBS_SPECTRAL_INVERSION} + + // DISPIDs for IAnalogRadioTuningSpace interface + DISPID_TUNER_TS_AR_MINFREQUENCY = 101; + {$EXTERNALSYM DISPID_TUNER_TS_AR_MINFREQUENCY} + DISPID_TUNER_TS_AR_MAXFREQUENCY = 102; + {$EXTERNALSYM DISPID_TUNER_TS_AR_MAXFREQUENCY} + DISPID_TUNER_TS_AR_STEP = 103; + {$EXTERNALSYM DISPID_TUNER_TS_AR_STEP} + + // DISPIDs for IAnalogTVTuningSpace interface + DISPID_TUNER_TS_ATV_MINCHANNEL = 101; + {$EXTERNALSYM DISPID_TUNER_TS_ATV_MINCHANNEL} + DISPID_TUNER_TS_ATV_MAXCHANNEL = 102; + {$EXTERNALSYM DISPID_TUNER_TS_ATV_MAXCHANNEL} + DISPID_TUNER_TS_ATV_INPUTTYPE = 103; + {$EXTERNALSYM DISPID_TUNER_TS_ATV_INPUTTYPE} + DISPID_TUNER_TS_ATV_COUNTRYCODE = 104; + {$EXTERNALSYM DISPID_TUNER_TS_ATV_COUNTRYCODE} + + // DISPIDs for IATSCTuningSpace interface + DISPID_TUNER_TS_ATSC_MINMINORCHANNEL = 201; + {$EXTERNALSYM DISPID_TUNER_TS_ATSC_MINMINORCHANNEL} + DISPID_TUNER_TS_ATSC_MAXMINORCHANNEL = 202; + {$EXTERNALSYM DISPID_TUNER_TS_ATSC_MAXMINORCHANNEL} + DISPID_TUNER_TS_ATSC_MINPHYSCHANNEL = 203; + {$EXTERNALSYM DISPID_TUNER_TS_ATSC_MINPHYSCHANNEL} + DISPID_TUNER_TS_ATSC_MAXPHYSCHANNEL = 204; + {$EXTERNALSYM DISPID_TUNER_TS_ATSC_MAXPHYSCHANNEL} + + // DISPID for IAnalogTVAudioComponent interface + DISPID_CHTUNER_ATVAC_CHANNEL = 101; + {$EXTERNALSYM DISPID_CHTUNER_ATVAC_CHANNEL} + + // DISPIDs for IAnalogTVDataComponent interface + DISPID_CHTUNER_ATVDC_SYSTEM = 101; + {$EXTERNALSYM DISPID_CHTUNER_ATVDC_SYSTEM} + DISPID_CHTUNER_ATVDC_CONTENT = 102; + {$EXTERNALSYM DISPID_CHTUNER_ATVDC_CONTENT} + + // DISPID for IChannelTuneRequest interface + DISPID_CHTUNER_CTR_CHANNEL = 101; + {$EXTERNALSYM DISPID_CHTUNER_CTR_CHANNEL} + + // DISPID IATSCChannelTuneRequest + DISPID_CHTUNER_ACTR_MINOR_CHANNEL = 201; + {$EXTERNALSYM DISPID_CHTUNER_ACTR_MINOR_CHANNEL} + + // DISPIDs for IDVBComponent interface + DISPID_DVBTUNER_DVBC_ATTRIBUTESVALID = 101; + {$EXTERNALSYM DISPID_DVBTUNER_DVBC_ATTRIBUTESVALID} + DISPID_DVBTUNER_DVBC_PID = 102; + {$EXTERNALSYM DISPID_DVBTUNER_DVBC_PID} + DISPID_DVBTUNER_DVBC_TAG = 103; + {$EXTERNALSYM DISPID_DVBTUNER_DVBC_TAG} + DISPID_DVBTUNER_DVBC_COMPONENTTYPE = 104; + {$EXTERNALSYM DISPID_DVBTUNER_DVBC_COMPONENTTYPE} + + // DISPIDs for IDVBTuneRequest interface + DISPID_DVBTUNER_ONID = 101; + {$EXTERNALSYM DISPID_DVBTUNER_ONID} + DISPID_DVBTUNER_TSID = 102; + {$EXTERNALSYM DISPID_DVBTUNER_TSID} + DISPID_DVBTUNER_SID = 103; + {$EXTERNALSYM DISPID_DVBTUNER_SID} + + // DISPIDs for IMPEG2TuneRequest interface + DISPID_MP2TUNER_TSID = 101; + {$EXTERNALSYM DISPID_MP2TUNER_TSID} + DISPID_MP2TUNER_PROGNO = 102; + {$EXTERNALSYM DISPID_MP2TUNER_PROGNO} + + // DISPIDs for IMPEG2TuneRequestFactory interface + DISPID_MP2TUNERFACTORY_CREATETUNEREQUEST = 1; + {$EXTERNALSYM DISPID_MP2TUNERFACTORY_CREATETUNEREQUEST} + +type + ITuningSpace = interface; + IEnumTuningSpaces = interface; + + {$HPPEMIT 'typedef System::DelphiInterface _di_ITuningSpaces;'} + {$EXTERNALSYM ITuningSpaces} + ITuningSpaces = interface(IDispatch) + ['{901284E4-33FE-4b69-8D63-634A596F3756}'] + (*** ITuningSpaces methods ***) + function get_Count(out Count: longint): HResult; stdcall; + function get__NewEnum(out NewEnum: IEnumVARIANT): HResult; stdcall; + function get_Item(varIndex: OLEVARIANT; out TuningSpace: ITuningSpace): HResult; stdcall; + function get_EnumTuningSpaces(out NewEnum: IEnumTuningSpaces): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_ITuningSpaceContainer;'} + {$EXTERNALSYM ITuningSpaceContainer} + ITuningSpaceContainer = interface(IDispatch) + ['{5B692E84-E2F1-11d2-9493-00C04F72D980}'] + (*** ITuningSpaceContainer methods ***) + function get_Count(out Count: longint): HResult; stdcall; + function get__NewEnum(out NewEnum: IEnumVARIANT): HResult; stdcall; + function get_Item(varIndex: OLEVARIANT; out TuningSpace: ITuningSpace): HResult; stdcall; + function put_Item(varIndex: OLEVARIANT; TuningSpace: ITuningSpace): HResult; stdcall; + function TuningSpacesForCLSID(SpaceCLSID: widestring; out NewColl: ITuningSpaces): HResult; stdcall; + function _TuningSpacesForCLSID(const SpaceCLSID: TGUID; out NewColl: ITuningSpaces): HResult; stdcall; + function TuningSpacesForName(Name: WideString; out NewColl: ITuningSpaces): HResult; stdcall; + function FindID(TuningSpace: ITuningSpace; out ID: longint): HResult; stdcall; + function Add(TuningSpace: ITuningSpace; out NewIndex: OLEVARIANT): HResult; stdcall; + function get_EnumTuningSpaces(out ppEnum: IEnumTuningSpaces): HResult; stdcall; + function Remove(Index: OLEVARIANT): HResult; stdcall; + function get_MaxCount(out MaxCount: longint): HResult; stdcall; + function put_MaxCount(MaxCount: longint): HResult; stdcall; + end; + + ITuneRequest = interface; + IComponentTypes = interface; + ILocator = interface; + + {$HPPEMIT 'typedef System::DelphiInterface _di_ITuningSpace;'} + {$EXTERNALSYM ITuningSpace} + ITuningSpace = interface(IDispatch) + ['{061C6E30-E622-11d2-9493-00C04F72D980}'] + (*** ITuningSpace methods ***) + function get_UniqueName(out Name: WideString): HResult; stdcall; + function put_UniqueName(Name: WideString): HResult; stdcall; + function get_FriendlyName(out Name: WideString): HResult; stdcall; + function put_FriendlyName: HResult; stdcall; + function get_CLSID(out SpaceCLSID: WideString): HResult; stdcall; + function get_NetworkType(out NetworkTypeGuid: WideString): HResult; stdcall; + function put_NetworkType(NetworkTypeGuid: WideString): HResult; stdcall; + function get__NetworkType(out NetworkTypeGuid: WideString): HResult; stdcall; + function put__NetworkType(const NetworkTypeGuid: WideString): HResult; stdcall; + // this method creates the "best" kind of tune request for this tuning space. + // the tuning space may support other kinds of tune requests created via + // other factory mechanisms(for example, see mpeg2tunerequestfactory). but, + // this method is the preferred way to get a tune request as it always returns + // the optimal type of tune request for this space. + function CreateTuneRequest(out TuneRequest: ITuneRequest): HResult; stdcall; + function EnumCategoryGUIDs(out ppEnum: IEnumGUID): HResult; stdcall; + function EnumDeviceMonikers(out ppEnum: IEnumMoniker): HResult; stdcall; + function get_DefaultPreferredComponentTypes(out ComponentTypes: IComponentTypes): HResult; stdcall; + function put_DefaultPreferredComponentTypes(NewComponentTypes: IComponentTypes): HResult; stdcall; + function get_FrequencyMapping(out pMapping: WideString): HResult; stdcall; + function put_FrequencyMapping(Mapping: WideString): HResult; stdcall; + function get_DefaultLocator(out LocatorVal: ILocator): HResult; stdcall; + function put_DefaultLocator(LocatorVal: ILocator): HResult; stdcall; + function Clone(out NewTS: ITuningSpace): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IEnumTuningSpaces;'} + {$EXTERNALSYM IEnumTuningSpaces} + IEnumTuningSpaces = interface(IUnknown) + ['{8B8EB248-FC2B-11d2-9D8C-00C04F72D980}'] + (*** IEnumTuningSpaces methods ***) + function Next(celt: ULONG; out rgelt: ITuningSpace; out pceltFetched: ULONG): HResult; stdcall; + function Skip(celt: ULONG): HResult; stdcall; + function Reset: HResult; stdcall; + function Clone(out ppEnum: IEnumTuningSpaces): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IDVBTuningSpace;'} + {$EXTERNALSYM IDVBTuningSpace} + IDVBTuningSpace = interface(ITuningSpace) + ['{ADA0B268-3B19-4e5b-ACC4-49F852BE13BA}'] + (*** IDVBTuningSpace methods ***) + function get_SystemType(out SysType: TDVBSystemType): HResult; stdcall; + function put_SystemType(SysType: TDVBSystemType): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IDVBTuningSpace2;'} + {$EXTERNALSYM IDVBTuningSpace2} + IDVBTuningSpace2 = interface(IDVBTuningSpace) + ['{843188B4-CE62-43db-966B-8145A094E040}'] + (*** IDVBTuningSpace2 methods ***) + function get_NetworkID(out NetworkID: longint): HResult; stdcall; + function put_NetworkID(NetworkID: longint): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IDVBSTuningSpace;'} + {$EXTERNALSYM IDVBSTuningSpace} + IDVBSTuningSpace = interface(IDVBTuningSpace2) + ['{CDF7BE60-D954-42FD-A972-78971958E470}'] + (*** IDVBSTuningSpace methods ***) + function get_LowOscillator(out LowOscillator: longint): HResult; stdcall; + function put_LowOscillator(LowOscillator: longint): HResult; stdcall; + function get_HighOscillator(out HighOscillator: longint): HResult; stdcall; + function put_HighOscillator(HighOscillator: longint): HResult; stdcall; + function get_LNBSwitch(out LNBSwitch: longint): HResult; stdcall; + function put_LNBSwitch(LNBSwitch: longint): HResult; stdcall; + function get_InputRange(out InputRange: WideString): HResult; stdcall; + function put_InputRange(const InputRange: WideString): HResult; stdcall; + function get_SpectralInversion(out SpectralInversionVal: SpectralInversion): HResult; stdcall; + function put_SpectralInversion(SpectralInversionVal: SpectralInversion): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAuxInTuningSpace;'} + {$EXTERNALSYM IAuxInTuningSpace} + IAuxInTuningSpace = interface(ITuningSpace) + ['{E48244B8-7E17-4f76-A763-5090FF1E2F30}'] + (*** IAuxInTuningSpace methods ***) + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAnalogTVTuningSpace;'} + {$EXTERNALSYM IAnalogTVTuningSpace} + IAnalogTVTuningSpace = interface(ITuningSpace) + ['{2A6E293C-2595-11d3-B64C-00C04F79498E}'] + (*** IAnalogTVTuningSpace methods ***) + function get_MinChannel(out MinChannelVal: longint): HResult; stdcall; + function put_MinChannel(NewMinChannelVal: longint): HResult; stdcall; + function get_MaxChannel(out MaxChannelVal: longint): HResult; stdcall; + function put_MaxChannel(NewMaxChannelVal: longint): HResult; stdcall; + function get_InputType(out InputTypeVal: TTunerInputType): HResult; stdcall; + function put_InputType(NewInputTypeVal: TTunerInputType): HResult; stdcall; + function get_CountryCode(out CountryCodeVal: longint): HResult; stdcall; + function put_CountryCode(NewCountryCodeVal: longint): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IATSCTuningSpace;'} + {$EXTERNALSYM IATSCTuningSpace} + IATSCTuningSpace = interface(IAnalogTVTuningSpace) + ['{0369B4E2-45B6-11d3-B650-00C04F79498E}'] + (*** IATSCTuningSpace methods ***) + function get_MinMinorChannel(out MinMinorChannelVal: longint): HResult; stdcall; + function put_MinMinorChannel(NewMinMinorChannelVal: longint): HResult; stdcall; + function get_MaxMinorChannel(out MaxMinorChannelVal: longint): HResult; stdcall; + function put_MaxMinorChannel(NewMaxMinorChannelVal: longint): HResult; stdcall; + function get_MinPhysicalChannel(out MinPhysicalChannelVal: longint): HResult; stdcall; + function put_MinPhysicalChannel(NewMinPhysicalChannelVal: longint): HResult; stdcall; + function get_MaxPhysicalChannel(out MaxPhysicalChannelVal: longint): HResult; stdcall; + function put_MaxPhysicalChannel(NewMaxPhysicalChannelVal: longint): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAnalogRadioTuningSpace;'} + {$EXTERNALSYM IAnalogRadioTuningSpace} + IAnalogRadioTuningSpace = interface(ITuningSpace) + ['{2A6E293B-2595-11d3-B64C-00C04F79498E}'] + (*** IAnalogRadioTuningSpace methods ***) + function get_MinFrequency(out MinFrequencyVal: longint): HResult; stdcall; + function put_MinFrequency(NewMinFrequencyVal: longint): HResult; stdcall; + function get_MaxFrequency(out MaxFrequencyVal: longint): HResult; stdcall; + function put_MaxFrequency(NewMaxFrequencyVal: longint): HResult; stdcall; + function get_Step(out StepVal: longint): HResult; stdcall; + function put_Step(NewStepVal: longint): HResult; stdcall; + end; + + IComponents = interface; + + ////////////////////////////////////////////////////////////////////////////////////// + // Tune Request Interfaces + ////////////////////////////////////////////////////////////////////////////////////// + // tune requests(of any kind) can only be obtained from tune request factories such as + // ITuningSpace::CreateTuneRequest. one reason for this is that we always want to be + // certain that a tune request is bound to the right tuning space. this means we don't + // have to perform consistency checks all over the place. + + {$HPPEMIT 'typedef System::DelphiInterface _di_ITuneRequest;'} + {$EXTERNALSYM ITuneRequest} + ITuneRequest = interface(IDispatch) + ['{07DDC146-FC3D-11d2-9D8C-00C04F72D980}'] + (*** ITuneRequest methods ***) + function get_TuningSpace(out TuningSpace: ITuningSpace): HResult; stdcall; + function get_Components(out Components: IComponents): HResult; stdcall; + function Clone(out NewTuneRequest: ITuneRequest): HResult; stdcall; + function get_Locator(out Locator: ILocator): HResult; stdcall; + function put_Locator(Locator: ILocator): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IChannelTuneRequest;'} + {$EXTERNALSYM IChannelTuneRequest} + IChannelTuneRequest = interface(ITuneRequest) + ['{0369B4E0-45B6-11d3-B650-00C04F79498E}'] + (*** IChannelTuneRequest methods ***) + function get_Channel(out Channel: longint): HResult; stdcall; + function put_Channel(Channel: longint): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IATSCChannelTuneRequest;'} + {$EXTERNALSYM IATSCChannelTuneRequest} + IATSCChannelTuneRequest = interface(IChannelTuneRequest) + ['{0369B4E1-45B6-11d3-B650-00C04F79498E}'] + (*** IATSCChannelTuneRequest methods ***) + function get_MinorChannel(out MinorChannel: longint): HResult; stdcall; + function put_MinorChannel(MinorChannel: longint): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IDVBTuneRequest;'} + {$EXTERNALSYM IDVBTuneRequest} + IDVBTuneRequest = interface(ITuneRequest) + ['{0D6F567E-A636-42bb-83BA-CE4C1704AFA2}'] + (*** IDVBTuneRequest methods ***) + function get_ONID(out ONID: longint): HResult; stdcall; + function put_ONID(ONID: longint): HResult; stdcall; + function get_TSID(out TSID: longint): HResult; stdcall; + function put_TSID(TSID: longint): HResult; stdcall; + function get_SID(out SID: longint): HResult; stdcall; + function put_SID(SID: longint): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IMPEG2TuneRequest;'} + {$EXTERNALSYM IMPEG2TuneRequest} + IMPEG2TuneRequest = interface(ITuneRequest) + ['{EB7D987F-8A01-42AD-B8AE-574DEEE44D1A}'] + (*** IMPEG2TuneRequest methods ***) + function get_TSID: HResult; stdcall; + function put_TSID(TSID: longint): HResult; stdcall; + function get_ProgNo: HResult; stdcall; + function put_ProgNo(ProgNo: longint): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IMPEG2TuneRequestFactory;'} + {$EXTERNALSYM IMPEG2TuneRequestFactory} + IMPEG2TuneRequestFactory = interface(IDispatch) + ['{14E11ABD-EE37-4893-9EA1-6964DE933E39}'] + (*** IMPEG2TuneRequestFactory methods ***) + function CreateTuneRequest(TuningSpace: ITuningSpace; + out TuneRequest: IMPEG2TuneRequest): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IMPEG2TuneRequestSupport;'} + {$EXTERNALSYM IMPEG2TuneRequestSupport} + IMPEG2TuneRequestSupport = interface(IUnknown) + ['{1B9D5FC3-5BBC-4b6c-BB18-B9D10E3EEEBF}'] + (*** IMPEG2TuneRequestSupport methods ***) + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_ITuner;'} + {$EXTERNALSYM ITuner} + ITuner = interface(IUnknown) + ['{28C52640-018A-11d3-9D8E-00C04F72D980}'] + (*** ITuner methods ***) + function get_TuningSpace(out TuningSpace: ITuningSpace): HResult; stdcall; + function put_TuningSpace(TuningSpace: ITuningSpace): HResult; stdcall; + function EnumTuningSpaces(out ppEnum: IEnumTuningSpaces): HResult; stdcall; + function get_TuneRequest(out TuneRequest: ITuneRequest): HResult; stdcall; + function put_TuneRequest(TuneRequest: ITuneRequest): HResult; stdcall; + function Validate(TuneRequest: ITuneRequest): HResult; stdcall; + function get_PreferredComponentTypes(out ComponentTypes: IComponentTypes): HResult; stdcall; + function put_PreferredComponentTypes(ComponentTypes: IComponentTypes): HResult; stdcall; + function get_SignalStrength(out Strength: longint): HResult; stdcall; + function TriggerSignalEvents(Interval: longint): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IScanningTuner;'} + {$EXTERNALSYM IScanningTuner} + IScanningTuner = interface(ITuner) + ['{1DFD0A5C-0284-11d3-9D8E-00C04F72D980}'] + (*** IScanningTuner methods ***) + function SeekUp: HResult; stdcall; + function SeekDown: HResult; stdcall; + function ScanUp(MillisecondsPause: longint): HResult; stdcall; + function ScanDown(MillisecondsPause: longint): HResult; stdcall; + function AutoProgram: HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IComponentType;'} + {$EXTERNALSYM IComponentType} + IComponentType = interface(IDispatch) + ['{6A340DC0-0311-11d3-9D8E-00C04F72D980}'] + (*** IComponentType methods ***) + function get_Category(out Category: ComponentCategory): HResult; stdcall; + function put_Category(Category: ComponentCategory): HResult; stdcall; + function get_MediaMajorType(out MediaMajorType: WideString): HResult; stdcall; + function put_MediaMajorType(MediaMajorType: WideString): HResult; stdcall; + function get__MediaMajorType(out MediaMajorTypeGuid: TGUID): HResult; stdcall; + function put__MediaMajorType(const MediaMajorTypeGuid: TGUID): HResult; stdcall; + function get_MediaSubType(out MediaSubType: WideString): HResult; stdcall; + function put_MediaSubType(MediaSubType: WideString): HResult; stdcall; + function get__MediaSubType(out MediaSubTypeGuid: TGUID): HResult; stdcall; + function put__MediaSubType(const MediaSubTypeGuid: TGUID): HResult; stdcall; + function get_MediaFormatType(out MediaFormatType: WideString): HResult; stdcall; + function put_MediaFormatType(MediaFormatType: WideString): HResult; stdcall; + function get__MediaFormatType(out MediaFormatTypeGuid: TGUID): HResult; stdcall; + function put__MediaFormatType(const MediaFormatTypeGuid: TGUID): HResult; stdcall; + function get_MediaType(out MediaType: TAMMediaType): HResult; stdcall; + function put_MediaType(MediaType: TAMMediaType): HResult; stdcall; + function Clone(out NewCT: IComponentType): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_ILanguageComponentType;'} + {$EXTERNALSYM ILanguageComponentType} + ILanguageComponentType = interface(IComponentType) + ['{B874C8BA-0FA2-11d3-9D8E-00C04F72D980}'] + (*** ILanguageComponentType methods ***) + function get_LangID(out LangID: longint): HResult; stdcall; + function put_LangID(LangID: longint): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IMPEG2ComponentType;'} + {$EXTERNALSYM IMPEG2ComponentType} + IMPEG2ComponentType = interface(ILanguageComponentType) + ['{2C073D84-B51C-48c9-AA9F-68971E1F6E38}'] + (*** IMPEG2ComponentType methods ***) + function get_StreamType(out MP2StreamType: MPEG2StreamType): HResult; stdcall; + function put_StreamType(MP2StreamType: MPEG2StreamType): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IATSCComponentType;'} + {$EXTERNALSYM IATSCComponentType} + IATSCComponentType = interface(IMPEG2ComponentType) + ['{FC189E4D-7BD4-4125-B3B3-3A76A332CC96}'] + (*** IATSCComponentType methods ***) + function get_Flags(out Flags: longint): HResult; stdcall; + function put_Flags(Flags: longint): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IEnumComponentTypes;'} + {$EXTERNALSYM IEnumComponentTypes} + IEnumComponentTypes = interface(IUnknown) + ['{8A674B4A-1F63-11d3-B64C-00C04F79498E}'] + (*** IEnumComponentTypes methods ***) + function Next(celt: ULONG; out rgelt: IComponentType; out pceltFetched: ULONG): HResult; stdcall; + function Skip(celt: ULONG): HResult; stdcall; + function Reset: HResult; stdcall; + function Clone(out ppEnum: IEnumComponentTypes): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IComponentTypes;'} + {$EXTERNALSYM IComponentTypes} + IComponentTypes = interface(IDispatch) + ['{0DC13D4A-0313-11d3-9D8E-00C04F72D980}'] + (*** IComponentTypes methods ***) + function get_Count(out Count: longint): HResult; stdcall; + function get__NewEnum(out ppNewEnum: IEnumVARIANT): HResult; stdcall; + function EnumComponentTypes(out ppNewEnum: IEnumComponentTypes): HResult; stdcall; + function get_Item(Index: OLEVARIANT; out ComponentType: IComponentType): HResult; stdcall; + function put_Item(Index: OLEVARIANT; ComponentType: IComponentType): HResult; stdcall; + function Add(ComponentType: IComponentType; out NewIndex: OLEVARIANT): HResult; stdcall; + function Remove(Index: OLEVARIANT): HResult; stdcall; + function Clone(out NewList: IComponentTypes): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IComponent;'} + {$EXTERNALSYM IComponent} + IComponent = interface(IDispatch) + ['{1A5576FC-0E19-11d3-9D8E-00C04F72D980}'] + (*** IComponent methods ***) + function get_Type(out CT: IComponentType): HResult; stdcall; + function put_Type(CT: IComponentType): HResult; stdcall; + function get_DescLangID(out LangID: longint): HResult; stdcall; + function put_DescLangID(LangID: longint): HResult; stdcall; + function get_Status(out Status: TComponentStatus): HResult; stdcall; + function put_Status(Status: TComponentStatus): HResult; stdcall; + function get_Description(out Description: WideString): HResult; stdcall; + function put_Description(Description: WideString): HResult; stdcall; + function Clone(out NewComponent: IComponent): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IMPEG2Component;'} + {$EXTERNALSYM IMPEG2Component} + IMPEG2Component = interface(IComponent) + ['{1493E353-1EB6-473c-802D-8E6B8EC9D2A9}'] + (*** IMPEG2Component methods ***) + function get_PID(out PID: longint): HResult; stdcall; + function put_PID(PID: longint): HResult; stdcall; + function get_PCRPID(out PCRPID: longint): HResult; stdcall; + function put_PCRPID(PCRPID: longint): HResult; stdcall; + function get_ProgramNumber(out ProgramNumber: longint): HResult; stdcall; + function put_ProgramNumber(ProgramNumber: longint): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IEnumComponents;'} + {$EXTERNALSYM IEnumComponents} + IEnumComponents = interface(IUnknown) + ['{2A6E2939-2595-11d3-B64C-00C04F79498E}'] + (*** IEnumComponents methods ***) + function Next(celt: ULONG; out rgelt: IComponent; out pceltFetched: ULONG): HResult; stdcall; + function Skip(celt: ULONG): HResult; stdcall; + function Reset: HResult; stdcall; + function Clone(out ppEnum: IEnumComponents): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IComponents;'} + {$EXTERNALSYM IComponents} + IComponents = interface(IDispatch) + ['{FCD01846-0E19-11d3-9D8E-00C04F72D980}'] + (*** IComponents methods ***) + function get_Count(out Count: longint): HResult; stdcall; + function get__NewEnum(out ppNewEnum: IEnumVARIANT): HResult; stdcall; + function EnumComponents(out ppNewEnum: IEnumComponents): HResult; stdcall; + function get_Item(Index: OLEVARIANT; out ppComponent: IComponent): HResult; stdcall; + function Add(Component: IComponent; out NewIndex: OLEVARIANT): HResult; stdcall; + function Remove(Index: OLEVARIANT): HResult; stdcall; + function Clone(out NewList: IComponents): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_ILocator;'} + {$EXTERNALSYM ILocator} + ILocator = interface(IDispatch) + ['{286D7F89-760C-4F89-80C4-66841D2507AA}'] + (*** ILocator methods ***) + function get_CarrierFrequency(out Frequency: longint): HResult; stdcall; + function put_CarrierFrequency(Frequency: longint): HResult; stdcall; + function get_InnerFEC(out FEC: FECMethod): HResult; stdcall; + function put_InnerFEC(FEC: FECMethod): HResult; stdcall; + function get_InnerFECRate(out FEC: BinaryConvolutionCodeRate): HResult; stdcall; + function put_InnerFECRate(FEC: BinaryConvolutionCodeRate): HResult; stdcall; + function get_OuterFEC(out FEC: FECMethod): HResult; stdcall; + function put_OuterFEC(FEC: FECMethod): HResult; stdcall; + function get_OuterFECRate(out FEC: BinaryConvolutionCodeRate): HResult; stdcall; + function put_OuterFECRate(FEC: BinaryConvolutionCodeRate): HResult; stdcall; + function get_Modulation(out Modulation: ModulationType): HResult; stdcall; + function put_Modulation(Modulation: ModulationType): HResult; stdcall; + function get_SymbolRate(out Rate: longint): HResult; stdcall; + function put_SymbolRate(Rate: longint): HResult; stdcall; + function Clone(out NewLocator: ILocator): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IATSCLocator;'} + {$EXTERNALSYM IATSCLocator} + IATSCLocator = interface(ILocator) + ['{BF8D986F-8C2B-4131-94D7-4D3D9FCC21EF}'] + (*** IATSCLocator methods ***) + function get_PhysicalChannel(out PhysicalChannel: longint): HResult; stdcall; + function put_PhysicalChannel(PhysicalChannel: longint): HResult; stdcall; + function get_TSID(out TSID: longint): HResult; stdcall; + function put_TSID(TSID: longint): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IDVBTLocator;'} + {$EXTERNALSYM IDVBTLocator} + IDVBTLocator = interface(ILocator) + ['{8664DA16-DDA2-42ac-926A-C18F9127C302}'] + (*** IDVBTLocator methods ***) + function get_Bandwidth(out BandWidthVal: longint): HResult; stdcall; + function put_Bandwidth(BandwidthVal: longint): HResult; stdcall; + function get_LPInnerFEC(out FEC: FECMethod): HResult; stdcall; + function put_LPInnerFEC(FEC: FECMethod): HResult; stdcall; + function get_LPInnerFECRate(out FEC: BinaryConvolutionCodeRate): HResult; stdcall; + function put_LPInnerFECRate(FEC: BinaryConvolutionCodeRate): HResult; stdcall; + function get_HAlpha(out Alpha: HierarchyAlpha): HResult; stdcall; + function put_HAlpha(Alpha: HierarchyAlpha): HResult; stdcall; + function get_Guard(out GI: GuardInterval): HResult; stdcall; + function put_Guard(GI: GuardInterval): HResult; stdcall; + function get_Mode(out mode: TransmissionMode): HResult; stdcall; + function put_Mode(mode: TransmissionMode): HResult; stdcall; + function get_OtherFrequencyInUse(out OtherFrequencyInUseVal: WordBool): HResult; stdcall; + function put_OtherFrequencyInUse(OtherFrequencyInUseVal: WordBool): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IDVBSLocator;'} + {$EXTERNALSYM IDVBSLocator} + IDVBSLocator = interface(ILocator) + ['{3D7C353C-0D04-45f1-A742-F97CC1188DC8}'] + (*** IDVBSLocator methods ***) + function get_SignalPolarisation(out PolarisationVal: Polarisation): HResult; stdcall; + function put_SignalPolarisation(PolarisationVal: Polarisation): HResult; stdcall; + function get_WestPosition(out WestLongitude: WordBool): HResult; stdcall; + function put_WestPosition(WestLongitude: WordBool): HResult; stdcall; + function get_OrbitalPosition(out longitude: longint): HResult; stdcall; + function put_OrbitalPosition(longitude: longint): HResult; stdcall; + function get_Azimuth(out Azimuth: longint): HResult; stdcall; + function put_Azimuth(Azimuth: longint): HResult; stdcall; + function get_Elevation(out Elevation: longint): HResult; stdcall; + function put_Elevation(Elevation: longint): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IDVBCLocator;'} + {$EXTERNALSYM IDVBCLocator} + IDVBCLocator = interface(ILocator) + ['{6E42F36E-1DD2-43c4-9F78-69D25AE39034}'] + (*** IDVBCLocator methods ***) + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IBroadcastEvent;'} + {$EXTERNALSYM IBroadcastEvent} + IBroadcastEvent = interface(IUnknown) + ['{3B21263F-26E8-489d-AAC4-924F7EFD9511}'] + (*** IBroadcastEvent methods ***) + function Fire(EventID: TGUID): HResult; stdcall; + end; + +//------------------------------------------------------------------------------ +// File: DXTrans.h +// Desc: DirectX Transform library +// Copyright (c) 1999 - 2000, Microsoft Corporation. All rights reserved. +//------------------------------------------------------------------------------ + +const + LIBID_DXTRANSLib : TGUID = '{54314D1D-35FE-11D1-81A1-0000F87557DB}'; + {$EXTERNALSYM LIBID_DXTRANSLib} + + IID_IDXBaseObject : TGUID = '{17B59B2B-9CC8-11D1-9053-00C04FD9189D}'; + {$EXTERNALSYM IID_IDXBaseObject} + IID_IDXTransformFactory : TGUID = '{6A950B2B-A971-11D1-81C8-0000F87557DB}'; + {$EXTERNALSYM IID_IDXTransformFactory} + IID_IDXTransform : TGUID = '{30A5FB78-E11F-11D1-9064-00C04FD9189D}'; + {$EXTERNALSYM IID_IDXTransform} + IID_IDXSurfacePick : TGUID = '{30A5FB79-E11F-11d1-9064-00C04FD9189D}'; + {$EXTERNALSYM IID_IDXSurfacePick} + IID_IDXTBindHost : TGUID = '{D26BCE55-E9DC-11d1-9066-00C04FD9189D}'; + {$EXTERNALSYM IID_IDXTBindHost} + IID_IDXTaskManager : TGUID = '{254DBBC1-F922-11D0-883A-3C8B00C10000}'; + {$EXTERNALSYM IID_IDXTaskManager} + IID_IDXSurfaceFactory : TGUID = '{144946F5-C4D4-11D1-81D1-0000F87557DB}'; + {$EXTERNALSYM IID_IDXSurfaceFactory} + IID_IDXSurfaceModifier : TGUID = '{9EA3B637-C37D-11D1-905E-00C04FD9189D}'; + {$EXTERNALSYM IID_IDXSurfaceModifier} + IID_IDXSurface : TGUID = '{B39FD73F-E139-11D1-9065-00C04FD9189D}'; + {$EXTERNALSYM IID_IDXSurface} + IID_IDXSurfaceInit : TGUID = '{9EA3B639-C37D-11d1-905E-00C04FD9189D}'; + {$EXTERNALSYM IID_IDXSurfaceInit} + IID_IDXARGBSurfaceInit : TGUID = '{9EA3B63A-C37D-11d1-905E-00C04FD9189D}'; + {$EXTERNALSYM IID_IDXARGBSurfaceInit} + IID_IDXARGBReadPtr : TGUID = '{EAAAC2D6-C290-11d1-905D-00C04FD9189D}'; + {$EXTERNALSYM IID_IDXARGBReadPtr} + IID_IDXARGBReadWritePtr : TGUID = '{EAAAC2D7-C290-11d1-905D-00C04FD9189D}'; + {$EXTERNALSYM IID_IDXARGBReadWritePtr} + IID_IDXDCLock : TGUID = '{0F619456-CF39-11D1-905E-00C04FD9189D}'; + {$EXTERNALSYM IID_IDXDCLock} + IID_IDXTScaleOutput : TGUID = '{B2024B50-EE77-11D1-9066-00C04FD9189D}'; + {$EXTERNALSYM IID_IDXTScaleOutput} + IID_IDXGradient : TGUID = '{B2024B51-EE77-11D1-9066-00C04FD9189D}'; + {$EXTERNALSYM IID_IDXGradient} + IID_IDXTScale : TGUID = '{B39FD742-E139-11D1-9065-00C04FD9189D}'; + {$EXTERNALSYM IID_IDXTScale} + IID_IDXEffect : TGUID = '{E31FB81B-1335-11d1-8189-0000F87557DB}'; + {$EXTERNALSYM IID_IDXEffect} + IID_IDXLookupTable : TGUID = '{01BAFC7F-9E63-11D1-9053-00C04FD9189D}'; + {$EXTERNALSYM IID_IDXLookupTable} + IID_IDXRawSurface : TGUID = '{09756C8A-D96A-11d1-9062-00C04FD9189D}'; + {$EXTERNALSYM IID_IDXRawSurface} + IID_IHTMLDXTransform : TGUID = '{30E2AB7D-4FDD-4159-B7EA-DC722BF4ADE5}'; + {$EXTERNALSYM IID_IHTMLDXTransform} + + CLSID_DXTransformFactory : TGUID = '{D1FE6762-FC48-11D0-883A-3C8B00C10000}'; + {$EXTERNALSYM CLSID_DXTransformFactory} + CLSID_DXTaskManager : TGUID = '{4CB26C03-FF93-11D0-817E-0000F87557DB}'; + {$EXTERNALSYM CLSID_DXTaskManager} + CLSID_DXTScale : TGUID = '{555278E2-05DB-11D1-883A-3C8B00C10000}'; + {$EXTERNALSYM CLSID_DXTScale} + CLSID_DXSurface : TGUID = '{0E890F83-5F79-11D1-9043-00C04FD9189D}'; + {$EXTERNALSYM CLSID_DXSurface} + CLSID_DXSurfaceModifier : TGUID = '{3E669F1D-9C23-11D1-9053-00C04FD9189D}'; + {$EXTERNALSYM CLSID_DXSurfaceModifier} + CLSID_DXGradient : TGUID = '{C6365470-F667-11D1-9067-00C04FD9189D}'; + {$EXTERNALSYM CLSID_DXGradient} + + +// +// Pixel format definitions +// + DDPF_RGB1 : TGUID = '{e436eb78-524f-11ce-9f53-0020af0ba770}'; + {$EXTERNALSYM DDPF_RGB1} + DDPF_RGB2 : TGUID = '{BBF7D3F3-143F-11d1-B50A-0000F8756A10}'; + {$EXTERNALSYM DDPF_RGB2} + DDPF_RGB4 : TGUID = '{e436eb79-524f-11ce-9f53-0020af0ba770}'; + {$EXTERNALSYM DDPF_RGB4} + DDPF_RGB8 : TGUID = '{e436eb7a-524f-11ce-9f53-0020af0ba770}'; + {$EXTERNALSYM DDPF_RGB8} + DDPF_RGB332 : TGUID = '{BBF7D3F6-143F-11d1-B50A-0000F8756A10}'; + {$EXTERNALSYM DDPF_RGB332} + DDPF_ARGB4444 : TGUID = '{BBF7D3F7-143F-11d1-B50A-0000F8756A10}'; + {$EXTERNALSYM DDPF_ARGB4444} + DDPF_RGB565 : TGUID = '{e436eb7b-524f-11ce-9f53-0020af0ba770}'; + {$EXTERNALSYM DDPF_RGB565} + DDPF_BGR565 : TGUID = '{BBF7D3F9-143F-11d1-B50A-0000F8756A10}'; + {$EXTERNALSYM DDPF_BGR565} + DDPF_RGB555 : TGUID = '{e436eb7c-524f-11ce-9f53-0020af0ba770}'; + {$EXTERNALSYM DDPF_RGB555} + DDPF_ARGB1555 : TGUID = '{BBF7D3FB-143F-11d1-B50A-0000F8756A10}'; + {$EXTERNALSYM DDPF_ARGB1555} + DDPF_RGB24 : TGUID = '{e436eb7d-524f-11ce-9f53-0020af0ba770}'; + {$EXTERNALSYM DDPF_RGB24} + DDPF_BGR24 : TGUID = '{BBF7D3FD-143F-11d1-B50A-0000F8756A10}'; + {$EXTERNALSYM DDPF_BGR24} + DDPF_RGB32 : TGUID = '{e436eb7e-524f-11ce-9f53-0020af0ba770}'; + {$EXTERNALSYM DDPF_RGB32} + DDPF_BGR32 : TGUID = '{BBF7D3FF-143F-11d1-B50A-0000F8756A10}'; + {$EXTERNALSYM DDPF_BGR32} + DDPF_ABGR32 : TGUID = '{BBF7D401-143F-11d1-B50A-0000F8756A10}'; + {$EXTERNALSYM DDPF_ABGR32} + DDPF_ARGB32 : TGUID = '{773c9ac0-3274-11d0-B724-00aa006c1A01}'; + {$EXTERNALSYM DDPF_ARGB32} + DDPF_PMARGB32 : TGUID = '{BBF7D403-143F-11d1-B50A-0000F8756A10}'; + {$EXTERNALSYM DDPF_PMARGB32} + DDPF_A1 : TGUID = '{7846F94E-3915-11d1-99AA-0000F8756A10}'; + {$EXTERNALSYM DDPF_A1} + DDPF_A2 : TGUID = '{7846F94F-3915-11d1-99AA-0000F8756A10}'; + {$EXTERNALSYM DDPF_A2} + DDPF_A4 : TGUID = '{7846F950-3915-11d1-99AA-0000F8756A10}'; + {$EXTERNALSYM DDPF_A4} + DDPF_A8 : TGUID = '{7846F951-3915-11d1-99AA-0000F8756A10}'; + {$EXTERNALSYM DDPF_A8} + DDPF_Z8 : TGUID = '{7846F952-3915-11d1-99AA-0000F8756A10}'; + {$EXTERNALSYM DDPF_Z8} + DDPF_Z16 : TGUID = '{7846F953-3915-11d1-99AA-0000F8756A10}'; + {$EXTERNALSYM DDPF_Z16} + DDPF_Z24 : TGUID = '{7846F954-3915-11d1-99AA-0000F8756A10}'; + {$EXTERNALSYM DDPF_Z24} + DDPF_Z32 : TGUID = '{7846F955-3915-11d1-99AA-0000F8756A10}'; + {$EXTERNALSYM DDPF_Z32} +// +// Component categories +// + CATID_DXImageTransform : TGUID = '{C501EDBE-9E70-11d1-9053-00C04FD9189D}'; + {$EXTERNALSYM CATID_DXImageTransform} + CATID_DX3DTransform : TGUID = '{C501EDBF-9E70-11d1-9053-00C04FD9189D}'; + {$EXTERNALSYM CATID_DX3DTransform} + CATID_DXAuthoringTransform : TGUID = '{ACAC94FC-E5CF-11d1-9066-00C04FD9189D}'; + {$EXTERNALSYM CATID_DXAuthoringTransform} + CATID_DXSurface : TGUID = '{52BA7097-B52C-11d1-81CB-0000F87557DB}'; + {$EXTERNALSYM CATID_DXSurface} + +// +// Service IDs. +// + SID_SDirectDraw : TGUID = (D1:$618f8ad4;D2:$8b7a;D3:$11d0;D4:($8f,$cc,$0,$c0,$4f,$d9,$18,$9d)); + {$EXTERNALSYM SID_SDirectDraw} + SID_SDirect3DRM : TGUID = (D1:$2bc49361;D2:$8327;D3:$11cf;D4:($ac,$4a,$0,$0,$c0,$38,$25,$a1)); + {$EXTERNALSYM SID_SDirect3DRM} + SID_SDXTaskManager : TGUID = '{4CB26C03-FF93-11D0-817E-0000F87557DB}'; + {$EXTERNALSYM SID_SDXTaskManager} + SID_SDXSurfaceFactory : TGUID = '{144946F5-C4D4-11D1-81D1-0000F87557DB}'; + {$EXTERNALSYM SID_SDXSurfaceFactory} + SID_SDXTransformFactory : TGUID = '{6A950B2B-A971-11D1-81C8-0000F87557DB}'; + {$EXTERNALSYM SID_SDXTransformFactory} + +type + {$HPPEMIT 'typedef System::DelphiInterface _di_IDXBaseObject;'} + {$EXTERNALSYM IDXBaseObject} + IDXBaseObject = interface(IUnknown) + ['{17B59B2B-9CC8-11D1-9053-00C04FD9189D}'] + (*** IDXBaseObject methods ***) + function GetGenerationId(out pID: ULONG): HResult; stdcall; + function IncrementGenerationId(bRefresh: BOOL): HResult; stdcall; + function GetObjectSize(out pcbSize: ULONG): HResult; stdcall; + end; + + DXBNDID = ( + DXB_X, + DXB_Y, + DXB_Z, + DXB_T + ); + {$EXTERNALSYM DXBNDID} + TDXBNDID = DXBNDID; + + DXBNDTYPE = ( + DXBT_DISCRETE, + DXBT_DISCRETE64, + DXBT_CONTINUOUS, + DXBT_CONTINUOUS64 + ); + {$EXTERNALSYM DXBNDTYPE} + TDXBNDType = DXBNDTYPE; + + DXDBND = record + Min: longint; + Max: longint; + end; + {$EXTERNALSYM DXDBND} + TDXDBND = DXDBND; + + DXDBNDS = array[0..3] of TDXDBND; + {$EXTERNALSYM DXDBNDS} + + DXDBND64 = record + Min: int64; + Max: int64; + end; + {$EXTERNALSYM DXDBND64} + TDXDBND64 = DXDBND64; + + DXDBNDS64 = array [0..3] of TDXDBND64; + {$EXTERNALSYM DXDBNDS64} + + DXCBND = record + {$EXTERNALSYM DXCBND} + Min: single; + Max: single; + end; + TDXCBND = DXCBND; + + DXCBNDS = array[0..3] of TDXCBND; + {$EXTERNALSYM DXCBNDS} + + DXCBND64 = record + Min: double; + Max: double; + end; + {$EXTERNALSYM DXCBND64} + TDXCBND64 = DXCBND64; + + DXCBNDS64 = array[0..3] of TDXCBND64; + {$EXTERNALSYM DXCBNDS64} + + DXBNDS = record + {$EXTERNALSYM DXBNDS} + eType: TDXBNDTYPE; + case Integer of + 0: (D: array[0..3] of TDXDBND); + 1: (LD: array[0..3] of TDXDBND64); + 2: (C: array[0..3] of TDXCBND); + 3: (LC: array[0..3] of TDXCBND64); + end; + TDXBNDS = DXBNDS; + + DXDVEC = array[0..3] of longint; + {$EXTERNALSYM DXDVEC} + + DXDVEC64 = array[0..3] of int64; + {$EXTERNALSYM DXDVEC64} + + DXCVEC = array[0..3] of single; + {$EXTERNALSYM DXCVEC} + + DXCVEC64 = array[0..3] of double; + {$EXTERNALSYM DXCVEC64} + + DXVEC = record + eType: TDXBNDTYPE; + case Integer of + 0: (D: array[0..3] of Longint); + 1: (LD: array[0..3] of Int64); + 2: (C: array[0..3] of Single); + 3: (LC: array[0..3] of Double); + end; + {$EXTERNALSYM DXVEC} + TDXVEC = DXVEC; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IDXTransform;'} + {$EXTERNALSYM IDXTransform} + IDXTransform = interface(IDXBaseObject) + ['{30A5FB78-E11F-11D1-9064-00C04FD9189D}'] + (*** IDXTransform methods ***) + function Setup(punkInputs: IUnknown; ulNumInputs: ULONG; punkOutputs: IUnknown; + ulNumOutputs: ULONG; dwFlags: DWORD): HResult; stdcall; + function Execute(const pRequestID: TGUID; var pClipBnds: TDXBNDS; var pPlacement: TDXVEC): HResult; stdcall; + function MapBoundsIn2Out(var pInBounds: TDXBNDS; ulNumInBnds: ULONG; ulOutIndex: ULONG; + out pOutBounds: TDXBNDS): HResult; stdcall; + function MapBoundsOut2In(ulOutIndex: ULONG; var pOutBounds: TDXBNDS; ulInIndex: ULONG; + out pInBounds: TDXBNDS): HResult; stdcall; + function SetMiscFlags(dwMiscFlags: DWORD): HResult; stdcall; + function GetMiscFlags(out pdwMiscFlags: DWORD): HResult; stdcall; + function GetInOutInfo(bIsOutput: BOOL; ulIndex: ULONG; out pdwFlags: DWORD; + out pIDs: TGUID; var pcIDs: ULONG; out ppUnkCurrentObject: IUnknown): HResult; stdcall; + function SetQuality(fQuality: Single): HResult; stdcall; + function GetQuality(out fQuality: Single): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IDXTransformFactory;'} + {$EXTERNALSYM IDXTransformFactory} + IDXTransformFactory = interface(IServiceProvider) + ['{6A950B2B-A971-11D1-81C8-0000F87557DB}'] + (*** IDXTransformFactory methods ***) + function SetService(const guidService: TGUID; pUnkService: IUnknown; + bWeakReference: BOOL): HResult; stdcall; + function CreateTransform(punkInputs: IUnknown; ulNumInputs: ULONG; + punkOutputs: IUnknown; ulNumOutputs: ULONG; + pInitProps: IPropertyBag; pErrLog: IErrorLog; + const TransCLSID: TGUID; const TransIID: TGUID; out ppTransform: Pointer): HResult; stdcall; + function InitializeTransform(pTransform: IDXTransform; punkInputs: IUnknown; + ulNumInputs: ULONG; punkOutputs: IUnknown; + ulNumOutputs: ULONG; pInitProps: IPropertyBag; + pErrLog: IErrorLog): HResult; stdcall; + end; + + + DXTMISCFLAGS = {$IFDEF TYPE_IDENTITY}type {$ENDIF} LongWord; + {$EXTERNALSYM DXTMISCFLAGS} + const + DXTMF_BLEND_WITH_OUTPUT = 1 shl 0; + {$EXTERNALSYM DXTMF_BLEND_WITH_OUTPUT} + DXTMF_DITHER_OUTPUT = 1 shl 1; + {$EXTERNALSYM DXTMF_DITHER_OUTPUT} + DXTMF_OPTION_MASK = $ffff; + {$EXTERNALSYM DXTMF_OPTION_MASK} + DXTMF_VALID_OPTIONS = DXTMF_BLEND_WITH_OUTPUT or DXTMF_DITHER_OUTPUT; + {$EXTERNALSYM DXTMF_VALID_OPTIONS} + DXTMF_BLEND_SUPPORTED = 1 shl 16; + {$EXTERNALSYM DXTMF_BLEND_SUPPORTED} + DXTMF_DITHER_SUPPORTED = 1 shl 17; + {$EXTERNALSYM DXTMF_DITHER_SUPPORTED} + DXTMF_INPLACE_OPERATION = 1 shl 24; + {$EXTERNALSYM DXTMF_INPLACE_OPERATION} + DXTMF_BOUNDS_SUPPORTED = 1 shl 25; + {$EXTERNALSYM DXTMF_BOUNDS_SUPPORTED} + DXTMF_PLACEMENT_SUPPORTED= 1 shl 26; + {$EXTERNALSYM DXTMF_PLACEMENT_SUPPORTED} + DXTMF_QUALITY_SUPPORTED = 1 shl 27; + {$EXTERNALSYM DXTMF_QUALITY_SUPPORTED} + DXTMF_OPAQUE_RESULT = 1 shl 28; + {$EXTERNALSYM DXTMF_OPAQUE_RESULT} + +type + DXINOUTINFOFLAGS = {$IFDEF TYPE_IDENTITY}type {$ENDIF} LongWord; + {$EXTERNALSYM DXINOUTINFOFLAGS} + const + DXINOUTF_OPTIONAL = 1 shl 0; + {$EXTERNALSYM DXINOUTF_OPTIONAL} + +type + {$HPPEMIT 'typedef System::DelphiInterface _di_IDXSurfacePick;'} + {$EXTERNALSYM IDXSurfacePick} + IDXSurfacePick = interface(IUnknown) + ['{30A5FB79-E11F-11d1-9064-00C04FD9189D}'] + (*** IDXSurfacePick methods ***) + function PointPick(var pPoint: TDXVEC; out pulInputSurfaceIndex: ULONG; + out pInputPoint: TDXVEC): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IDXTBindHost;'} + {$EXTERNALSYM IDXTBindHost} + IDXTBindHost = interface(IUnknown) + ['{D26BCE55-E9DC-11d1-9066-00C04FD9189D}'] + (*** IDXTBindHost methods ***) + function SetBindHost(pBindHost: IBindHost): HResult; stdcall; + end; + + DXTASKPROC = procedure(var pTaskData: pointer; var pbContinueProcessing: BOOL); stdcall; + {$EXTERNALSYM DXTASKPROC} + PFNDXTASKPROC = ^DXTASKPROC; + {$EXTERNALSYM PFNDXTASKPROC} + + DXAPCPROC = procedure(dwData: DWORD);stdcall; + {$EXTERNALSYM DXAPCPROC} + PFNDXAPCPROC = ^DXAPCPROC; + {$EXTERNALSYM PFNDXAPCPROC} + + DXTMTASKINFO = record + pfnTaskProc: PFNDXTASKPROC; + pTaskData: Pointer; + pfnCompletionAPC: PFNDXAPCPROC; + dwCompletionData: DWORD; + pRequestID: PGUID; + end; + {$EXTERNALSYM DXTMTASKINFO} + TDXTMTaskInfo = DXTMTASKINFO; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IDXTaskManager;'} + {$EXTERNALSYM IDXTaskManager} + IDXTaskManager = interface(IUnknown) + ['{254DBBC1-F922-11D0-883A-3C8B00C10000}'] + (*** IDXTaskManager methods ***) + function QueryNumProcessors(out pulNumProc: ULONG): HResult; stdcall; + function SetThreadPoolSize(ulNumThreads: ULONG): HResult; stdcall; + function GetThreadPoolSize(out pulNumThreads: ULONG): HResult; stdcall; + function SetConcurrencyLimit(ulNumThreads: ULONG): HResult; stdcall; + function GetConcurrencyLimit(out pulNumThreads: ULONG): HResult; stdcall; + function ScheduleTasks(var TaskInfo: TDXTMTASKINFO; Events: PHANDLE; + out TaskIDs: DWORD; ulNumTasks: ULONG; ulWaitPeriod: ULONG): HResult; stdcall; + function TerminateTasks(var TaskIDs: DWORD; ulCount: ULONG; ulTimeOut: ULONG): HResult; stdcall; + function TerminateRequest(const RequestID: TGUID; ulTimeOut: ULONG): HResult; stdcall; + end; + + DXBASESAMPLE = record + Blue : Byte; + Green : Byte; + Red : Byte; + Alpha : Byte; + end; + {$EXTERNALSYM DXBASESAMPLE} + TDXBaseSample = DXBASESAMPLE; + + DXSAMPLE = record + Blue : Byte; + Green : Byte; + Red : Byte; + Alpha : Byte; + end; + {$EXTERNALSYM DXSAMPLE} + TDXSample = DXSAMPLE; + + DXPMSAMPLE = record + Blue : Byte; + Green : Byte; + Red : Byte; + Alpha : Byte; + end; + {$EXTERNALSYM DXPMSAMPLE} + TDXPMSample = DXPMSAMPLE; + + DXRUNTYPE = ( + DXRUNTYPE_CLEAR, + DXRUNTYPE_OPAQUE, + DXRUNTYPE_TRANS, + DXRUNTYPE_UNKNOWN + ); + {$EXTERNALSYM DXRUNTYPE} + TDXRunType = DXRUNTYPE; + +const + DX_MAX_RUN_INFO_COUNT = 128; + {$EXTERNALSYM DX_MAX_RUN_INFO_COUNT} + +type +// 2 : Type ; // Type +// 30 : Count ; // Number of samples in run + PDXRunInfo = ^TDXRunInfo; + DXRUNINFO = record + Bitfields : ULONG; + end; + {$EXTERNALSYM DXRUNINFO} + TDXRunInfo = DXRUNINFO; + + DXSFCREATE = {$IFDEF TYPE_IDENTITY}type {$ENDIF} LongWord; + {$EXTERNALSYM DXSFCREATE} + const + DXSF_FORMAT_IS_CLSID = 1 shl 0; + {$EXTERNALSYM DXSF_FORMAT_IS_CLSID} + DXSF_NO_LAZY_DDRAW_LOCK = 1 shl 1; + {$EXTERNALSYM DXSF_NO_LAZY_DDRAW_LOCK} + +type + DXBLTOPTIONS = {$IFDEF TYPE_IDENTITY}type {$ENDIF} LongWord; + {$EXTERNALSYM DXBLTOPTIONS} + const + DXBOF_DO_OVER = 1 shl 0; + {$EXTERNALSYM DXBOF_DO_OVER} + DXBOF_DITHER = 1 shl 1; + {$EXTERNALSYM DXBOF_DITHER} + +type + DXSAMPLEFORMATENUM = {$IFDEF TYPE_IDENTITY}type {$ENDIF} LongWord; + {$EXTERNALSYM DXSAMPLEFORMATENUM} + const + DXPF_FLAGSMASK = $FFFF0000; + {$EXTERNALSYM DXPF_FLAGSMASK} + DXPF_NONPREMULT = $00010000; + {$EXTERNALSYM DXPF_NONPREMULT} + DXPF_TRANSPARENCY = $00020000; + {$EXTERNALSYM DXPF_TRANSPARENCY} + DXPF_TRANSLUCENCY = $00040000; + {$EXTERNALSYM DXPF_TRANSLUCENCY} + DXPF_2BITERROR = $00200000; + {$EXTERNALSYM DXPF_2BITERROR} + DXPF_3BITERROR = $00300000; + {$EXTERNALSYM DXPF_3BITERROR} + DXPF_4BITERROR = $00400000; + {$EXTERNALSYM DXPF_4BITERROR} + DXPF_5BITERROR = $00500000; + {$EXTERNALSYM DXPF_5BITERROR} + DXPF_ERRORMASK = $00700000; + {$EXTERNALSYM DXPF_ERRORMASK} + DXPF_NONSTANDARD = $00000000; + {$EXTERNALSYM DXPF_NONSTANDARD} + DXPF_PMARGB32 = $00060001; + {$EXTERNALSYM DXPF_PMARGB32} + DXPF_ARGB32 = $00070002; + {$EXTERNALSYM DXPF_ARGB32} + DXPF_ARGB4444 = $00470003; + {$EXTERNALSYM DXPF_ARGB4444} + DXPF_A8 = $00060004; + {$EXTERNALSYM DXPF_A8} + DXPF_RGB32 = $00000005; + {$EXTERNALSYM DXPF_RGB32} + DXPF_RGB24 = $00000006; + {$EXTERNALSYM DXPF_RGB24} + DXPF_RGB565 = $00300007; + {$EXTERNALSYM DXPF_RGB565} + DXPF_RGB555 = $00300008; + {$EXTERNALSYM DXPF_RGB555} + DXPF_RGB8 = $00500009; + {$EXTERNALSYM DXPF_RGB8} + DXPF_ARGB1555 = $0032000A; + {$EXTERNALSYM DXPF_ARGB1555} + DXPF_RGB32_CK = $00020005; + {$EXTERNALSYM DXPF_RGB32_CK} + DXPF_RGB24_CK = $00020006; + {$EXTERNALSYM DXPF_RGB24_CK} + DXPF_RGB555_CK = $00320008; + {$EXTERNALSYM DXPF_RGB555_CK} + DXPF_RGB565_CK = $00320007; + {$EXTERNALSYM DXPF_RGB565_CK} + DXPF_RGB8_CK = $00520009; + {$EXTERNALSYM DXPF_RGB8_CK} + +type + DXLOCKSURF = {$IFDEF TYPE_IDENTITY}type {$ENDIF} LongWord; + {$EXTERNALSYM DXLOCKSURF} + const + DXLOCKF_READ = 0; + {$EXTERNALSYM DXLOCKF_READ} + DXLOCKF_READWRITE = 1 shl 0; + {$EXTERNALSYM DXLOCKF_READWRITE} + DXLOCKF_EXISTINGINFOONLY = 1 shl 1; + {$EXTERNALSYM DXLOCKF_EXISTINGINFOONLY} + DXLOCKF_WANTRUNINFO = 1 shl 2; + {$EXTERNALSYM DXLOCKF_WANTRUNINFO} + DXLOCKF_NONPREMULT = 1 shl 16; + {$EXTERNALSYM DXLOCKF_NONPREMULT} + DXLOCKF_VALIDFLAGS = (DXLOCKF_READWRITE or DXLOCKF_EXISTINGINFOONLY or DXLOCKF_WANTRUNINFO or DXLOCKF_NONPREMULT); + {$EXTERNALSYM DXLOCKF_VALIDFLAGS} + +Type + DXSURFSTATUS = {$IFDEF TYPE_IDENTITY}type {$ENDIF} LongWord; + {$EXTERNALSYM DXSURFSTATUS} + const + DXSURF_TRANSIENT = 1 shl 0; + {$EXTERNALSYM DXSURF_TRANSIENT} + DXSURF_READONLY = 1 shl 1; + {$EXTERNALSYM DXSURF_READONLY} + DXSURF_VALIDFLAGS = (DXSURF_TRANSIENT or DXSURF_READONLY); + {$EXTERNALSYM DXSURF_VALIDFLAGS} + +type + {$HPPEMIT 'typedef System::DelphiInterface _di_IDXDCLock;'} + {$EXTERNALSYM IDXDCLock} + IDXDCLock = interface(IUnknown) + ['{0F619456-CF39-11D1-905E-00C04FD9189D}'] + (*** IDXDCLock methods ***) + function GetDC: HDC; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IDXSurface;'} + {$EXTERNALSYM IDXSurface} + IDXSurface = interface(IDXBaseObject) + ['{B39FD73F-E139-11D1-9065-00C04FD9189D}'] + (*** IDXSurface methods ***) + function GetPixelFormat(out pFormatID: TGUID; out pSampleFormatEnum: DXSAMPLEFORMATENUM): HResult; stdcall; + function GetBounds(out pBounds: TDXBNDS): HResult; stdcall; + function GetStatusFlags(out pdwStatusFlags: DWORD): HResult; stdcall; + function SetStatusFlags(dwStatusFlags: DWORD): HResult; stdcall; + function LockSurface(var pBounds: TDXBNDS; ulTimeOut: ULONG; dwFlags: DWORD; + const riid: TGUID; out ppPointer: Pointer; out pulGenerationId: ULONG): HResult; stdcall; + function GetDirectDrawSurface(const riid: TGUID; out ppSurface: Pointer): HResult; stdcall; + function GetColorKey(var pColorKey: TDXSAMPLE): HResult; stdcall; + function SetColorKey(ColorKey: TDXSAMPLE): HResult; stdcall; + function LockSurfaceDC(var pBounds: TDXBNDS; ulTimeOut: ULONG; dwFlags: DWORD; + out ppDCLock: IDXDCLock): HResult; stdcall; + function SetAppData(dwAppData: DWORD): HResult; stdcall; + function GetAppData(var pdwAppData: DWORD): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IDXSurfaceFactory;'} + {$EXTERNALSYM IDXSurfaceFactory} + IDXSurfaceFactory = interface(IUnknown) + ['{144946F5-C4D4-11D1-81D1-0000F87557DB}'] + (*** IDXSurfaceFactory methods ***) + function CreateSurface(pDirectDraw: IUnknown; var pDDSurfaceDesc: PDDSurfaceDesc; + const pFormatID: TGUID; var pBounds: TDXBNDS; dwFlags: DWORD; + punkOuter: IUnknown; const riid: TGUID; out ppDXSurface: Pointer): HResult; stdcall; + function CreateFromDDSurface(pDDrawSurface: IUnknown; const pFormatID: TGUID; + dwFlags: DWORD; punkOuter: IUnknown; const riid: TGUID; + out ppDXSurface: Pointer): HResult; stdcall; + function LoadImage(pszFileName: PWideChar; pDirectDraw: IUnknown; + pDDSurfaceDesc: PDDSURFACEDESC; const pFormatID: TGUID; const riid: TGUID; + out ppDXSurface: Pointer): HResult; stdcall; + function LoadImageFromStream(pStream: IStream; pDirectDraw: IUnknown; + pDDSurfaceDesc: PDDSURFACEDESC; const pFormatID: TGUID; + const riid: TGUID; out ppDXSurface: Pointer): HResult; stdcall; + function CopySurfaceToNewFormat(pSrc: IDXSurface; pDirectDraw: IUnknown; + pDDSurfaceDesc: PDDSURFACEDESC; const pDestFormatID: TGUID; + out ppNewSurface: IDXSurface): HResult; stdcall; + function CreateD3DRMTexture(pSrc: IDXSurface; pDirectDraw: IUnknown; + pD3DRM3: IUnknown; const riid: TGUID; out ppTexture3: Pointer): HResult; stdcall; + function BitBlt(pDest: IDXSurface; var pPlacement: TDXVEC; pSrc: IDXSurface; + var pClipBounds: TDXBNDS; dwFlags: DWORD): HResult; stdcall; + end; + + //convenient type declaration for IDXLookupTable + LUT = array[0..255] of Byte; + {$EXTERNALSYM LUT} + + {$HPPEMIT 'typedef System::DelphiInterface _di_IDXLookupTable;'} + {$EXTERNALSYM IDXLookupTable} + IDXLookupTable = interface(IDXBaseObject) + ['{01BAFC7F-9E63-11D1-9053-00C04FD9189D}'] + (*** IDXLookupTable methods ***) + function GetTables(RedLUT: LUT; GreenLUT: LUT; BlueLUT: LUT; AlphaLUT: LUT): HResult; stdcall; + function IsChannelIdentity(out pSampleBools: TDXBASESAMPLE): HResult; stdcall; + function GetIndexValues(Index: ULONG; out pSample: TDXBASESAMPLE): HResult; stdcall; + function ApplyTables(var pSamples: TDXSAMPLE; cSamples: ULONG): HResult; stdcall; + end; + + DXSURFMODCOMPOP = {$IFDEF TYPE_IDENTITY}type {$ENDIF} LongWord; + {$EXTERNALSYM DXSURFMODCOMPOP} + const + DXSURFMOD_COMP_OVER = 0; + {$EXTERNALSYM DXSURFMOD_COMP_OVER} + DXSURFMOD_COMP_ALPHA_MASK = 1; + {$EXTERNALSYM DXSURFMOD_COMP_ALPHA_MASK} + DXSURFMOD_COMP_MAX_VALID = 1; + {$EXTERNALSYM DXSURFMOD_COMP_MAX_VALID} + +type + {$HPPEMIT 'typedef System::DelphiInterface _di_IDXSurfaceModifier;'} + {$EXTERNALSYM IDXSurfaceModifier} + IDXSurfaceModifier = interface(IUnknown) + ['{9EA3B637-C37D-11D1-905E-00C04FD9189D}'] + (*** IDXSurfaceModifier methods ***) + function SetFillColor(Color: TDXSAMPLE): HResult; stdcall; + function GetFillColor(out pColor: TDXSAMPLE): HResult; stdcall; + function SetBounds(var pBounds: TDXBNDS): HResult; stdcall; + function SetBackground(pSurface: IDXSurface): HResult; stdcall; + function GetBackground(out ppSurface: IDXSurface): HResult; stdcall; + function SetCompositeOperation(CompOp: DXSURFMODCOMPOP): HResult; stdcall; + function GetCompositeOperation(out pCompOp: DXSURFMODCOMPOP): HResult; stdcall; + function SetForeground(pSurface: IDXSurface; bTile: BOOL; var pOrigin: TPOINT): HResult; stdcall; + function GetForeground(out ppSurface: IDXSurface; out pbTile: BOOL; out pOrigin: TPOINT): HResult; stdcall; + function SetOpacity(Opacity: Single): HResult; stdcall; + function GetOpacity(out pOpacity: Single): HResult; stdcall; + function SetLookup(pLookupTable: IDXLookupTable): HResult; stdcall; + function GetLookup(out ppLookupTable: IDXLookupTable): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IDXSurfaceInit;'} + {$EXTERNALSYM IDXSurfaceInit} + IDXSurfaceInit = interface(IUnknown) + ['{9EA3B639-C37D-11d1-905E-00C04FD9189D}'] + (*** IDXSurfaceInit methods ***) + function InitSurface(pDirectDraw: IUnknown; var pDDSurfaceDesc: TDDSURFACEDESC; + const pFormatID: TGUID; var pBounds: TDXBNDS; dwFlags: DWORD): HResult; stdcall; + end; + + DXRAWSURFACEINFO = record + pFirstByte : PBYTE; + lPitch : LongInt; + Width : ULONG; + Height : ULONG; + pPixelFormat : PGUID; + hdc : HDC; + dwColorKey : DWORD; + pPalette : ^TDXBASESAMPLE; + end; + {$EXTERNALSYM DXRAWSURFACEINFO} + TDXRawSurfaceInfo = DXRAWSURFACEINFO; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IDXRawSurface;'} + {$EXTERNALSYM IDXRawSurface} + IDXRawSurface = interface(IUnknown) + ['{09756C8A-D96A-11d1-9062-00C04FD9189D}'] + (*** IDXRawSurface methods ***) + function GetSurfaceInfo(var pSurfaceInfo: TDXRawSurfaceInfo): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IDXARGBSurfaceInit;'} + {$EXTERNALSYM IDXARGBSurfaceInit} + IDXARGBSurfaceInit = interface(IDXSurfaceInit) + ['{9EA3B63A-C37D-11d1-905E-00C04FD9189D}'] + (*** IDXARGBSurfaceInit methods ***) + function InitFromDDSurface(pDDrawSurface: IUnknown; const pFormatID: TGUID; + dwFlags: DWORD): HResult; stdcall; + function InitFromRawSurface(pRawSurface: IDXRawSurface): HResult; stdcall; + end; + + DXNATIVETYPEINFO = record + pCurrentData : ^BYTE; + pFirstByte : ^PBYTE; + lPitch : LongInt; + dwColorKey : DWORD; + end; + {$EXTERNALSYM DXNATIVETYPEINFO} + TDXNativeTypeInfo = DXNATIVETYPEINFO; + + DXPACKEDRECTDESC = record + pSamples : ^TDXBASESAMPLE; + bPremult : BOOL; + rect : TRECT; + lRowPadding : LongInt; + end; + {$EXTERNALSYM DXPACKEDRECTDESC} + TDXPackedRectDesc = DXPACKEDRECTDESC; + + DXOVERSAMPLEDESC = record + p : TPOINT; + Color : TDXPMSAMPLE; + end; + {$EXTERNALSYM DXOVERSAMPLEDESC} + TDXOverSampleDesc = DXOVERSAMPLEDESC; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IDXARGBReadPtr;'} + {$EXTERNALSYM IDXARGBReadPtr} + IDXARGBReadPtr = interface(IUnknown) + ['{EAAAC2D6-C290-11d1-905D-00C04FD9189D}'] + (*** IDXARGBReadPtr methods ***) + function GetSurface(const riid: TGUID; out ppSurface: pointer): HResult; stdcall; + function GetNativeType(out pInfo: TDXNativeTypeInfo): DXSAMPLEFORMATENUM; stdcall; + procedure Move(cSamples: LongInt); stdcall; + procedure MoveToRow(y: ULONG); stdcall; + procedure MoveToXY(x, y: ULONG); stdcall; + function MoveAndGetRunInfo(Row: ULONG; out ppInfo: PDXRUNINFO): ULONG; stdcall; + function Unpack(var pSamples: TDXSAMPLE; cSamples: ULONG; bMove: BOOL): TDXSAMPLE; stdcall; + function UnpackPremult(var pSamples: TDXPMSAMPLE; cSamples: ULONG; bMove: BOOL): TDXPMSAMPLE; stdcall; + procedure UnpackRect(var pRectDesc: TDXPackedRectDesc); stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IDXARGBReadWritePtr;'} + {$EXTERNALSYM IDXARGBReadWritePtr} + IDXARGBReadWritePtr = interface(IDXARGBReadPtr) + ['{EAAAC2D7-C290-11d1-905D-00C04FD9189D}'] + (*** IDXARGBReadWritePtr methods ***) + procedure PackAndMove(var pSamples: TDXSAMPLE; cSamples: ULONG); stdcall; + procedure PackPremultAndMove(var pSamples: TDXPMSAMPLE; cSamples: ULONG); stdcall; + procedure PackRect(var pRectDesc: TDXPackedRectDesc); stdcall; + procedure CopyAndMoveBoth(var pScratchBuffer: TDXBASESAMPLE; pSrc: IDXARGBReadPtr; + cSamples: ULONG; bIsOpaque: BOOL); stdcall; + procedure CopyRect(var pScratchBuffer: TDXBASESAMPLE; var pDestRect: TRECT; + pSrc: IDXARGBReadPtr; var pSrcOrigin: TPOINT; bIsOpaque: BOOL); stdcall; + procedure FillAndMove(var pScratchBuffer: TDXBASESAMPLE; SampVal: TDXPMSAMPLE; + cSamples: ULONG; bDoOver: BOOL); stdcall; + procedure FillRect(var pRect: TRECT; SampVal: TDXPMSAMPLE; bDoOver: BOOL); stdcall; + procedure OverSample(var pOverDesc: TDXOverSampleDesc); stdcall; + procedure OverArrayAndMove(var pScratchBuffer: TDXBASESAMPLE; var pSrc: TDXPMSAMPLE; + cSamples: ULONG); stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IDXTScaleOutput;'} + {$EXTERNALSYM IDXTScaleOutput} + IDXTScaleOutput = interface(IUnknown) + ['{B2024B50-EE77-11D1-9066-00C04FD9189D}'] + (*** IDXTScaleOutput methods ***) + function SetOutputSize(const OutSize: SIZE; bMaintainAspect: BOOL): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IDXGradient;'} + {$EXTERNALSYM IDXGradient} + IDXGradient = interface(IDXTScaleOutput) + ['{B2024B51-EE77-11D1-9066-00C04FD9189D}'] + (*** IDXGradient methods ***) + function SetGradient(StartColor: TDXSAMPLE; EndColor: TDXSAMPLE; bHorizontal: BOOL): HResult; stdcall; + function GetOutputSize(out pOutSize: SIZE): HResult; stdcall; + end; + + Scales = array[0..1] of Single; + {$EXTERNALSYM Scales} + + {$HPPEMIT 'typedef System::DelphiInterface _di_IDXTScale;'} + {$EXTERNALSYM IDXTScale} + IDXTScale = interface(IUnknown) + ['{B39FD742-E139-11D1-9065-00C04FD9189D}'] + (*** IDXTScale methods ***) + function SetScales(var Scales: Scales): HResult; stdcall; + function GetScales(out Scales: Scales): HResult; stdcall; + function ScaleFitToSize(var pClipBounds: TDXBNDS; FitToSize: SIZE; bMaintainAspect: BOOL): HResult; stdcall; + end; + + DISPIDDXEFFECT = {$IFDEF TYPE_IDENTITY}type {$ENDIF} LongWord; + {$EXTERNALSYM DISPIDDXEFFECT} + const + DISPID_DXECAPABILITIES = 10000; + {$EXTERNALSYM DISPID_DXECAPABILITIES} + DISPID_DXEPROGRESS = DISPID_DXECAPABILITIES + 1; + {$EXTERNALSYM DISPID_DXEPROGRESS} + DISPID_DXESTEP = DISPID_DXEPROGRESS + 1; + {$EXTERNALSYM DISPID_DXESTEP} + DISPID_DXEDURATION = DISPID_DXESTEP + 1; + {$EXTERNALSYM DISPID_DXEDURATION} + DISPID_DXE_NEXT_ID = DISPID_DXEDURATION + 1; + {$EXTERNALSYM DISPID_DXE_NEXT_ID} + +type + DXEFFECTTYPE = {$IFDEF TYPE_IDENTITY}type {$ENDIF} LongWord; + {$EXTERNALSYM DXEFFECTTYPE} + const + DXTET_PERIODIC = 1 shl 0; + {$EXTERNALSYM DXTET_PERIODIC} + DXTET_MORPH = 1 shl 1; + {$EXTERNALSYM DXTET_MORPH} + +type + {$HPPEMIT 'typedef System::DelphiInterface _di_IDXEffect;'} + {$EXTERNALSYM IDXEffect} + IDXEffect = interface(IDispatch) + ['{E31FB81B-1335-11d1-8189-0000F87557DB}'] + (*** IDXEffect methods ***) + function get_Capabilities(out pVal: LongInt): HResult; stdcall; + function get_Progress(out pVal: Single): HResult; stdcall; + function put_Progress(newVal: Single): HResult; stdcall; + function get_StepResolution(out pVal: Single): HResult; stdcall; + function get_Duration(out pVal: Single): HResult; stdcall; + function put_Duration(newVal: Single): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IHTMLDXTransform;'} + {$EXTERNALSYM IHTMLDXTransform} + IHTMLDXTransform = interface(IUnknown) + ['{30E2AB7D-4FDD-4159-B7EA-DC722BF4ADE5}'] + (*** IHTMLDXTransform methods ***) + function SetHostUrl(bstrHostUrl: WideString): HResult; stdcall; + end; + +//------------------------------------------------------------------------------ +// File: QEdit.h +// Desc: Dexter library (DES) +// Copyright (c) 1999 - 2000, Microsoft Corporation. All rights reserved. +//------------------------------------------------------------------------------ + +const + LIBID_DexterLib: TGUID = '{78530B68-61F9-11D2-8CAD-00A024580902}'; + {$EXTERNALSYM LIBID_DexterLib} + + IID_IPropertySetter : TGUID = '{AE9472BD-B0C3-11D2-8D24-00A0C9441E20}'; + {$EXTERNALSYM IID_IPropertySetter} + IID_IDxtCompositor : TGUID = '{BB44391E-6ABD-422F-9E2E-385C9DFF51FC}'; + {$EXTERNALSYM IID_IDxtCompositor} + IID_IDxtAlphaSetter : TGUID = '{4EE9EAD9-DA4D-43D0-9383-06B90C08B12B}'; + {$EXTERNALSYM IID_IDxtAlphaSetter} + IID_IDxtJpeg : TGUID = '{DE75D011-7A65-11D2-8CEA-00A0C9441E20}'; + {$EXTERNALSYM IID_IDxtJpeg} + IID_IDxtKey : TGUID = '{3255DE56-38FB-4901-B980-94B438010D7B}'; + {$EXTERNALSYM IID_IDxtKey} + IID_IMediaLocator : TGUID = '{288581E0-66CE-11D2-918F-00C0DF10D434}'; + {$EXTERNALSYM IID_IMediaLocator} + IID_IMediaDet : TGUID = '{65BD0710-24D2-4FF7-9324-ED2E5D3ABAFA}'; + {$EXTERNALSYM IID_IMediaDet} + IID_IGrfCache : TGUID = '{AE9472BE-B0C3-11D2-8D24-00A0C9441E20}'; + {$EXTERNALSYM IID_IGrfCache} + IID_IRenderEngine : TGUID = '{6BEE3A81-66C9-11D2-918F-00C0DF10D434}'; + {$EXTERNALSYM IID_IRenderEngine} + IID_IRenderEngine2 : TGUID = '{6BEE3A82-66C9-11d2-918F-00C0DF10D434}'; + {$EXTERNALSYM IID_IRenderEngine2} + IID_IFindCompressorCB : TGUID = '{F03FA8DE-879A-4D59-9B2C-26BB1CF83461}'; + {$EXTERNALSYM IID_IFindCompressorCB} + IID_ISmartRenderEngine : TGUID = '{F03FA8CE-879A-4D59-9B2C-26BB1CF83461}'; + {$EXTERNALSYM IID_ISmartRenderEngine} + IID_IAMTimelineObj : TGUID = '{78530B77-61F9-11D2-8CAD-00A024580902}'; + {$EXTERNALSYM IID_IAMTimelineObj} + IID_IAMTimelineEffectable : TGUID = '{EAE58537-622E-11D2-8CAD-00A024580902}'; + {$EXTERNALSYM IID_IAMTimelineEffectable} + IID_IAMTimelineEffect : TGUID = '{BCE0C264-622D-11D2-8CAD-00A024580902}'; + {$EXTERNALSYM IID_IAMTimelineEffect} + IID_IAMTimelineTransable : TGUID = '{378FA386-622E-11D2-8CAD-00A024580902}'; + {$EXTERNALSYM IID_IAMTimelineTransable} + IID_IAMTimelineSplittable : TGUID = '{A0F840A0-D590-11D2-8D55-00A0C9441E20}'; + {$EXTERNALSYM IID_IAMTimelineSplittable} + IID_IAMTimelineTrans : TGUID = '{BCE0C265-622D-11D2-8CAD-00A024580902}'; + {$EXTERNALSYM IID_IAMTimelineTrans} + IID_IAMTimelineSrc : TGUID = '{78530B79-61F9-11D2-8CAD-00A024580902}'; + {$EXTERNALSYM IID_IAMTimelineSrc} + IID_IAMTimelineTrack : TGUID = '{EAE58538-622E-11D2-8CAD-00A024580902}'; + {$EXTERNALSYM IID_IAMTimelineTrack} + IID_IAMTimelineVirtualTrack : TGUID = '{A8ED5F80-C2C7-11D2-8D39-00A0C9441E20}'; + {$EXTERNALSYM IID_IAMTimelineVirtualTrack} + IID_IAMTimelineComp : TGUID = '{EAE58536-622E-11D2-8CAD-00A024580902}'; + {$EXTERNALSYM IID_IAMTimelineComp} + IID_IAMTimelineGroup : TGUID = '{9EED4F00-B8A6-11D2-8023-00C0DF10D434}'; + {$EXTERNALSYM IID_IAMTimelineGroup} + IID_IAMTimeline : TGUID = '{78530B74-61F9-11D2-8CAD-00A024580902}'; + {$EXTERNALSYM IID_IAMTimeline} + IID_IXml2Dex : TGUID = '{18C628ED-962A-11D2-8D08-00A0C9441E20}'; + {$EXTERNALSYM IID_IXml2Dex} + IID_IAMErrorLog : TGUID = '{E43E73A2-0EFA-11D3-9601-00A0C9441E20}'; + {$EXTERNALSYM IID_IAMErrorLog} + IID_IAMSetErrorLog : TGUID = '{963566DA-BE21-4EAF-88E9-35704F8F52A1}'; + {$EXTERNALSYM IID_IAMSetErrorLog} + IID_ISampleGrabberCB : TGUID = '{0579154A-2B53-4994-B0D0-E773148EFF85}'; + {$EXTERNALSYM IID_ISampleGrabberCB} + IID_ISampleGrabber : TGUID = '{6B652FFF-11FE-4FCE-92AD-0266B5D7C78F}'; + {$EXTERNALSYM IID_ISampleGrabber} + IID_IResize : TGUID = '{4ada63a0-72d5-11d2-952a-0060081840bc}'; + {$EXTERNALSYM IID_IResize} + + CLSID_AMTimeline : TGUID = '{78530B75-61F9-11D2-8CAD-00A024580902}'; + {$EXTERNALSYM CLSID_AMTimeline} + CLSID_AMTimelineObj : TGUID = '{78530B78-61F9-11D2-8CAD-00A024580902}'; + {$EXTERNALSYM CLSID_AMTimelineObj} + CLSID_AMTimelineSrc : TGUID = '{78530B7A-61F9-11D2-8CAD-00A024580902}'; + {$EXTERNALSYM CLSID_AMTimelineSrc} + CLSID_AMTimelineTrack : TGUID = '{8F6C3C50-897B-11D2-8CFB-00A0C9441E20}'; + {$EXTERNALSYM CLSID_AMTimelineTrack} + CLSID_AMTimelineComp : TGUID = '{74D2EC80-6233-11D2-8CAD-00A024580902}'; + {$EXTERNALSYM CLSID_AMTimelineComp} + CLSID_AMTimelineGroup : TGUID = '{F6D371E1-B8A6-11D2-8023-00C0DF10D434}'; + {$EXTERNALSYM CLSID_AMTimelineGroup} + CLSID_AMTimelineTrans : TGUID = '{74D2EC81-6233-11D2-8CAD-00A024580902}'; + {$EXTERNALSYM CLSID_AMTimelineTrans} + CLSID_AMTimelineEffect : TGUID = '{74D2EC82-6233-11D2-8CAD-00A024580902}'; + {$EXTERNALSYM CLSID_AMTimelineEffect} + CLSID_RenderEngine : TGUID = '{64D8A8E0-80A2-11D2-8CF3-00A0C9441E20}'; + {$EXTERNALSYM CLSID_RenderEngine} + CLSID_SmartRenderEngine : TGUID = '{498B0949-BBE9-4072-98BE-6CCAEB79DC6F}'; + {$EXTERNALSYM CLSID_SmartRenderEngine} + CLSID_AudMixer : TGUID = '{036A9790-C153-11D2-9EF7-006008039E37}'; + {$EXTERNALSYM CLSID_AudMixer} + CLSID_Xml2Dex : TGUID = '{18C628EE-962A-11D2-8D08-00A0C9441E20}'; + {$EXTERNALSYM CLSID_Xml2Dex} + CLSID_MediaLocator : TGUID = '{CC1101F2-79DC-11D2-8CE6-00A0C9441E20}'; + {$EXTERNALSYM CLSID_MediaLocator} + CLSID_PropertySetter : TGUID = '{ADF95821-DED7-11D2-ACBE-0080C75E246E}'; + {$EXTERNALSYM CLSID_PropertySetter} + CLSID_MediaDet : TGUID = '{65BD0711-24D2-4FF7-9324-ED2E5D3ABAFA}'; + {$EXTERNALSYM CLSID_MediaDet} + CLSID_SampleGrabber : TGUID = '{C1F400A0-3F08-11D3-9F0B-006008039E37}'; + {$EXTERNALSYM CLSID_SampleGrabber} + CLSID_NullRenderer : TGUID = '{C1F400A4-3F08-11D3-9F0B-006008039E37}'; + {$EXTERNALSYM CLSID_NullRenderer} + CLSID_DxtCompositor : TGUID = '{BB44391D-6ABD-422F-9E2E-385C9DFF51FC}'; + {$EXTERNALSYM CLSID_DxtCompositor} + CLSID_DxtAlphaSetter : TGUID = '{506D89AE-909A-44F7-9444-ABD575896E35}'; + {$EXTERNALSYM CLSID_DxtAlphaSetter} + CLSID_DxtJpeg : TGUID = '{DE75D012-7A65-11D2-8CEA-00A0C9441E20}'; + {$EXTERNALSYM CLSID_DxtJpeg} + CLSID_ColorSource : TGUID = '{0CFDD070-581A-11D2-9EE6-006008039E37}'; + {$EXTERNALSYM CLSID_ColorSource} + CLSID_DxtKey : TGUID = '{C5B19592-145E-11D3-9F04-006008039E37}'; + {$EXTERNALSYM CLSID_DxtKey} + +type + // used by DEXTER_VALUE's dwInterp var + DEXTERF = ( + DEXTERF_JUMP, + DEXTERF_INTERPOLATE + ); + {$EXTERNALSYM DEXTERF} + TDexterF = DEXTERF; + + // used to set values on the property setter + PDexterParam = ^TDexterParam; + DEXTER_PARAM = record + Name : WideString ; + dispID : longint; + nValues : longint; + end; + {$EXTERNALSYM DEXTER_PARAM} + TDexterParam = DEXTER_PARAM; + + // used to set values on the property setter + PDexterValue = ^TDexterValue; + DEXTER_VALUE = record + v : OLEVARIANT ; + rt : TReferenceTime ; + dwInterp : DWORD ; + end; + {$EXTERNALSYM DEXTER_VALUE} + TDexterValue = DEXTER_VALUE; + +const + // used by bMethod directly below + DEXTER_AUDIO_JUMP = 0; + {$EXTERNALSYM DEXTER_AUDIO_JUMP} + DEXTER_AUDIO_INTERPOLATE = DEXTER_AUDIO_JUMP + 1; + {$EXTERNALSYM DEXTER_AUDIO_INTERPOLATE} + +type + // used to set volumes on the mixer and mixer pins + DEXTER_AUDIO_VOLUMEENVELOPE = record + rtEnd : TReferenceTime ; + dLevel : double ; + bMethod : BOOL ; + end; + {$EXTERNALSYM DEXTER_AUDIO_VOLUMEENVELOPE} + TDexterAudioVolumeEnvelope = DEXTER_AUDIO_VOLUMEENVELOPE; + +const + // used in IAMTimeline::Get(Set)InsertMode + TIMELINE_INSERT_MODE_INSERT = 1; + {$EXTERNALSYM TIMELINE_INSERT_MODE_INSERT} + TIMELINE_INSERT_MODE_OVERLAY = 2; + {$EXTERNALSYM TIMELINE_INSERT_MODE_OVERLAY} + + // define what main 'things' can be put into the timeline tree. + // these values are used quite a bit with timeline access + // (bitmap mask flags) +// TIMELINE_MAJOR_TYPE + TIMELINE_MAJOR_TYPE_COMPOSITE = 1; + {$EXTERNALSYM TIMELINE_MAJOR_TYPE_COMPOSITE} + TIMELINE_MAJOR_TYPE_TRACK = 2; + {$EXTERNALSYM TIMELINE_MAJOR_TYPE_TRACK} + TIMELINE_MAJOR_TYPE_SOURCE = 4; + {$EXTERNALSYM TIMELINE_MAJOR_TYPE_SOURCE} + TIMELINE_MAJOR_TYPE_TRANSITION = 8; + {$EXTERNALSYM TIMELINE_MAJOR_TYPE_TRANSITION} + TIMELINE_MAJOR_TYPE_EFFECT = 16; + {$EXTERNALSYM TIMELINE_MAJOR_TYPE_EFFECT} + TIMELINE_MAJOR_TYPE_GROUP = 128; + {$EXTERNALSYM TIMELINE_MAJOR_TYPE_GROUP} + +// used in various IAMTimelineXXX "search" functions. Look in this +// file for "SearchDirection" to see where it's used. I didn't want +// to use an enum as an interface param type, so I used a long. Probably +// silly of me. +// DEXTERF_TRACK_SEARCH_FLAGS + DEXTERF_BOUNDING = -1; + {$EXTERNALSYM DEXTERF_BOUNDING} + DEXTERF_EXACTLY_AT = 0; + {$EXTERNALSYM DEXTERF_EXACTLY_AT} + DEXTERF_FORWARDS = 1; + {$EXTERNALSYM DEXTERF_FORWARDS} + +type + // right now, the media type in the group contains enough information about + // how we want to recompress. This might not be enough information in the + // future, so we define a structure we can get and set to the group. + _SCompFmt0 = record + nFormatId : longint ; + MediaType : TAMMediaType ; + end; + {$EXTERNALSYM _SCompFmt0} + SCompFmt0 = _SCompFmt0; + {$EXTERNALSYM SCompFmt0} + TSCompFmt0 = _SCompFmt0; + +const + // used in IAMTimelineSrc::Get(Set)StretchMode + RESIZEF_STRETCH = 0; + {$EXTERNALSYM RESIZEF_STRETCH} + RESIZEF_CROP = RESIZEF_STRETCH + 1; + {$EXTERNALSYM RESIZEF_CROP} + RESIZEF_PRESERVEASPECTRATIO = RESIZEF_CROP + 1; + {$EXTERNALSYM RESIZEF_PRESERVEASPECTRATIO} + RESIZEF_PRESERVEASPECTRATIO_NOLETTERBOX = RESIZEF_PRESERVEASPECTRATIO + 1; + {$EXTERNALSYM RESIZEF_PRESERVEASPECTRATIO_NOLETTERBOX} + + // used in IRenderEngine::SetDynamicReconnectLevel + // (bitmap mask flags) + CONNECTF_DYNAMIC_NONE = 0; + {$EXTERNALSYM CONNECTF_DYNAMIC_NONE} + CONNECTF_DYNAMIC_SOURCES = $1; + {$EXTERNALSYM CONNECTF_DYNAMIC_SOURCES} + CONNECTF_DYNAMIC_EFFECTS = $2; + {$EXTERNALSYM CONNECTF_DYNAMIC_EFFECTS} + + // used in + // IMediaLocator::FindMediaFile + // IRenderEngine::SetSourceNameValidation + // IAMTimeline::ValidateSourceNames + // (bitmap mask flags) + SFN_VALIDATEF_CHECK = $1; + {$EXTERNALSYM SFN_VALIDATEF_CHECK} + SFN_VALIDATEF_POPUP = $2; + {$EXTERNALSYM SFN_VALIDATEF_POPUP} + SFN_VALIDATEF_TELLME = $4; + {$EXTERNALSYM SFN_VALIDATEF_TELLME} + SFN_VALIDATEF_REPLACE = $8; + {$EXTERNALSYM SFN_VALIDATEF_REPLACE} + SFN_VALIDATEF_USELOCAL = $10; + {$EXTERNALSYM SFN_VALIDATEF_USELOCAL} + SFN_VALIDATEF_NOFIND = $20; + {$EXTERNALSYM SFN_VALIDATEF_NOFIND} + SFN_VALIDATEF_IGNOREMUTED = $40; + {$EXTERNALSYM SFN_VALIDATEF_IGNOREMUTED} + SFN_VALIDATEF_END = SFN_VALIDATEF_IGNOREMUTED + 1; + {$EXTERNALSYM SFN_VALIDATEF_END} + + // key transitions types + DXTKEY_RGB = 0; + {$EXTERNALSYM DXTKEY_RGB} + DXTKEY_NONRED = DXTKEY_RGB + 1; + {$EXTERNALSYM DXTKEY_NONRED} + DXTKEY_LUMINANCE = DXTKEY_NONRED + 1; + {$EXTERNALSYM DXTKEY_LUMINANCE} + DXTKEY_ALPHA = DXTKEY_LUMINANCE + 1; + {$EXTERNALSYM DXTKEY_ALPHA} + DXTKEY_HUE = DXTKEY_ALPHA + 1; + {$EXTERNALSYM DXTKEY_HUE} + +type + //////////////////////////////////////////////////////////////// + //////////////////////////////////////////////////////////////// + // New Property setting Interfaces + //////////////////////////////////////////////////////////////// + //////////////////////////////////////////////////////////////// + + {$HPPEMIT 'typedef System::DelphiInterface _di_IPropertySetter;'} + {$EXTERNALSYM IPropertySetter} + IPropertySetter = interface(IUnknown) + ['{AE9472BD-B0C3-11D2-8D24-00A0C9441E20}'] + (*** IPropertySetter methods ***) + // for loading and saving through XML + function LoadXML(pxml: IUnknown): HResult; stdcall; + // !!! doesn't work HResult LoadXML([in] IXMLElement * pxml); + function PrintXML(out pszXML: pchar; cbXML: integer; out pcbPrinted: pinteger; indent: integer): HResult; stdcall; + // for cloning a portion of the props when splitting the object + function CloneProps(out ppSetter: IPropertySetter; rtStart, rtStop: TReferenceTime): HResult; stdcall; + // for loading and saving programmatically + // caller must call this in pre-sorted order, this time must be > all + // previous times + function AddProp(Param: TDexterParam; var paValue: TDexterValue): HResult; stdcall; + function GetProps(out pcParams: longint; out paParam: PDexterParam; out paValue: PDexterValue): HResult; stdcall; + // after calling GetProps, you must call FreeProps to free resources + function FreeProps(cParams: longint; var paParam: TDexterParam; var paValue: TDexterValue): HResult; stdcall; + // to empty to property setter, so you can start over again + function ClearProps: HResult; stdcall; + // for persisting + function SaveToBlob(out pcSize: longint; out ppb: pbyte): HResult; stdcall; + // + function LoadFromBlob(cSize: longint; var pb: Byte): HResult; stdcall; + // to program the object that supports IDispatch with the props + // call with rtNow == -1 to set Static Props when your object instantiates + // errors will be logged, if a log is provided + function SetProps(pTarget: IUnknown; rtNow: TReferenceTime): HResult; stdcall; + // unicode version + function PrintXMLW({out}pszXML: PWideChar; cchXML: integer; out pcchPrinted: integer; indent: integer): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IDxtCompositor;'} + {$EXTERNALSYM IDxtCompositor} + IDxtCompositor = interface(IDXEffect) + ['{BB44391E-6ABD-422F-9E2E-385C9DFF51FC}'] + (*** IDxtCompositor methods ***) + function get_OffsetX(out pVal: longint): HResult; stdcall; + function put_OffsetX(newVal: longint): HResult; stdcall; + function get_OffsetY(out pVal: longint): HResult; stdcall; + function put_OffsetY(newVal: longint): HResult; stdcall; + function get_Width(out pVal: longint): HResult; stdcall; + function put_Width(newVal: longint): HResult; stdcall; + function get_Height(out pVal: longint): HResult; stdcall; + function put_Height(newVal: longint): HResult; stdcall; + function get_SrcOffsetX(out pVal: longint): HResult; stdcall; + function put_SrcOffsetX(newVal: longint): HResult; stdcall; + function get_SrcOffsetY(out pVal: longint): HResult; stdcall; + function put_SrcOffsetY(newVal: longint): HResult; stdcall; + function get_SrcWidth(out pVal: longint): HResult; stdcall; + function put_SrcWidth(newVal: longint): HResult; stdcall; + function get_SrcHeight(out pVal: longint): HResult; stdcall; + function put_SrcHeight(newVal: longint): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IDxtAlphaSetter;'} + {$EXTERNALSYM IDxtAlphaSetter} + IDxtAlphaSetter = interface(IDXEffect) + ['{4EE9EAD9-DA4D-43D0-9383-06B90C08B12B}'] + (*** IDxtAlphaSetter methods ***) + function get_Alpha(out pVal: longint): HResult; stdcall; + function put_Alpha(newVal: longint): HResult; stdcall; + function get_AlphaRamp(out pVal: Double): HResult; stdcall; + function put_AlphaRamp(newVal: Double): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IDxtJpeg;'} + {$EXTERNALSYM IDxtJpeg} + IDxtJpeg = interface(IDXEffect) + ['{DE75D011-7A65-11D2-8CEA-00A0C9441E20}'] + (*** IDxtJpeg methods ***) + function get_MaskNum(out pVal: longint): HResult; stdcall; + function put_MaskNum(newVal: longint): HResult; stdcall; + function get_MaskName(out pVal: WideString): HResult; stdcall; + function put_MaskName(newVal: WideString): HResult; stdcall; + function get_ScaleX(out pVal: Double): HResult; stdcall; + function put_ScaleX(newVal: Double): HResult; stdcall; + function get_ScaleY(out pVal: Double): HResult; stdcall; + function put_ScaleY(newVal: Double): HResult; stdcall; + function get_OffsetX(out pVal: longint): HResult; stdcall; + function put_OffsetX(newVal: longint): HResult; stdcall; + function get_OffsetY(out pVal: longint): HResult; stdcall; + function put_OffsetY(newVal: longint): HResult; stdcall; + function get_ReplicateX(out pVal: longint): HResult; stdcall; + function put_ReplicateX(newVal: longint): HResult; stdcall; + function get_ReplicateY(out pVal: longint): HResult; stdcall; + function put_ReplicateY(newVal: longint): HResult; stdcall; + function get_BorderColor(out pVal: longint): HResult; stdcall; + function put_BorderColor(newVal: longint): HResult; stdcall; + function get_BorderWidth(out pVal: longint): HResult; stdcall; + function put_BorderWidth(newVal: longint): HResult; stdcall; + function get_BorderSoftness(out pVal: longint): HResult; stdcall; + function put_BorderSoftness(newVal: longint): HResult; stdcall; + function ApplyChanges: HResult; stdcall; + function LoadDefSettings: HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IDxtKey;'} + {$EXTERNALSYM IDxtKey} + IDxtKey = interface(IDXEffect) + ['{3255DE56-38FB-4901-B980-94B438010D7B}'] + (*** IDxtKey methods ***) + function get_KeyType(out pVal: integer): HResult; stdcall; + function put_KeyType(newVal: integer): HResult; stdcall; + function get_Hue(out pVal: integer): HResult; stdcall; + function put_Hue(newVal: integer): HResult; stdcall; + function get_Luminance(out pVal: integer): HResult; stdcall; + function put_Luminance(newVal: integer): HResult; stdcall; + function get_RGB(out pVal: DWORD): HResult; stdcall; + function put_RGB(newVal: DWORD): HResult; stdcall; + function get_Similarity(out pVal: integer): HResult; stdcall; + function put_Similarity(newVal: integer): HResult; stdcall; + function get_Invert(out pVal: BOOL): HResult; stdcall; + function put_Invert(newVal: BOOL): HResult; stdcall; + end; + + // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + // This little COM interface will look 'around' for the closest + // path match for a given file. If the file already exists, then + // this interface should hardly do anything. If it's not found, + // it will go look for it and if successful, return S_FALSE. If it + // cannot find the file, it will call the hook, if set and return + // it's return code. if the hook is not set, it is in a type of + // error condition. The Dexter-provided MediaLocator will bring up + // a dialog box asking you to browse for your file. Other COM + // objects may do something else. + // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + {$HPPEMIT 'typedef System::DelphiInterface _di_IMediaLocator;'} + {$EXTERNALSYM IMediaLocator} + IMediaLocator = interface(IUnknown) + ['{288581E0-66CE-11D2-918F-00C0DF10D434}'] + (*** IMediaLocator methods ***) + function FindMediaFile(Input: TBSTR; FilterString: TBSTR; + out pOutput: TBSTR; Flags: longint): HResult; stdcall; + function AddFoundLocation(DirectoryName: TBSTR): HResult; stdcall; + end; + + ISampleGrabber = interface; + + // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + // This object provides caching of duration and stream type + // information for files that would produce a directshow source + // filter. It takes too long to figure this out in DShow right + // now, so this is one way around it. The way it works is that + // you first fill out the Filename property, then call and + // ask how many streams it has, or, set the CurrentStream prop + // and then ask for the per-stream properties, StreamType or + // StreamLength. They both reference the CurrentStream prop that + // you set. I also allowed you (for convenience) to just give + // it a IUnknown Filter that represents an IBaseFilter source + // filter that is NOT currently in a graph. It will use that + // instead. When using this, though, you will not get cached + // values. The cached values are stored in the system's ini file + // called DCBC2A70-70D8-4459-BFFA-E0D61DEA3FDF.INI. Nice, huh? :-) + // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + {$HPPEMIT 'typedef System::DelphiInterface _di_IMediaDet;'} + {$EXTERNALSYM IMediaDet} + IMediaDet = interface(IUnknown) + ['{65BD0710-24D2-4FF7-9324-ED2E5D3ABAFA}'] + (*** IMediaDet methods ***) + function get_Filter(out pVal: IUnknown): HResult; stdcall; + function put_Filter(newVal: IUnknown): HResult; stdcall; + function get_OutputStreams(out pVal: longint): HResult; stdcall; + function get_CurrentStream(out pVal: longint): HResult; stdcall; + function put_CurrentStream(newVal: longint): HResult; stdcall; + function get_StreamType(out pVal: TGUID): HResult; stdcall; + function get_StreamTypeB(out pVal: WideString): HResult; stdcall; + function get_StreamLength(out pVal: Double): HResult; stdcall; + function get_Filename(out pVal: WideString): HResult; stdcall; + function put_Filename(pVal: WideString): HResult; stdcall; + function GetBitmapBits(streamTime: Double; pBufferSize: Plongint; pBuffer: PByte; + Width: longint; Height: longint): HResult; stdcall; + function WriteBitmapBits(streamTime: Double; Width: longint; Height: longint; + Filename: WideString): HResult; stdcall; + function get_StreamMediaType(out pVal: TAMMediaType): HResult; stdcall; + function GetSampleGrabber(out ppVal: ISampleGrabber): HResult; stdcall; + function get_FrameRate(out pVal: Double): HResult; stdcall; + function EnterBitmapGrabMode(SeekTime: Double): HResult; stdcall; + end; + + // useless interface, don't use it! + + {$HPPEMIT 'typedef System::DelphiInterface _di_IGrfCache;'} + {$EXTERNALSYM IGrfCache} + IGrfCache = interface(IDispatch) + ['{AE9472BE-B0C3-11D2-8D24-00A0C9441E20}'] + (*** IGrfCache methods ***) + function AddFilter(ChainedCache: IGrfCache; Id: Int64; const pFilter: IBaseFilter; + pName: PWideChar): HResult; stdcall; + function ConnectPins(ChainedCache: IGrfCache; PinID1: Int64; const pPin1: IPin; + PinID2: Int64; const pPin2: IPin): HResult; stdcall; + function SetGraph(const pGraph: IGraphBuilder): HResult; stdcall; + function DoConnectionsNow: HResult; stdcall; + end; + + IAMTimeline = interface; + + // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + // The RenderEngin builds a graph from the timeline and gives + // you some simple positional commands. + // explained methods: + // SetTimelineObject - tell the render engine who to parse + // ConnectEverything - build up a graph based on the timeline + // ScrapIt - throw away graph and everything + // GetFilterGraph - get the graph that's built up, if any + // SetFilterGraph - allows you to preset the graph that's built up. + // cannot call this if there already is a graph. + + // !!! the following methods are unused/not implemented + + // SetInterestRange - discard COM objects and memory outside of this + // range, if possible. Used for scrubbing on a long timeline and + // freeing up resources + // SetRenderRange - pretend like a portion of the timeline IS the timeline + // and don't connect anything in the graph outside of that range. + // Commit - allocate what's necessary and get prepared to run + // Decommit - free anything possible + // GetCaps - find out some info about the render engine + // DoSmartRecompression - connect compressed sources if + // possible + // in the graph, this will RenderPin( ) on every switcher + // rendering pin. + // SetSourceNameValidation - allows you to set some flags which + // determine how source files are found, if they need to be found. + // FilterString is a list of extensions to find for the media + // files (see OPENFILENAME filters) + // pOverride is a media locator you would like to use instead + // of the built in one + // The flags are defined in the struct immediately below. + // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + {$HPPEMIT 'typedef System::DelphiInterface _di_IRenderEngine;'} + {$EXTERNALSYM IRenderEngine} + IRenderEngine = interface(IUnknown) + ['{6BEE3A81-66C9-11D2-918F-00C0DF10D434}'] + (*** IRenderEngine methods ***) + function SetTimelineObject(pTimeline: IAMTimeline): HResult; stdcall; + function GetTimelineObject(out ppTimeline: IAMTimeline): HResult; stdcall; + function GetFilterGraph(out ppFG: IGraphBuilder): HResult; stdcall; + function SetFilterGraph(pFG: IGraphBuilder): HResult; stdcall; + function SetInterestRange(Start, Stop: TReferenceTime): HResult; stdcall; + function SetInterestRange2(Start, Stop: Double): HResult; stdcall; + function SetRenderRange(Start, Stop: TReferenceTime): HResult; stdcall; + function SetRenderRange2(Start, Stop: Double): HResult; stdcall; + function GetGroupOutputPin(Group: longint; out ppRenderPin: IPin): HResult; stdcall; + function ScrapIt: HResult; stdcall; + function RenderOutputPins: HResult; stdcall; + function GetVendorString(out pVendorID: WideString): HResult; stdcall; + function ConnectFrontEnd: HResult; stdcall; + function SetSourceConnectCallback(pCallback: IGrfCache): HResult; stdcall; + function SetDynamicReconnectLevel(Level: longint): HResult; stdcall; + function DoSmartRecompression: HResult; stdcall; + function UseInSmartRecompressionGraph: HResult; stdcall; + function SetSourceNameValidation(const FilterString: WideString; + pOverride: IMediaLocator; Flags: longint): HResult; stdcall; + function Commit: HResult; stdcall; + function Decommit: HResult; stdcall; + function GetCaps(Index: longint; var pReturn: longint): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IRenderEngine2;'} + {$EXTERNALSYM IRenderEngine2} + IRenderEngine2 = interface(IUnknown) + ['{6BEE3A82-66C9-11d2-918F-00C0DF10D434}'] + (*** IRenderEngine2 methods ***) + function SetResizerGUID(const ResizerGuid: TGUID): HResult; + end; + + // used for the smart render engine when it needs to find a compressor + {$HPPEMIT 'typedef System::DelphiInterface _di_IFindCompressorCB;'} + {$EXTERNALSYM IFindCompressorCB} + IFindCompressorCB = interface(IUnknown) + ['{F03FA8DE-879A-4D59-9B2C-26BB1CF83461}'] + (*** IFindCompressorCB methods ***) + function GetCompressor(var pType: TAMMediaType; var pCompType: TAMMediaType; + out ppFilter: IBaseFilter): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_ISmartRenderEngine;'} + {$EXTERNALSYM ISmartRenderEngine} + ISmartRenderEngine = interface(IUnknown) + ['{F03FA8CE-879A-4D59-9B2C-26BB1CF83461}'] + (*** ISmartRenderEngine methods ***) + function SetGroupCompressor(Group: longint; pCompressor: IBaseFilter): HResult; stdcall; + function GetGroupCompressor(Group: longint; var pCompressor: IBaseFilter): HResult; stdcall; + function SetFindCompressorCB(pCallback: IFindCompressorCB): HResult; stdcall; + end; + + IAMTimelineGroup = interface; + +//////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////// +// TIMELINE TIMELINE TIMELINE TIMELINE TIMELINE TIMELINE +//////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////// + + // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + // Every object on the timeline supports at least this interface. + // explained methods: + // Get/SetStartStop - the timeline times at which this object is + // active. Groups and Tracks have start times of zero. + // FixTimes - used by the render engine. Rounds the input times + // to the nearest FPS of the parent Group, for use in setting + // up the big switch. + // GetSubObject - get the sub-object which is associated with this + // timeline object. Each timeline object can carry around a + // pointer to 'something else'. For our Render Engine, this is + // a pointer to a filter that gets put into a graph. + // NOTE: Getting the subobject will FORCE it to load if it's possible + // to force this. If you don't want it to do this, don't call + // this function. + // SetSubObject - see GetSubObject + // SetSubObjectGUID - instead of giving the node a pointer, you can + // instead give it a GUID and see if this works instead. The + // sub-object will attempt to be instantiated when 'necessary' + // which is really when it's asked for with GetSubObject./ + // !!! a better way to do this perhaps? + // GetSubObjectLoaded - ask if the sub-object pointer is set + // Get/SetTimelineType - return the major type which is stored here, + // used by the API user and the render engine. + // Get/SetTimelineSubType - see above + // Get/SetUserID - get and set a number, any number + // GetGenID - every created object has a unique number to it. Used + // by the render engine. + // Get/SetUserName - a storable name, for users of the API + // Get/SetPropertySetter - the object that will set properties for this + // object (it will support IPropertySetter and it is created by + // CPropertySetter) + // Get/SetUserData - gets the persistant data used by the user of + // the API. + // Get/SetMuted - set whether this object should be active or not. + // Setting a parent of other objects off also turns off the + // sub-objects. + // Get/SetLocked - set whether you can edit this object or not. + // Note: the timeline doesn't enforce this, it just stores + // a value for convenience. + // Get/SetDirtyRange - + // RemoveAll - remove this object, and if in the tree already, all it's + // sub objects, including children + // Remove - remove this object, and if in the tree already, all it's + // sub objects, but not kids + // GetTimelineNoRef - called internally by the timeline. + // GetGroupIBelongTo - called internally by the timeline. + // GetEmbedDepth - find out how many tracks we are a part of + // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMTimelineObj;'} + {$EXTERNALSYM IAMTimelineObj} + IAMTimelineObj = interface(IUnknown) + ['{78530B77-61F9-11D2-8CAD-00A024580902}'] + (*** IAMTimelineObj methods ***) + function GetStartStop(var pStart, pStop: TReferenceTime): HResult; stdcall; + function GetStartStop2(var pStart, pStop: TREFTIME): HResult; stdcall; + function FixTimes(var pStart, pStop: TReferenceTime): HResult; stdcall; + function FixTimes2(var pStart, pStop: TREFTIME): HResult; stdcall; + function SetStartStop(Start, Stop: TReferenceTime): HResult; stdcall; + function SetStartStop2(Start, Stop: TREFTIME): HResult; stdcall; + function GetPropertySetter(out pVal: IPropertySetter): HResult; stdcall; + function SetPropertySetter(newVal: IPropertySetter): HResult; stdcall; + function GetSubObject(out pVal: IUnknown): HResult; stdcall; + function SetSubObject(newVal: IUnknown): HResult; stdcall; + function SetSubObjectGUID(newVal: TGUID): HResult; stdcall; + function SetSubObjectGUIDB(const newVal: WideString): HResult; stdcall; + function GetSubObjectGUID(var pVal: TGUID): HResult; stdcall; + function GetSubObjectGUIDB(out pVal: WideString): HResult; stdcall; + function GetSubObjectLoaded(var pVal: BOOL): HResult; stdcall; + function GetTimelineType(var pVal: integer): HResult; stdcall; // TIMELINE_MAJOR_TYPE + function SetTimelineType(newVal: integer): HResult; stdcall; // TIMELINE_MAJOR_TYPE + function GetUserID(var pVal: longint): HResult; stdcall; + function SetUserID(newVal: longint): HResult; stdcall; + function GetGenID(var pVal: longint): HResult; stdcall; + function GetUserName(out pVal: WideString): HResult; stdcall; + function SetUserName(const newVal: WideString): HResult; stdcall; + function GetUserData(var pData: PByte; var pSize: Integer): HResult; stdcall; + function SetUserData(var pData: Byte; Size: Integer): HResult; stdcall; + function GetMuted(var pVal: BOOL): HResult; stdcall; + function SetMuted(newVal: BOOL): HResult; stdcall; + function GetLocked(var pVal: BOOL): HResult; stdcall; + function SetLocked(newVal: BOOL): HResult; stdcall; + function GetDirtyRange(var pStart, pStop: TReferenceTime): HResult; stdcall; + function GetDirtyRange2(var pStart, pStop: TREFTIME): HResult; stdcall; + function SetDirtyRange(Start, Stop: TReferenceTime): HResult; stdcall; + function SetDirtyRange2(Start, Stop: TREFTIME): HResult; stdcall; + function ClearDirty: HResult; stdcall; + function Remove: HResult; stdcall; + function RemoveAll: HResult; stdcall; + function GetTimelineNoRef(var ppResult: IAMTimeline): HResult; stdcall; + function GetGroupIBelongTo(out ppGroup: IAMTimelineGroup): HResult; stdcall; + function GetEmbedDepth(var pVal: longint): HResult; stdcall; + end; + + // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + // Any object on the timeline that can have an effect put on it + // implements this interface. This includes sources, tracks, and + // compositions. + // explained methods: + // EffectInsBefore - insert an effect at the given priority onto + // this object. The effect's times will be clipped within + // this object's bounds. Use -1 to specify 'at the end' for priority. + // You cannot have two effects at the same priority. + // EffectSwapPriorities - swaparoo two effects. Makes undo easier to + // implement. + // EffectGetCount - get how many effects are applied to this object. + // GetEffect - get the nth effect applied to this object + // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMTimelineEffectable;'} + {$EXTERNALSYM IAMTimelineEffectable} + IAMTimelineEffectable = interface(IUnknown) + ['{EAE58537-622E-11D2-8CAD-00A024580902}'] + (*** IAMTimelineEffectable methods ***) + function EffectInsBefore(pFX: IAMTimelineObj; priority: longint): HResult; stdcall; + function EffectSwapPriorities(PriorityA, PriorityB: longint): HResult; stdcall; + function EffectGetCount(var pCount: longint): HResult; stdcall; + function GetEffect(out ppFx: IAMTimelineObj; Which: longint): HResult; stdcall; + end; + + // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + // Any effect on the timeline will support at least this interface. + // NOTE: The Start/Stop times on this object are RELATIVE to their + // parent's, as are all start/stop times. + // explained methods: + // EffectGetPriority - finds out this effect's priority related to the others. + // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMTimelineEffect;'} + {$EXTERNALSYM IAMTimelineEffect} + IAMTimelineEffect = interface(IUnknown) + ['{BCE0C264-622D-11D2-8CAD-00A024580902}'] + (*** IAMTimelineEffect methods ***) + function EffectGetPriority(var pVal: longint): HResult; stdcall; + end; + + // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + // Any object on the timeline that can have a transition put on it + // implements this interface + // explained methods: + // TransAdd - add a transition on this object. Multiple trans's on + // the same object cannot overlap in time. Transitions' times + // must lie within the bounds of their parent. + // TransGetCount - get how many transitions are applied to this + // object. + // GetNextTrans - given a time, get the next transition that happens + // on this object after that time. On exit, the input time is + // set to the start time of the transition. + // GetTransAtTime - find a transition forwards or backwards from + // a given spot. See DEXTERF_TRACK_SEARCH_FLAGS enum. + // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMTimelineTransable;'} + {$EXTERNALSYM IAMTimelineTransable} + IAMTimelineTransable = interface(IUnknown) + ['{378FA386-622E-11D2-8CAD-00A024580902}'] + (*** IAMTimelineTransable methods ***) + function TransAdd(pTrans: IAMTimelineObj): HResult; stdcall; + function TransGetCount(var pCount: longint): HResult; stdcall; + function GetNextTrans(out ppTrans: IAMTimelineObj; var pInOut: TReferenceTime): HResult; stdcall; + function GetNextTrans2(out ppTrans: IAMTimelineObj; var pInOut: TREFTIME): HResult; stdcall; + function GetTransAtTime(out ppObj: IAMTimelineObj; Time: TReferenceTime; SearchDirection: longint): HResult; stdcall; + function GetTransAtTime2(out ppObj: IAMTimelineObj; Time: TREFTIME; SearchDirection: longint): HResult; stdcall; + end; + + // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + // Any object on the timeline that can be split into two will + // implement this interface. Namely, source, effects, and transitions + // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMTimelineSplittable;'} + {$EXTERNALSYM IAMTimelineSplittable} + IAMTimelineSplittable = interface(IUnknown) + ['{A0F840A0-D590-11D2-8D55-00A0C9441E20}'] + (*** IAMTimelineSplittable methods ***) + function SplitAt(Time: TReferenceTime): HResult; stdcall; + function SplitAt2(Time: TREFTIME): HResult; stdcall; + end; + + // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + // Any trans on the timeline will support at least this interface. + // NOTE: The Start/Stop times on this object are RELATIVE to their + // parent's, as are all start/stop times. + // explained methods: + // GetCutPoint - get where this transition should cut from A to B + // if the transition were not applied. + // GetA2B - get if this transition is to go from A->B or B->A. + // GetBackwards - get if this transition should run backwards. + // GetCutsOnly - force no transition, force doing a cut + // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMTimelineTrans;'} + {$EXTERNALSYM IAMTimelineTrans} + IAMTimelineTrans = interface(IUnknown) + ['{BCE0C265-622D-11D2-8CAD-00A024580902}'] + (*** IAMTimelineTrans methods ***) + function GetCutPoint(var pTLTime: TReferenceTime): HResult; stdcall; + function GetCutPoint2(var pTLTime: TREFTIME): HResult; stdcall; + function SetCutPoint(TLTime: TReferenceTime): HResult; stdcall; + function SetCutPoint2(TLTime: TREFTIME): HResult; stdcall; + function GetSwapInputs(var pVal: BOOL): HResult; stdcall; + function SetSwapInputs(pVal: BOOL): HResult; stdcall; + function GetCutsOnly(var pVal: BOOL): HResult; stdcall; + function SetCutsOnly(pVal: BOOL): HResult; stdcall; + end; + + // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + // Sources represent any source media object on the timeline. + // They extend an IAMTimelineObj to include media start and stop + // times, a media name (which could represent darned near anything), + // and a StreamNumber, which defines which stream out of a potential + // many this stream represents from a source clip. + // explained methods: + // ModifyStopTime - like calling SetStartStop, but this method just + // adjusts the tail end of the clip. + // FixMediaTimes - called by the render engine to round times to + // this source clip's parent group's FPS. + // SpliceWithNext - if the next clip after this is the same source + // and this's stop time matches next's start time, the two + // will be joined. + // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMTimelineSrc;'} + {$EXTERNALSYM IAMTimelineSrc} + IAMTimelineSrc = interface(IUnknown) + ['{78530B79-61F9-11D2-8CAD-00A024580902}'] + (*** IAMTimelineSrc methods ***) + function GetMediaTimes(var pStart, pStop: TReferenceTime): HResult; stdcall; + function GetMediaTimes2(var pStart, pStop: TREFTIME): HResult; stdcall; + function ModifyStopTime(Stop: TReferenceTime): HResult; stdcall; + function ModifyStopTime2(Stop: TREFTIME): HResult; stdcall; + function FixMediaTimes(var pStart, pStop: TReferenceTime): HResult; stdcall; + function FixMediaTimes2(var pStart, pStop: TREFTIME): HResult; stdcall; + function SetMediaTimes(Start, Stop: TReferenceTime): HResult; stdcall; + function SetMediaTimes2(Start, Stop: TREFTIME): HResult; stdcall; + function SetMediaLength(Length: TReferenceTime): HResult; stdcall; + function SetMediaLength2(Length: TREFTIME): HResult; stdcall; + function GetMediaLength(var pLength: TReferenceTime): HResult; stdcall; + function GetMediaLength2(var pLength: TREFTIME): HResult; stdcall; + function GetMediaName(out pVal: WideString): HResult; stdcall; + function SetMediaName(const newVal: WideString): HResult; stdcall; + function SpliceWithNext(pNext: IAMTimelineObj): HResult; stdcall; + function GetStreamNumber(var pVal: longint): HResult; stdcall; + function SetStreamNumber(Val: longint): HResult; stdcall; + function IsNormalRate(var pVal: BOOL): HResult; stdcall; + // If a source can't figure out its frames per second, this number + // will be used (eg: Dib sequences). AVI, MPEG, etc. will not need this + // Use 0 fps to prevent a filename like "ski4.jpg" from using a dib seq + function GetDefaultFPS(var pFPS: Double): HResult; stdcall; + function SetDefaultFPS(FPS: Double): HResult; stdcall; + // !!! This is video specific.. new interface? + // what kind of stretching? Stretch, crop, or preserve aspect ratio? + function GetStretchMode(var pnStretchMode: integer): HResult; stdcall; + function SetStretchMode(nStretchMode: integer): HResult; stdcall; + end; + + // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + // Tracks are things that can contain media in them. You can add + // and remove sources, effects, and transitions from them. Sources + // are added according to the current insert mode of the timeline. + // If in OVERLAY mode, moving or adding a source to a time that's + // already occupied by another source will wipe out any overlapping + // portion of the underlying source. In InsertMode, everything at + // the insert point is moved down in time to make room for the + // new source. + // explained methods: + // SrcAdd - add the source to this track. The source's start/stop + // times must be set up first. + // GetNextSrc - pass a time in at which you wish to find a source + // and it will return the first source which occurs after the + // given time. + // MoveEverythingBy - bump a bunch of objects a certain direction + // on the track by a given time. + // GetSourcesCount - how many sources are on this track? + // AreYouBlank - do you contain anything at all? + // GetSrcAtTime - find a source at a given time. SearchDirection + // is which way to search. -1 = backwards, 1 = forwards + // MakeSpace - !!! what does this do, anyhow? + // RemoveSlice - !!! what does this do, anyhow? + // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMTimelineTrack;'} + {$EXTERNALSYM IAMTimelineTrack} + IAMTimelineTrack = interface(IUnknown) + ['{EAE58538-622E-11D2-8CAD-00A024580902}'] + (*** IAMTimelineTrack methods ***) + function SrcAdd(pSource: IAMTimelineObj): HResult; stdcall; + function GetNextSrc(out ppSrc: IAMTimelineObj; var pInOut: TReferenceTime): HResult; stdcall; + function GetNextSrc2(out ppSrc: IAMTimelineObj; var pInOut: TREFTIME): HResult; stdcall; + function MoveEverythingBy(Start, MoveBy: TReferenceTime): HResult; stdcall; + function MoveEverythingBy2(Start, MoveBy: TREFTIME): HResult; stdcall; + function GetSourcesCount(var pVal: longint): HResult; stdcall; + function AreYouBlank(var pVal: longint): HResult; stdcall; + function GetSrcAtTime(out ppSrc: IAMTimelineObj; Time: TReferenceTime; SearchDirection: longint): HResult; stdcall; + function GetSrcAtTime2(out ppSrc: IAMTimelineObj; Time: TREFTIME; SearchDirection: longint): HResult; stdcall; + function InsertSpace(rtStart, rtEnd: TReferenceTime): HResult; stdcall; + function InsertSpace2(rtStart, rtEnd: TREFTIME): HResult; stdcall; + function ZeroBetween(rtStart, rtEnd: TReferenceTime): HResult; stdcall; + function ZeroBetween2(rtStart, rtEnd: TREFTIME): HResult; stdcall; + function GetNextSrcEx(pLast: IAMTimelineObj; out ppNext: IAMTimelineObj): HResult; stdcall; + end; + + // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + // This virtual track interface is shared by both the compositions + // and tracks (and groups). + // explained methods: + // TrackGetPriority - used by rendering objects which need to know this. + // SetTrackDirty - !!! not sure if this is useful. + // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMTimelineVirtualTrack;'} + {$EXTERNALSYM IAMTimelineVirtualTrack} + IAMTimelineVirtualTrack = interface(IUnknown) + ['{A8ED5F80-C2C7-11D2-8D39-00A0C9441E20}'] + (*** IAMTimelineVirtualTrack methods ***) + function TrackGetPriority(var pPriority: longint): HResult; stdcall; + function SetTrackDirty: HResult; stdcall; + end; + + // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + // Compositions are like tracks in the sense that they also + // implement IAMVirtualTrack and you can put transitions and effects + // on them, but they really are the SUM of those tracks that they + // contain. They are "embedded" compositions. They should only contain + // media of one particular type (like all video or all audio), but + // this is not enforced. You can add a composition to another + // composition with VTrackInsBefore, just like you can add a track. + // The very top composition to which all other comps and tracks belong + // is a Group, which supports I-AMTimelineGroup as well as I-AMTimelineComp. + // explained methods: + // VTrackInsBefore - does NOT mean VideoTrack. Means Virtual Track. + // Adds a virtual track to a composition at a given priority. + // use -1 to mean "at the end" + // VTrackSwapPriorities - switch two vtracks around. + // VTrackGetCount - get how many vtracks this comp contains. + // GetVTrack - you get the idea + // GetCountOfType - Get the total number of these objects this comp + // and all it's vtracks (recursively) contains. !!! this may be dead. + // GetRecursiveLayerOfType - given a number, returns a given track. This + // is done recursively. You need to pass in a pointer to the number, + // and it will be modified upon exit to an unknown value. DO NOT + // CALL THE VERSION WITH THE POINTER! + // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMTimelineComp;'} + {$EXTERNALSYM IAMTimelineComp} + IAMTimelineComp = interface(IUnknown) + ['{EAE58536-622E-11D2-8CAD-00A024580902}'] + (*** IAMTimelineComp methods ***) + function VTrackInsBefore(pVirtualTrack: IAMTimelineObj; priority: longint): HResult; stdcall; + function VTrackSwapPriorities(VirtualTrackA, VirtualTrackB: longint): HResult; stdcall; + function VTrackGetCount(var pVal: longint): HResult; stdcall; + function GetVTrack(out ppVirtualTrack: IAMTimelineObj; Which: longint): HResult; stdcall; + function GetCountOfType(var pVal, pValWithComps: longint; majortype: integer): HResult; stdcall; // TIMELINE_MAJOR_TYPE + function GetRecursiveLayerOfType(out ppVirtualTrack: IAMTimelineObj; WhichLayer: longint; + Type_: integer): HResult; stdcall; // TIMELINE_MAJOR_TYPE + function GetRecursiveLayerOfTypeI(out ppVirtualTrack: IAMTimelineObj; + var pWhichLayer: longint; Type_: integer): HResult; stdcall; // TIMELINE_MAJOR_TYPE + function GetNextVTrack(pVirtualTrack: IAMTimelineObj; out ppNextVirtualTrack: IAMTimelineObj): HResult; stdcall; + end; + + // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + // Groups represent the topmost composition in a timeline. Every + // group should contain media of only one major type (like all video). + // The timeline can contain multiple groups, see it's interface for + // this. Each group has a particular "media type" that you can get/set + // which help identify it. Each group has an associated FPS which + // is used by the render engine in setting up the big switch. All + // cuts on the timeline will happen rounded to this nearest FPS for + // this particular group. Each group has a priority which enables + // writing out multiple-stream files with 1 or more streams of the + // same type. (Like a 2 video stream AVI file). + // explained methods: + // SetTimeline - this is called internally when the group is added. + // Do not call this. + // GetTimeline - get the timeline this group belongs to. + // GetPriority - get this group's priority + // Get/SetOutputFPS - explained above + // SetMediaTypeForVB - method for VB. Pass in 0 for video, 1 for audio + // SetRecompFormatFromSource - set the recompress format based on the + // source that's loaded or set in the IAMTimelineSrc + // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMTimelineGroup;'} + {$EXTERNALSYM IAMTimelineGroup} + IAMTimelineGroup = interface(IUnknown) + ['{9EED4F00-B8A6-11D2-8023-00C0DF10D434}'] + (*** IAMTimelineGroup methods ***) + function SetTimeline(pTimeline: IAMTimeline): HResult; stdcall; + function GetTimeline(out ppTimeline: IAMTimeline): HResult; stdcall; + function GetPriority(var pPriority: longint): HResult; stdcall; + function GetMediaType(out value: TAMMediaType): HResult; stdcall; + function SetMediaType(value: PAMMediaType): HResult; stdcall; + function SetOutputFPS(FPS: Double): HResult; stdcall; + function GetOutputFPS(var pFPS: Double): HResult; stdcall; + function SetGroupName(const pGroupName: WideString): HResult; stdcall; + function GetGroupName(out pGroupName: WideString): HResult; stdcall; + function SetPreviewMode(fPreview: BOOL): HResult; stdcall; + function GetPreviewMode(var pfPreview: BOOL): HResult; stdcall; + function SetMediaTypeForVB(Val: longint): HResult; stdcall; + function GetOutputBuffering(out pnBuffer: integer): HResult; stdcall; + function SetOutputBuffering(nBuffer: integer): HResult; stdcall; + function SetSmartRecompressFormat(var pFormat: longint): HResult; stdcall; + function GetSmartRecompressFormat(ppFormat: Plongint): HResult; stdcall; + function IsSmartRecompressFormatSet(var pVal: BOOL): HResult; stdcall; + function IsRecompressFormatDirty(var pVal: BOOL): HResult; stdcall; + function ClearRecompressFormatDirty: HResult; stdcall; + function SetRecompFormatFromSource(pSource: IAMTimelineSrc): HResult; stdcall; + end; + + // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + // The main timeline. This is the base object you use to set + // properties of the timeline as a whole, and to create blank + // objects for use within the timeline. You cannot create the + // objects using COM methods, you must go through the timeline to + // create this. That's because certain information is set before + // handing the object back to you. Every object created by the + // timeline will support at LEAST IAMTimelineObj. For any timeline, + // it can have one or more "groups" that it knows about. Each group + // has the capability to hold a complete sub-tree containing media + // that is all of one type. This logical seperation is used for the + // rendering engine, but is not strictly enforced. + // explained methods: + // CreateEmptyNode - pass in a mid type and it will pass back + // an object of the type you requested. + // AddGroup - add a created group to the tree + // RemGroupFromList - make sure timeline no longer knows about this group. + // does NOT do anything to the group itself. Normally the user + // does not want to call this, it's called from the Group's Remove( ) method. + // GetGroup - get a certain group + // GetGroupCount - get how many groups + // ClearAllGroups - clear everything + // GetInsertMode - ask what the insert mode is, overlay or insert + // SetInsertMode - set whether to insert or overlay + // EnableTransitions - turn transitions on or off as a whole + // EnableEffects - same deal. + // SetIntererstRange - discard sub-objects outside of a given + // time range, to save memory/resources + // Get/SetDefaultFPS - set the 'default' FPS for this timeline, + // the RenderEngine reads this information for setting itself up + // by default. + // GetCountOfType - ask for how many of a given thing are in a given + // group. !!! this may be a useless function. + // !!! not implemented + // IsDirty - asks if anything in the timeline needs to be redrawn + // GetDirtyRange - same deal + // ValidateSourceNames - make sure the filenames in the sources + // really exist. Use the same enum flags as the render engine + // uses for SetSourceNameValidation. Source's filenames will be + // changed to those of the found ones in the timeline. + // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMTimeline;'} + {$EXTERNALSYM IAMTimeline} + IAMTimeline = interface(IUnknown) + ['{78530B74-61F9-11D2-8CAD-00A024580902}'] + (*** IAMTimeline methods ***) + function CreateEmptyNode(out ppObj: IAMTimelineObj; Type_: integer): HResult; stdcall; // TIMELINE_MAJOR_TYPE + function AddGroup(pGroup: IAMTimelineObj): HResult; stdcall; + function RemGroupFromList(pGroup: IAMTimelineObj): HResult; stdcall; + function GetGroup(out ppGroup: IAMTimelineObj; WhichGroup: longint): HResult; stdcall; + function GetGroupCount(var pCount: longint): HResult; stdcall; + function ClearAllGroups: HResult; stdcall; + function GetInsertMode(var pMode: longint): HResult; stdcall; + function SetInsertMode(Mode: longint): HResult; stdcall; + function EnableTransitions(fEnabled: BOOL): HResult; stdcall; + function TransitionsEnabled(var pfEnabled: BOOL): HResult; stdcall; + function EnableEffects(fEnabled: BOOL): HResult; stdcall; + function EffectsEnabled(var pfEnabled: BOOL): HResult; stdcall; + function SetInterestRange(Start, Stop: TReferenceTime): HResult; stdcall; + function GetDuration(var pDuration: TReferenceTime): HResult; stdcall; + function GetDuration2(var pDuration: Double): HResult; stdcall; + function SetDefaultFPS(FPS: Double): HResult; stdcall; + function GetDefaultFPS(var pFPS: Double): HResult; stdcall; + function IsDirty(var pDirty: BOOL): HResult; stdcall; + function GetDirtyRange(var pStart, pStop: TReferenceTime): HResult; stdcall; + function GetCountOfType(Group: longint; var pVal, pValWithComps: longint; + majortype: integer): HResult; stdcall; // TIMELINE_MAJOR_TYPE + function ValidateSourceNames(ValidateFlags: longint; pOverride: IMediaLocator; + NotifyEventHandle: integer): HResult; stdcall; + function SetDefaultTransition(const pGuid: TGUID): HResult; stdcall; + function GetDefaultTransition(var pGuid: TGUID): HResult; stdcall; + function SetDefaultEffect(const pGuid: TGUID): HResult; stdcall; + function GetDefaultEffect(var pGuid: TGUID): HResult; stdcall; + function SetDefaultTransitionB(const pGuid: WideString): HResult; stdcall; + function GetDefaultTransitionB(out pGuid: WideString): HResult; stdcall; + function SetDefaultEffectB(const pGuid: WideString): HResult; stdcall; + function GetDefaultEffectB(out pGuid: WideString): HResult; stdcall; + end; + +//////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////// +// XML STUFF --- XML STUFF --- XML STUFF --- XML STUFF --- XML +//////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////// + +//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// Xml2Dex - converts back and forth between XML and a dexter project +//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + + {$HPPEMIT 'typedef System::DelphiInterface _di_IXml2Dex;'} + {$EXTERNALSYM IXml2Dex} + IXml2Dex = interface(IDispatch) + ['{18C628ED-962A-11D2-8D08-00A0C9441E20}'] + (*** IXml2Dex methods ***) + function CreateGraphFromFile(out ppGraph: IUnknown; pTimeline: IUnknown; + const Filename: WideString): HResult; stdcall; + function WriteGrfFile(pGraph: IUnknown; const Filename: WideString): HResult; stdcall; + function WriteXMLFile(pTimeline: IUnknown; const Filename: WideString): HResult; stdcall; + function ReadXMLFile(pTimeline: IUnknown; const XMLName: WideString): HResult; stdcall; + function Delete(pTimeline: IUnknown; dStart, dEnd: Double): HResult; stdcall; + function WriteXMLPart(pTimeline: IUnknown; dStart, dEnd: Double; + const Filename: WideString): HResult; stdcall; + function PasteXMLFile(pTimeline: IUnknown; dStart: Double; const Filename: WideString): HResult; stdcall; + function CopyXML(pTimeline: IUnknown; dStart, dEnd: Double): HResult; stdcall; + function PasteXML(pTimeline: IUnknown; dStart: Double): HResult; stdcall; + function Reset: HResult; stdcall; + function ReadXML(pTimeline: IUnknown; pxml: IUnknown): HResult; stdcall; + function WriteXML(pTimeline: IUnknown; var pbstrXML: WideString): HResult; stdcall; + end; + +//////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////// +// USEFUL HELPER INTERFACES +//////////////////////////////////////////////////////////////// +//////////////////////////////////////////////////////////////// + +//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +// IAMErrorLog - an interface that receives error information from +// a timeline or a render engine. +//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMErrorLog;'} + {$EXTERNALSYM IAMErrorLog} + IAMErrorLog = interface(IUnknown) + ['{E43E73A2-0EFA-11D3-9601-00A0C9441E20}'] + (*** IAMErrorLog methods ***) + function LogError(Severity: longint; const pErrorString: WideString; ErrorCode: longint; + HResult: longint; var pExtraInfo: OleVariant): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMSetErrorLog;'} + {$EXTERNALSYM IAMSetErrorLog} + IAMSetErrorLog = interface(IUnknown) + ['{963566DA-BE21-4EAF-88E9-35704F8F52A1}'] + (*** IAMSetErrorLog methods ***) + function get_ErrorLog(out pVal: IAMErrorLog): HResult; stdcall; + function put_ErrorLog(pVal: IAMErrorLog): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_ISampleGrabberCB;'} + {$EXTERNALSYM ISampleGrabberCB} + ISampleGrabberCB = interface(IUnknown) + ['{0579154A-2B53-4994-B0D0-E773148EFF85}'] + (*** ISampleGrabberCB methods ***) + function SampleCB(SampleTime: Double; pSample: IMediaSample): HResult; stdcall; + function BufferCB(SampleTime: Double; pBuffer: PByte; BufferLen: longint): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_ISampleGrabber;'} + {$EXTERNALSYM ISampleGrabber} + ISampleGrabber = interface(IUnknown) + ['{6B652FFF-11FE-4FCE-92AD-0266B5D7C78F}'] + (*** ISampleGrabber methods ***) + // set this to have the filter immediate stop after + // garnishing a sample + function SetOneShot(OneShot: BOOL): HResult; stdcall; + // set what media type we connect to. It can be partially + // specified by setting only the major type, OR the major and + // subtype, OR major, subtype, and the formattype. + function SetMediaType(var pType: TAMMediaType): HResult; stdcall; + // after something's connected to this filter, find out + // what it is + function GetConnectedMediaType(out pType: TAMMediaType): HResult; stdcall; + // call this to buffer incoming samples, so the next two methods will work + // If this is not called, the next two methods will return + // E_INVALIDARG + function SetBufferSamples(BufferThem: BOOL): HResult; stdcall; + // pass in NULL for pBuffer to get out the buffer size you need to + // allocate. This will NOT return a pointer to a compressed dib + // any longer! It will return the IMediaSample's GetPointer buffer. + function GetCurrentBuffer(var pBufferSize: longint; pBuffer: Pointer): HResult; stdcall; + // return the currently buffered sample + function GetCurrentSample(out ppSample: IMediaSample): HResult; stdcall; + // if this callback is set, then it will be called for + // every sample passing through the filter. Do not take a long time + // in the callback for smooth playback (obviously!) + function SetCallback(pCallback: ISampleGrabberCB; WhichMethodToCallback: longint): HResult; stdcall; + end; + + // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + // resize the input video to an output size, for uniformity within DES. + // DES will set the output media type and probably also put_Size. By setting + // the output media type, DES is stating the resizer must produce only that + // media type on the output pin, unless it is succeeded by a put_Size call. + // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + {$HPPEMIT 'typedef System::DelphiInterface _di_IResize;'} + {$EXTERNALSYM IResize} + IResize = interface(IUnknown) + ['{4ada63a0-72d5-11d2-952a-0060081840bc}'] + (*** IResize methods ***) + function get_Size(out piHeight, piWidth: Integer; out pFlag: LongInt): HResult; stdcall; + function get_InputSize(out piHeight, piWidth: Integer): HResult; stdcall; + function put_Size(Height, Width: Integer; Flag: LongInt): HResult; stdcall; + function get_MediaType(out pmt: TAMMediaType): HResult; stdcall; + function put_MediaType(pmt: PAMMediaType): HResult; stdcall; + end; + +const + E_NOTINTREE = HResult($80040400); + {$EXTERNALSYM E_NOTINTREE} + E_RENDER_ENGINE_IS_BROKEN = HResult($80040401); + {$EXTERNALSYM E_RENDER_ENGINE_IS_BROKEN} + E_MUST_INIT_RENDERER = HResult($80040402); + {$EXTERNALSYM E_MUST_INIT_RENDERER} + E_NOTDETERMINED = HResult($80040403); + {$EXTERNALSYM E_NOTDETERMINED} + E_NO_TIMELINE = HResult($80040404); + {$EXTERNALSYM E_NO_TIMELINE} + S_WARN_OUTPUTRESET = 40404; + {$EXTERNALSYM S_WARN_OUTPUTRESET} + +// These codes are given to the app in IAMErrorLog to help identify what went wrong + +// Filename doesn't exist, or DShow doesn't recognize the filetype +// EXTRA - filename + DEX_IDS_BAD_SOURCE_NAME = 1400; + {$EXTERNALSYM DEX_IDS_BAD_SOURCE_NAME} + +// Filename doesn't exist or contains unknown data +// EXTRA - filename (maybe no codec?) + DEX_IDS_BAD_SOURCE_NAME2 = 1401; + {$EXTERNALSYM DEX_IDS_BAD_SOURCE_NAME2} + +// filename was required, but wasn't given + DEX_IDS_MISSING_SOURCE_NAME = 1402; + {$EXTERNALSYM DEX_IDS_MISSING_SOURCE_NAME} + +// cannot parse data provided by this source +// !!! what source? + DEX_IDS_UNKNOWN_SOURCE = 1403; + {$EXTERNALSYM DEX_IDS_UNKNOWN_SOURCE} + +// unexpected error - some DShow component not installed correctly + DEX_IDS_INSTALL_PROBLEM = 1404; + {$EXTERNALSYM DEX_IDS_INSTALL_PROBLEM} + +// Source filter does not accept filenames +// !!! What source? + DEX_IDS_NO_SOURCE_NAMES = 1405; + {$EXTERNALSYM DEX_IDS_NO_SOURCE_NAMES} + +// The group's mediatype is not supported +// EXTRA - gives you an integer group number + DEX_IDS_BAD_MEDIATYPE = 1406; + {$EXTERNALSYM DEX_IDS_BAD_MEDIATYPE} + +// Invalid stream number for a source +// EXTRA - gives the stream number !!! should identify which source! + DEX_IDS_STREAM_NUMBER = 1407; + {$EXTERNALSYM DEX_IDS_STREAM_NUMBER} + +// You ran out of memory + DEX_IDS_OUTOFMEMORY = 1408; + {$EXTERNALSYM DEX_IDS_OUTOFMEMORY} + +// One bitmap in a sequence was not the same type as the others +// EXTRA - gives the bitmap name + DEX_IDS_DIBSEQ_NOTALLSAME = 1409; + {$EXTERNALSYM DEX_IDS_DIBSEQ_NOTALLSAME} + +// Clip's mediatimes are invalid, or DibSeq too short, or a previous error caused this +// !!! Needs to give the clip name + DEX_IDS_CLIPTOOSHORT = 1410; + {$EXTERNALSYM DEX_IDS_CLIPTOOSHORT} + +// Clsid of FX/Transition is not a DirectX Transform +// EXTRA - gives the CLSID + DEX_IDS_INVALID_DXT = 1411; + {$EXTERNALSYM DEX_IDS_INVALID_DXT} + +// Default FX/Transition Clsid is not a DirectX Transform" +// EXTRA - gives the CLSID + DEX_IDS_INVALID_DEFAULT_DXT = 1412; + {$EXTERNALSYM DEX_IDS_INVALID_DEFAULT_DXT} + +// Your version of DX doesn't support 3D transforms" +// EXTRA - gives the CLSID of the 3D transform you tried to use + DEX_IDS_NO_3D = 1413; + {$EXTERNALSYM DEX_IDS_NO_3D} + +// This DirectX Transform is not the right kind, or is broken +// EXTRA - gives the CLSID of the broken transform + DEX_IDS_BROKEN_DXT = 1414; + {$EXTERNALSYM DEX_IDS_BROKEN_DXT} + +// No such property exists on an object +// EXTRA - gives the name of the property (if given as a string) + DEX_IDS_NO_SUCH_PROPERTY = 1415; + {$EXTERNALSYM DEX_IDS_NO_SUCH_PROPERTY} + +// Illegal value for a property +// EXTRA - gives the VARIANT value that was illegal + DEX_IDS_ILLEGAL_PROPERTY_VAL = 1416; + {$EXTERNALSYM DEX_IDS_ILLEGAL_PROPERTY_VAL} + +// Syntax error in XML file at line: +// EXTRA - gives I4 line number, if available + DEX_IDS_INVALID_XML = 1417; + {$EXTERNALSYM DEX_IDS_INVALID_XML} + +// Can't find filter specified in XML by Category and Instance +// EXTRA - gives friendly name (instance) + DEX_IDS_CANT_FIND_FILTER = 1418; + {$EXTERNALSYM DEX_IDS_CANT_FIND_FILTER} + +// Disk error writing XML file + DEX_IDS_DISK_WRITE_ERROR = 1419; + {$EXTERNALSYM DEX_IDS_DISK_WRITE_ERROR} + +// Clsid not a valid DShow audio effect filter +// EXTRA - gives the CLSID + DEX_IDS_INVALID_AUDIO_FX = 1420; + {$EXTERNALSYM DEX_IDS_INVALID_AUDIO_FX} + +// Cannot find compressor for smart recompression type + DEX_IDS_CANT_FIND_COMPRESSOR = 1421; + {$EXTERNALSYM DEX_IDS_CANT_FIND_COMPRESSOR} + + + +// !!! Here go problems hooking up sources or finding codecs + + +// THE FOLLOWING SHOULD NEVER HAPPEN - please call me if they do + +// Unexpected error in parsing the timeline + DEX_IDS_TIMELINE_PARSE = 1426; + {$EXTERNALSYM DEX_IDS_TIMELINE_PARSE} +// Unexpected error building the filtergraph + DEX_IDS_GRAPH_ERROR = 1427; + {$EXTERNALSYM DEX_IDS_GRAPH_ERROR} +// Unexpected error with the internal grid + DEX_IDS_GRID_ERROR = 1428; + {$EXTERNALSYM DEX_IDS_GRID_ERROR} +// Unexpected error getting an interface + DEX_IDS_INTERFACE_ERROR = 1429; + {$EXTERNALSYM DEX_IDS_INTERFACE_ERROR} + +// these are the enumeration categories for effects +// + CLSID_VideoEffects1Category : TGUID = '{CC7BFB42-F175-11d1-A392-00E0291F3959}'; + {$EXTERNALSYM CLSID_VideoEffects1Category} + CLSID_VideoEffects2Category : TGUID = '{CC7BFB43-F175-11d1-A392-00E0291F3959}'; + {$EXTERNALSYM CLSID_VideoEffects2Category} + CLSID_AudioEffects1Category : TGUID = '{cc7bfb44-f175-11d1-a392-00e0291f3959}'; + {$EXTERNALSYM CLSID_AudioEffects1Category} + CLSID_AudioEffects2Category : TGUID = '{cc7bfb45-f175-11d1-a392-00e0291f3959}'; + {$EXTERNALSYM CLSID_AudioEffects2Category} + +{**************************************************************************} +{* Module Name: mpeguids.h *} +{* This file was inadvertently left out of the DirectX by Microsoft *} +{* Universal ID's for the mpeg decoder property pages. *} +{* *} +{* Copyright (c) 1995 - 1997 Microsoft Corporation. All Rights Reserved.*} +{**************************************************************************} + + IID_IMpegVideoDecoder : TGUID = '{EB1BB270-F71F-11CE-8E85-02608C9BABA2}'; + CLSID_MpegAudioDecodePropertyPage : TGUID = '{CC785860-B2CA-11ce-8D2B-0000E202599C}'; + CLSID_MpegVideoDecodePropertyPage : TGUID = '{E5B4EAA0-B2CA-11ce-8D2B-0000E202599C}'; + CLSID_MMMpeg1VideoCodec : TGUID = '{eafd3a00-a2c7-11d0-b0ac-006097707a2c}'; + VIDEO_DECODER_CLSID : TGUID = '{eafd3a00-a2c7-11d0-b0ac-006097707a2c}'; + CLSID_MMMpeg1AudioCodec : TGUID = '{2cd28f20-a2c8-11d0-b0ac-006097707a2c}'; + AUDIO_DECODER_CLSID : TGUID = '{2cd28f20-a2c8-11d0-b0ac-006097707a2c}'; + +type +// Structure to describe the caps of the mpeg video decoder. + MPEGVideoDecoderCaps = record + VideoMaxBitRate: DWORD + end; + TMPEGVideoDecoderCaps = MPEGVideoDecoderCaps; + +// -------------------------------------------------------------------------------------- +// Structure to hold the contents of an Mpeg 1 sequence header. // +// This structure come from mpgvideo.h in DXMedia SDK!! // +// -------------------------------------------------------------------------------------- + SeqHdrInfo = record // + Width : LongInt; // Native Width in pixels // + Height : LongInt; // Native Height in pixels // + vbv : LongInt; // vbv // + PictureTime : TReferenceTime; // Time per picture in 100ns units // + TimePerFrame : LongInt; // Time per picture in MPEG units // + BitRate : LongInt; // Bits per second // + XPelsPerMeter : LongInt; // Pel aspect ratio // + YPelsPerMeter : LongInt; // Pel aspect ratio // + StartTimeCode : DWORD; // First GOP time code (or -1) // + ActualHeaderLen : LongInt; // Length of valid bytes in raw seq hdr // + RawHeader : array[0..139] of Byte; // The real sequence header // + end; // + TSeqHdrInfo = SeqHdrInfo; + +// -------------------------------------------------------------------------------------- + +// IMpegVideoDecoder not documented... + IMpegVideoDecoder = interface(IUnknown) + ['{EB1BB270-F71F-11CE-8E85-02608C9BABA2}'] + (*** IMpegVideoDecoder methods ***) + procedure get_CurrentDecoderOption(out pOptions: DWORD); stdcall; + procedure set_CurrentDecoderOption(Options: DWORD); stdcall; + procedure get_DefaultDecoderOption(out pOptions: DWORD); stdcall; + procedure set_DefaultDecoderOption(Options: DWORD); stdcall; + procedure get_QualityMsgProcessing(out pfIgnore: BOOL); stdcall; + procedure set_QualityMsgProcessing(fIgnore: BOOL); stdcall; + procedure get_GreyScaleOutput(out pfGrey: BOOL); stdcall; + procedure set_GreyScaleOutput(fGrey: BOOL); stdcall; + procedure get_SequenceHeader(out pSeqHdrInfo: TSeqHdrInfo); stdcall; + procedure get_OutputFormat(out pOutputFormat: DWORD); stdcall; + procedure get_FrameStatistics(out pIFramesDecoded, pPFramesDecoded, stdcall; + pBFramesDecoded, pIFramesSkipped, pPFramesSkipped, pBFramesSkipped: DWORD); + procedure ResetFrameStatistics; stdcall; + procedure get_DecoderPaletteInfo(lpdwFirstEntry, lpdwLastEntry: PDWORD); stdcall; + procedure get_DecoderPaletteEntries(dwStartEntry, dwNumEntries: DWORD; + lppe: PPALETTEENTRY); stdcall; + procedure get_EncryptionKey(out dwEncrptionKey: DWORD); stdcall; + procedure put_EncryptionKey(dwEncrptionKey: DWORD); stdcall; + procedure get_DecoderCaps(out pCaps: TMPEGVideoDecoderCaps); stdcall; + end; + +//------------------------------------------------------------------------------ +// File: DShowASF.h +// +// Copyright (c) 1992-2000, Microsoft Corporation. All rights reserved. +//------------------------------------------------------------------------------ + +const + IID_IConfigAsfWriter : TGUID = (D1:$45086030;D2:$F7E4;D3:$486a;D4:($B5,$04,$82,$6B,$B5,$79,$2A,$3B)); + {$EXTERNALSYM IID_IConfigAsfWriter} + // IID_IWMProfile : TGUID = (D1:$96406bdb;D2:$2b2b;D3:$11d3;D4:($b3,$6b,$00,$c0,$4f,$61,$08,$ff)); + +type +// Interface to control the ASF writer + {$HPPEMIT 'typedef System::DelphiInterface _di_IConfigAsfWriter;'} + {$EXTERNALSYM IConfigAsfWriter} + IConfigAsfWriter = interface(IUnknown) + ['{45086030-F7E4-486a-B504-826BB5792A3B}'] + (*** IConfigAsfWriter methods ***) + // The user is expected to enumerate profiles using the wmsdk IWMProfileManager + // method and then pass the desired profile index to the ASF Writer filter via this + // method. The filter will then try to configure itself for the selected profile. + // + // NOTE: These 2 XXXProfileId methods are now obsolete because they assume + // version 4.0 WMSDK profiles. To configure the filter for later profile + // versions using a profile index, use the XXXProfile methods which take + // the IWMProfile* directly. + function ConfigureFilterUsingProfileId(dwProfileId: DWORD): HResult; stdcall; + function GetCurrentProfileId(out pdwProfileId: DWORD): HResult; stdcall; + // configure using a pre-defined wmsdk profile guid + function ConfigureFilterUsingProfileGuid(const guidProfile: TGUID): HResult; stdcall; + function GetCurrentProfileGuid(out pProfileGuid: TGUID): HResult; stdcall; + // Use these methods when a custom profile setup is preferred + function ConfigureFilterUsingProfile(pProfile: IUnKnown): HResult; stdcall; // IWMProfile in Window Media Format SDK + function GetCurrentProfile(out ppProfile: IUnKnown): HResult; stdcall; // IWMProfile in Window Media Format SDK + // allow app to control whether or not to index file + function SetIndexMode(bIndexFile: BOOL): HResult; stdcall; + function GetIndexMode(out pbIndexFile: BOOL): HResult; stdcall; + end; + +//------------------------------------------------------------------------------ +// File: AMParse.h +// +// Desc: Interface to the parser to get current time. This is useful for +// multifile playback. +// +// Copyright (c) 1996 - 2000, Microsoft Corporation. All rights reserved. +//------------------------------------------------------------------------------ + +const + IID_IAMParse : TGUID = (D1:$c47a3420;D2:$005c;D3:$11d2;D4:($90,$38,$00,$a0,$c9,$69,$72,$98)); +{$EXTERNALSYM IID_IAMParse} + +type +// Parser interface - supported by MPEG-2 splitter filter + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMParse;'} + {$EXTERNALSYM IAMParse} + IAMParse = interface(IUnknown) + ['{c47a3420-005c-11d2-9038-00a0c9697298}'] + (*** IAMParse methods ***) + function GetParseTime(out prtCurrent: TReferenceTime): HResult; stdcall; + function SetParseTime(rtCurrent: TReferenceTime): HResult; stdcall; + function Flush: HResult; stdcall; + end; + +//------------------------------------------------------------------------------ +// File: AudEvCod.h +// +// Desc: List of Audio device error event codes and the expected params. +// +// Copyright (c) 1999 - 2000, Microsoft Corporation. All rights reserved. +//------------------------------------------------------------------------------ + +const + EC_SND_DEVICE_ERROR_BASE = $0200; + {$EXTERNALSYM EC_SND_DEVICE_ERROR_BASE} + +type + _tagSND_DEVICE_ERROR = ( + {$IFNDEF COMPILER6_UP} + SNDDEV_ERROR_INVALID_0, + SNDDEV_ERROR_Open, + {$ELSE} + SNDDEV_ERROR_Open = 1, + {$ENDIF} + SNDDEV_ERROR_Close, + SNDDEV_ERROR_GetCaps, + SNDDEV_ERROR_PrepareHeader, + SNDDEV_ERROR_UnprepareHeader, + SNDDEV_ERROR_Reset, + SNDDEV_ERROR_Restart, + SNDDEV_ERROR_GetPosition, + SNDDEV_ERROR_Write, + SNDDEV_ERROR_Pause, + SNDDEV_ERROR_Stop, + SNDDEV_ERROR_Start, + SNDDEV_ERROR_AddBuffer, + SNDDEV_ERROR_Query + ); + {$EXTERNALSYM _tagSND_DEVICE_ERROR} + SNDDEV_ERR = _tagSND_DEVICE_ERROR; + {$EXTERNALSYM SNDDEV_ERR} + TSndDevErr = SNDDEV_ERR; + +// Sound device error event codes +// ============================== +// +// All audio device error events are always passed on to the application, and are +// never processed by the filter graph + +const + EC_SNDDEV_IN_ERROR = EC_SND_DEVICE_ERROR_BASE + $00; + {$EXTERNALSYM EC_SNDDEV_IN_ERROR} + EC_SNDDEV_OUT_ERROR = EC_SND_DEVICE_ERROR_BASE + $01; + {$EXTERNALSYM EC_SNDDEV_OUT_ERROR} +// Parameters: ( DWORD, DWORD) +// lParam1 is an enum SND_DEVICE_ERROR which notifies the app how the device was +// being accessed when the failure occurred. +// +// lParam2 is the error returned from the sound device call. + +//------------------------------------------------------------------------------ +// File: ATSMedia.h +// +// Desc: Broadcast Driver Architecture Media Definitions for ATSC +// +// Copyright (c) 1996 - 2000, Microsoft Corporation. All rights reserved. +//------------------------------------------------------------------------------ + +//=========================================================================== +// +// ATSC Network Type +// +//=========================================================================== + +const + BDANETWORKTYPE_ATSC : TGUID = '{71985F51-1CA1-11d3-9CC8-00C04F7971E0}'; + {$EXTERNALSYM BDANETWORKTYPE_ATSC} + +//------------------------------------------------------------------------------ +// File: MediaErr.h +// +// Desc: Shell error codes +// +// Copyright (c) 1999 - 2000, Microsoft Corporation. All rights reserved. +//------------------------------------------------------------------------------ +const + DMO_E_INVALIDSTREAMINDEX = HResult($80040201); + {$EXTERNALSYM DMO_E_INVALIDSTREAMINDEX} + DMO_E_INVALIDTYPE = HResult($80040202); + {$EXTERNALSYM DMO_E_INVALIDTYPE} + DMO_E_TYPE_NOT_SET = HResult($80040203); + {$EXTERNALSYM DMO_E_TYPE_NOT_SET} + DMO_E_NOTACCEPTING = HResult($80040204); + {$EXTERNALSYM DMO_E_NOTACCEPTING} + DMO_E_TYPE_NOT_ACCEPTED = HResult($80040205); + {$EXTERNALSYM DMO_E_TYPE_NOT_ACCEPTED} + DMO_E_NO_MORE_ITEMS = HResult($80040206); + {$EXTERNALSYM DMO_E_NO_MORE_ITEMS} + +//------------------------------------------------------------------------------ +// File: MedParam.h +// Desc: Definition of the IMediaParams and associated interfaces. These +// interfaces are designed to allow communication of curve-following +// behaviors for parameters of objects which require dynamic changes +// to their parameters at run time. All changes are specified by +// timestamp and curve type to ensure the parameters can be set +// at sufficient accuracy with predictable behavior on subsequent +// playback of the same curves. +// Copyright (c) 1999 - 2000, Microsoft Corporation. All rights reserved. +//------------------------------------------------------------------------------ + +const + IID_IMediaParamInfo : TGUID = '{6d6cbb60-a223-44aa-842f-a2f06750be6d}'; + {$EXTERNALSYM IID_IMediaParamInfo} + IID_IMediaParams : TGUID = '{6d6cbb61-a223-44aa-842f-a2f06750be6e}'; + {$EXTERNALSYM IID_IMediaParams} + + GUID_TIME_REFERENCE : TGUID = (D1:$93ad712b;D2:$daa0;D3:$4ffe;D4:($bc,$81,$b0,$ce,$50,$f ,$cd,$d9)); + {$EXTERNALSYM GUID_TIME_REFERENCE} + GUID_TIME_MUSIC : TGUID = (D1:$574c49d ;D2:$5b04;D3:$4b15;D4:($a5,$42,$ae,$28,$20,$30,$11,$7b)); + {$EXTERNALSYM GUID_TIME_MUSIC} + GUID_TIME_SAMPLES : TGUID = (D1:$a8593d05;D2:$c43 ;D3:$4984;D4:($9a,$63,$97,$af,$9e,$2 ,$c4,$c0)); + {$EXTERNALSYM GUID_TIME_SAMPLES} + +type + MP_DATA = {$IFDEF TYPE_IDENTITY}type {$ENDIF} Single; + {$EXTERNALSYM MP_DATA} + MPData = MP_DATA; + + _MP_Type = ( + MPT_INT, + MPT_FLOAT, + MPT_BOOL, + MPT_ENUM, + MPT_MAX + ); + {$EXTERNALSYM _MP_Type} + MP_TYPE = _MP_Type; + {$EXTERNALSYM MP_TYPE} + TMPTYPE = MP_TYPE; + +const + MPBOOL_TRUE = 1; + {$EXTERNALSYM MPBOOL_TRUE} + MPBOOL_FALSE = 0; + {$EXTERNALSYM MPBOOL_FALSE} + +type + MP_CURVE_TYPE = {$IFDEF TYPE_IDENTITY}type {$ENDIF} LongWord; + {$EXTERNALSYM MP_CURVE_TYPE} + MPCurveType = MP_CURVE_TYPE; + const + MP_CURVE_JUMP = $1; + {$EXTERNALSYM MP_CURVE_JUMP} + MP_CURVE_LINEAR = $2; + {$EXTERNALSYM MP_CURVE_LINEAR} + MP_CURVE_SQUARE = $4; + {$EXTERNALSYM MP_CURVE_SQUARE} + MP_CURVE_INVSQUARE = $8; + {$EXTERNALSYM MP_CURVE_INVSQUARE} + MP_CURVE_SINE = $10; + {$EXTERNALSYM MP_CURVE_SINE} + +type + MP_CAPS = {$IFDEF TYPE_IDENTITY}type {$ENDIF} DWORD; + {$EXTERNALSYM MP_CAPS} + MPCaps = MP_CAPS; + const + MP_CAPS_CURVE_JUMP = MP_CURVE_JUMP; + {$EXTERNALSYM MP_CAPS_CURVE_JUMP} + MP_CAPS_CURVE_LINEAR = MP_CURVE_LINEAR; + {$EXTERNALSYM MP_CAPS_CURVE_LINEAR} + MP_CAPS_CURVE_SQUARE = MP_CURVE_SQUARE; + {$EXTERNALSYM MP_CAPS_CURVE_SQUARE} + MP_CAPS_CURVE_INVSQUARE = MP_CURVE_INVSQUARE; + {$EXTERNALSYM MP_CAPS_CURVE_INVSQUARE} + MP_CAPS_CURVE_SINE = MP_CURVE_SINE; + {$EXTERNALSYM MP_CAPS_CURVE_SINE} + +type + _MP_PARAMINFO = record + mpType : TMPType; + mopCaps : MPCaps; + mpdMinValue : MPData; + mpdMaxValue : MPData; + mpdNeutralValue : MPData; + szUnitText : array[0..31] of WCHAR; + szLabel : array[0..31] of WCHAR; + end; + {$EXTERNALSYM _MP_PARAMINFO} + MP_PARAMINFO = _MP_PARAMINFO; + {$EXTERNALSYM MP_PARAMINFO} + TMPParamInfo = _MP_PARAMINFO; + +const + DWORD_ALLPARAMS = -1; + {$EXTERNALSYM DWORD_ALLPARAMS} + +type + MP_TIMEDATA = {$IFDEF TYPE_IDENTITY}type {$ENDIF} DWORD; + {$EXTERNALSYM MP_TIMEDATA} + MPTimeData = MP_TIMEDATA; + + MP_FLAGS = {$IFDEF TYPE_IDENTITY}type {$ENDIF} DWORD; + {$EXTERNALSYM MP_FLAGS} + MPFlags = MP_FLAGS; + +const + MPF_ENVLP_STANDARD = $0; + {$EXTERNALSYM MPF_ENVLP_STANDARD} + MPF_ENVLP_BEGIN_CURRENTVAL = $1; + {$EXTERNALSYM MPF_ENVLP_BEGIN_CURRENTVAL} + MPF_ENVLP_BEGIN_NEUTRALVAL = $2; + {$EXTERNALSYM MPF_ENVLP_BEGIN_NEUTRALVAL} + +type + _MP_ENVELOPE_SEGMENT = record + rtStart : TReferenceTime; + rtEnd : TReferenceTime; + valStart : MPData; + valEnd : MPData; + iCurve : MPCURVETYPE; + flags : MPFlags; + end; + {$EXTERNALSYM _MP_ENVELOPE_SEGMENT} + MP_ENVELOPE_SEGMENT = _MP_ENVELOPE_SEGMENT; + {$EXTERNALSYM MP_ENVELOPE_SEGMENT} + TMPEnvelopeSegment = _MP_ENVELOPE_SEGMENT; + + +const + MPF_PUNCHIN_REFTIME = $0; + {$EXTERNALSYM MPF_PUNCHIN_REFTIME} + MPF_PUNCHIN_NOW = $1; + {$EXTERNALSYM MPF_PUNCHIN_NOW} + MPF_PUNCHIN_STOPPED = $2; + {$EXTERNALSYM MPF_PUNCHIN_STOPPED} + +type + {$HPPEMIT 'typedef System::DelphiInterface _di_IMediaParamInfo;'} + {$EXTERNALSYM IMediaParamInfo} + IMediaParamInfo = interface(IUnknown) + ['{6d6cbb60-a223-44aa-842f-a2f06750be6d}'] + (*** IMediaParamInfo methods ***) + function GetParamCount(out pdwParams: DWORD): HResult; stdcall; + function GetParamInfo(dwParamIndex: DWORD; out pInfo: TMPPARAMINFO): HResult; stdcall; + function GetParamText(dwParamIndex: DWORD; out ppwchText: PWideChar): HResult; stdcall; + function GetNumTimeFormats(out pdwNumTimeFormats: DWORD): HResult; stdcall; + function GetSupportedTimeFormat(dwFormatIndex: DWORD; out pguidTimeFormat: TGUID): HResult; stdcall; + function GetCurrentTimeFormat(out pguidTimeFormat: TGUID; out pTimeData: MPTimeData): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IMediaParams;'} + {$EXTERNALSYM IMediaParams} + IMediaParams = interface(IUnknown) + ['{6d6cbb61-a223-44aa-842f-a2f06750be6e}'] + (*** IMediaParams methods ***) + function GetParam(dwParamIndex: DWORD; out pValue: MPData): HResult; stdcall; + function SetParam(dwParamIndex: DWORD; value: MPData): HResult; stdcall; + function AddEnvelope(dwParamIndex, cSegments: DWORD; var pEnvelopeSegments: TMPENVELOPESEGMENT): HResult; stdcall; + function FlushEnvelope(dwParamIndex: DWORD; refTimeStart, refTimeEnd: TReferenceTime): HResult; stdcall; + function SetTimeFormat(const guidTimeFormat: TGUID; mpTimeData: MPTimeData): HResult; stdcall; + end; + +//------------------------------------------------------------------------------ +// File: mediaobj.h +// Desc: Define the interfaces for DirectX Media Objects. +// Copyright (c) 1999 - 2000, Microsoft Corporation. All rights reserved. +//------------------------------------------------------------------------------ + +const + IID_IMediaBuffer : TGUID = '{59eff8b9-938c-4a26-82f2-95cb84cdc837}'; + {$EXTERNALSYM IID_IMediaBuffer} + IID_IMediaObject : TGUID = '{d8ad0f58-5494-4102-97c5-ec798e59bcf4}'; + {$EXTERNALSYM IID_IMediaObject} + IID_IEnumDMO : TGUID = '{2c3cd98a-2bfa-4a53-9c27-5249ba64ba0f}'; + {$EXTERNALSYM IID_IEnumDMO} + IID_IMediaObjectInPlace : TGUID = '{651b9ad0-0fc7-4aa9-9538-d89931010741}'; + {$EXTERNALSYM IID_IMediaObjectInPlace} + IID_IDMOQualityControl : TGUID = '{65abea96-cf36-453f-af8a-705e98f16260}'; + {$EXTERNALSYM IID_IDMOQualityControl} + IID_IDMOVideoOutputOptimizations : TGUID = '{be8f4f4e-5b16-4d29-b350-7f6b5d9298ac}'; + {$EXTERNALSYM IID_IDMOVideoOutputOptimizations} + +type +// DMO_MEDIA_TYPE structure + DMO_MEDIA_TYPE = AM_MEDIA_TYPE; + {$EXTERNALSYM DMO_MEDIA_TYPE} + PDMOMediaType = ^TDMOMediaType; + TDMOMediaType = DMO_MEDIA_TYPE; + +const +// Per-buffer flags that apply to input buffers + DMO_INPUT_DATA_BUFFERF_SYNCPOINT = $1; + {$EXTERNALSYM DMO_INPUT_DATA_BUFFERF_SYNCPOINT} + DMO_INPUT_DATA_BUFFERF_TIME = $2; + {$EXTERNALSYM DMO_INPUT_DATA_BUFFERF_TIME} + DMO_INPUT_DATA_BUFFERF_TIMELENGTH = $4; + {$EXTERNALSYM DMO_INPUT_DATA_BUFFERF_TIMELENGTH} + +// Per-buffer flags that apply to output buffers. + DMO_OUTPUT_DATA_BUFFERF_SYNCPOINT = $1; + {$EXTERNALSYM DMO_OUTPUT_DATA_BUFFERF_SYNCPOINT} + DMO_OUTPUT_DATA_BUFFERF_TIME = $2; + {$EXTERNALSYM DMO_OUTPUT_DATA_BUFFERF_TIME} + DMO_OUTPUT_DATA_BUFFERF_TIMELENGTH = $4; + {$EXTERNALSYM DMO_OUTPUT_DATA_BUFFERF_TIMELENGTH} + // This flag means the object could have generated more data for this + // output stream, even with no additional input from any input stream, + // but the output buffer did not have sufficient room. + DMO_OUTPUT_DATA_BUFFERF_INCOMPLETE = $1000000; + {$EXTERNALSYM DMO_OUTPUT_DATA_BUFFERF_INCOMPLETE} + +// Flags returned by GetInputStatus() + // ACCEPT_DATA indicates that the input stream is ready to accept + // new data via ProcessInput(). + DMO_INPUT_STATUSF_ACCEPT_DATA = $1; + {$EXTERNALSYM DMO_INPUT_STATUSF_ACCEPT_DATA} + +// Flags returned by GetInputStreamInfo() + DMO_INPUT_STREAMF_WHOLE_SAMPLES = $1; + {$EXTERNALSYM DMO_INPUT_STREAMF_WHOLE_SAMPLES} + DMO_INPUT_STREAMF_SINGLE_SAMPLE_PER_BUFFER = $2; + {$EXTERNALSYM DMO_INPUT_STREAMF_SINGLE_SAMPLE_PER_BUFFER} + DMO_INPUT_STREAMF_FIXED_SAMPLE_SIZE = $4; + {$EXTERNALSYM DMO_INPUT_STREAMF_FIXED_SAMPLE_SIZE} + DMO_INPUT_STREAMF_HOLDS_BUFFERS = $8; + {$EXTERNALSYM DMO_INPUT_STREAMF_HOLDS_BUFFERS} + +// Flags returned by GetOutputStreamInfo() + DMO_OUTPUT_STREAMF_WHOLE_SAMPLES = $1; + {$EXTERNALSYM DMO_OUTPUT_STREAMF_WHOLE_SAMPLES} + DMO_OUTPUT_STREAMF_SINGLE_SAMPLE_PER_BUFFER = $2; + {$EXTERNALSYM DMO_OUTPUT_STREAMF_SINGLE_SAMPLE_PER_BUFFER} + DMO_OUTPUT_STREAMF_FIXED_SAMPLE_SIZE = $4; + {$EXTERNALSYM DMO_OUTPUT_STREAMF_FIXED_SAMPLE_SIZE} + DMO_OUTPUT_STREAMF_DISCARDABLE = $8; + {$EXTERNALSYM DMO_OUTPUT_STREAMF_DISCARDABLE} + DMO_OUTPUT_STREAMF_OPTIONAL = $10; + {$EXTERNALSYM DMO_OUTPUT_STREAMF_OPTIONAL} + +// SetType flags + DMO_SET_TYPEF_TEST_ONLY = $1; + {$EXTERNALSYM DMO_SET_TYPEF_TEST_ONLY} + DMO_SET_TYPEF_CLEAR = $2; + {$EXTERNALSYM DMO_SET_TYPEF_CLEAR} + +// Process Output Flags + DMO_PROCESS_OUTPUT_DISCARD_WHEN_NO_BUFFER = $1; + {$EXTERNALSYM DMO_PROCESS_OUTPUT_DISCARD_WHEN_NO_BUFFER} + +type +// Buffer wrapper interface + {$HPPEMIT 'typedef System::DelphiInterface _di_IMediaBuffer;'} + {$EXTERNALSYM IMediaBuffer} + IMediaBuffer = interface(IUnknown) + ['{59eff8b9-938c-4a26-82f2-95cb84cdc837}'] + (*** IMediaBuffer methods ***) + function SetLength(cbLength: DWORD): HResult; stdcall; + function GetMaxLength(out pcbMaxLength: DWORD): HResult; stdcall; + function GetBufferAndLength(out ppBuffer: PByte; // not filled if NULL + out pcbLength: DWORD // not filled if NULL + ): HResult; stdcall; + end; + + +// Output buffer info structure: one of these must be passed in for each +// output stream with every ProcessOutput() call +// All [out] fields should be +// assumed undefined if ProcessOutput() failed + PDMOOutputDataBuffer = ^TDMOOutputDataBuffer; + _DMO_OUTPUT_DATA_BUFFER = record + pBuffer : IMediaBuffer; // [in] can be NULL + // ProcessOutput() must set any appropriate flags and zero out the rest. + dwStatus : DWORD; // [out] DMO_OUTPUT_DATA_BUFFERF_XXX (INCOMPLETE, etc.) + // Each of these is valid if the corresponding flag is set in dwStatus + rtTimestamp : TReferenceTime; // [out] + rtTimelength : TReferenceTime; // [out] + end; + {$EXTERNALSYM _DMO_OUTPUT_DATA_BUFFER} + DMO_OUTPUT_DATA_BUFFER = _DMO_OUTPUT_DATA_BUFFER; + {$EXTERNALSYM DMO_OUTPUT_DATA_BUFFER} + TDMOOutputDataBuffer = _DMO_OUTPUT_DATA_BUFFER; + + PDMO_OUTPUT_DATA_BUFFER = ^_DMO_OUTPUT_DATA_BUFFER; + {$EXTERNALSYM PDMO_OUTPUT_DATA_BUFFER} + + PDMOOutputDataBufferArray = ^TDMOOutputDataBufferArray; + TDMOOutputDataBufferArray = array [0..0] of TDMOOutputDataBuffer; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IMediaObject;'} + {$EXTERNALSYM IMediaObject} + IMediaObject = interface(IUnknown) + ['{d8ad0f58-5494-4102-97c5-ec798e59bcf4}'] + (*** IMediaObject methods ***) + function GetStreamCount(out pcInputStreams, pcOutputStreams: DWORD): HResult; stdcall; + function GetInputStreamInfo(dwInputStreamIndex: DWORD; out pdwFlags: DWORD): HResult; stdcall; + function GetOutputStreamInfo(dwOutputStreamIndex: DWORD; out pdwFlags: DWORD): HResult; stdcall; + function GetInputType(dwInputStreamIndex, dwTypeIndex: DWORD; out pmt: TDMOMediaType): HResult; stdcall; + function GetOutputType(dwOutputStreamIndex, dwTypeIndex: DWORD; out pmt: TDMOMediaType): HResult; stdcall; + function SetInputType(dwInputStreamIndex: DWORD; const pmt: PDMOMediaType; dwFlags: DWORD): HResult; stdcall; + function SetOutputType(dwOutputStreamIndex: DWORD; const pmt: PDMOMediaType; dwFlags: DWORD): HResult; stdcall; + function GetInputCurrentType(dwInputStreamIndex: DWORD; out pmt: TDMOMediaType): HResult; stdcall; + function GetOutputCurrentType(dwOutputStreamIndex: DWORD; out pmt: TDMOMediaType): HResult; stdcall; + function GetInputSizeInfo(dwInputStreamIndex: DWORD; out pcbSize, pcbMaxLookahead, pcbAlignment: DWORD): HResult; stdcall; + function GetOutputSizeInfo(dwOutputStreamIndex: DWORD; out pcbSize, pcbAlignment: DWORD): HResult; stdcall; + function GetInputMaxLatency(dwInputStreamIndex: DWORD; out prtMaxLatency: TReferenceTime): HResult; stdcall; + function SetInputMaxLatency(dwInputStreamIndex: DWORD; rtMaxLatency: TReferenceTime): HResult; stdcall; + function Flush: HResult; stdcall; + function Discontinuity(dwInputStreamIndex: DWORD): HResult; stdcall; + function AllocateStreamingResources: HResult; stdcall; + function FreeStreamingResources: HResult; stdcall; + function GetInputStatus(dwInputStreamIndex: DWORD; out dwFlags: DWORD): HResult; stdcall; + function ProcessInput(dwInputStreamIndex: DWORD; pBuffer: IMediaBuffer; dwFlags: DWORD; + rtTimestamp, rtTimelength: TReferenceTime): HResult; stdcall; + function ProcessOutput(dwFlags, cOutputBufferCount: DWORD; var pOutputBuffers: TDMOOutputDataBufferArray; + out pdwStatus: DWORD): HResult; stdcall; + function Lock(bLock: longint): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IEnumDMO;'} + {$EXTERNALSYM IEnumDMO} + IEnumDMO = interface(IUnknown) + ['{2c3cd98a-2bfa-4a53-9c27-5249ba64ba0f}'] + (*** IEnumDMO methods ***) + function Next(cItemsToFetch: DWORD; out pCLSID: TGUID; out Names: PWideChar; + pcItemsFetched: PDWORD): HResult; stdcall; + function Skip(cItemsToSkip: DWORD): HResult; stdcall; + function Reset: HResult; stdcall; + function Clone(out ppEnum: IEnumDMO): HResult; stdcall; + end; + +const + DMO_INPLACE_NORMAL = $0; + {$EXTERNALSYM DMO_INPLACE_NORMAL} + DMO_INPLACE_ZERO = $1; + {$EXTERNALSYM DMO_INPLACE_ZERO} + +type + {$HPPEMIT 'typedef System::DelphiInterface _di_IMediaObjectInPlace;'} + {$EXTERNALSYM IMediaObjectInPlace} + IMediaObjectInPlace = interface(IUnknown) + ['{651b9ad0-0fc7-4aa9-9538-d89931010741}'] + (*** IMediaObjectInPlace methods ***) + function Process(ulSize: ULONG; {in/out} pData: Pointer; refTimeStart: TReferenceTime; + dwFlags: DWORD): HResult; stdcall; + function Clone(out ppMediaObject: IMediaObjectInPlace): HResult; stdcall; + function GetLatency(out pLatencyTime: TReferenceTime): HResult; stdcall; + end; + +const + DMO_QUALITY_STATUS_ENABLED = $1; + {$EXTERNALSYM DMO_QUALITY_STATUS_ENABLED} + +type + {$HPPEMIT 'typedef System::DelphiInterface _di_IDMOQualityControl;'} + {$EXTERNALSYM IDMOQualityControl} + IDMOQualityControl = interface(IUnknown) + ['{65abea96-cf36-453f-af8a-705e98f16260}'] + (*** IDMOQualityControl methods ***) + function SetNow(rtNow: TReferenceTime): HResult; stdcall; + function SetStatus(dwFlags: DWORD): HResult; stdcall; + function GetStatus(out pdwFlags: DWORD): HResult; stdcall; + end; + +const + DMO_VOSF_NEEDS_PREVIOUS_SAMPLE = $1; + {$EXTERNALSYM DMO_VOSF_NEEDS_PREVIOUS_SAMPLE} + +type + {$HPPEMIT 'typedef System::DelphiInterface _di_IDMOVideoOutputOptimizations;'} + {$EXTERNALSYM IDMOVideoOutputOptimizations} + IDMOVideoOutputOptimizations = interface(IUnknown) + ['{be8f4f4e-5b16-4d29-b350-7f6b5d9298ac}'] + (*** IDMOVideoOutputOptimizations methods ***) + function QueryOperationModePreferences(ulOutputStreamIndex: ULONG; + var pdwRequestedCapabilities: DWORD): HResult; stdcall; + function SetOperationMode(ulOutputStreamIndex: ULONG; + dwEnabledFeatures: DWORD): HResult; stdcall; + function GetCurrentOperationMode(ulOutputStreamIndex: ULONG; + var pdwEnabledFeatures: DWORD): HResult; stdcall; + function GetCurrentSampleRequirements(ulOutputStreamIndex: ULONG; + var pdwRequestedFeatures: DWORD): HResult; stdcall; + end; + +(************************************************************************ +* * +* dmodshow.h -- This module defines the DirectMusic core API's * +* * +* Copyright (c) 1998, Microsoft Corp. All rights reserved. * +* * +************************************************************************) +const + IID_IDMOWrapperFilter : TGUID = '{52d6f586-9f0f-4824-8fc8-e32ca04930c2}'; + {$EXTERNALSYM IID_IDMOWrapperFilter} + CLSID_DMOWrapperFilter : TGUID = '{94297043-bd82-4dfd-b0de-8177739c6d20}'; + {$EXTERNALSYM CLSID_DMOWrapperFilter} + CLSID_DMOFilterCategory : TGUID = '{bcd5796c-bd52-4d30-ab76-70f975b89199}'; + {$EXTERNALSYM CLSID_DMOFilterCategory} + +type + {$HPPEMIT 'typedef System::DelphiInterface _di_IDMOWrapperFilter;'} + {$EXTERNALSYM IDMOWrapperFilter} + IDMOWrapperFilter = interface(IUnknown) + ['{52d6f586-9f0f-4824-8fc8-e32ca04930c2}'] + (*** IDMOWrapperFilter methods ***) + function Init(const clsidDMO, catDMO: TGUID): HResult; stdcall; + end; + +//------------------------------------------------------------------------------ +// File: DMOReg.h +// +// Desc: +// +// Copyright (c) 1999 - 2000, Microsoft Corporation. All rights reserved. +//------------------------------------------------------------------------------ + +const + DMOCATEGORY_AUDIO_DECODER : TGUID = '{57f2db8b-e6bb-4513-9d43-dcd2a6593125}'; + {$EXTERNALSYM DMOCATEGORY_AUDIO_DECODER} + DMOCATEGORY_AUDIO_ENCODER : TGUID = '{33D9A761-90C8-11d0-BD43-00A0C911CE86}'; + {$EXTERNALSYM DMOCATEGORY_AUDIO_ENCODER} + DMOCATEGORY_VIDEO_DECODER : TGUID = '{4a69b442-28be-4991-969c-b500adf5d8a8}'; + {$EXTERNALSYM DMOCATEGORY_VIDEO_DECODER} + DMOCATEGORY_VIDEO_ENCODER : TGUID = '{33D9A760-90C8-11d0-BD43-00A0C911CE86}'; + {$EXTERNALSYM DMOCATEGORY_VIDEO_ENCODER} + DMOCATEGORY_AUDIO_EFFECT : TGUID = '{f3602b3f-0592-48df-a4cd-674721e7ebeb}'; + {$EXTERNALSYM DMOCATEGORY_AUDIO_EFFECT} + DMOCATEGORY_VIDEO_EFFECT : TGUID = '{d990ee14-776c-4723-be46-3da2f56f10b9}'; + {$EXTERNALSYM DMOCATEGORY_VIDEO_EFFECT} + DMOCATEGORY_AUDIO_CAPTURE_EFFECT : TGUID = '{f665aaba-3e09-4920-aa5f-219811148f09}'; + {$EXTERNALSYM DMOCATEGORY_AUDIO_CAPTURE_EFFECT} + +// Acoustic Echo Canceller {BF963D80-C559-11D0-8A2B-00A0C9255AC1} +// Matches KSNODETYPE_ACOUSTIC_ECHO_CANCEL in ksmedia.h + DMOCATEGORY_ACOUSTIC_ECHO_CANCEL : TGUID = '{BF963D80-C559-11D0-8A2B-00A0C9255AC1}'; + {$EXTERNALSYM DMOCATEGORY_ACOUSTIC_ECHO_CANCEL} + +// Noise Supression {E07F903F-62FD-4e60-8CDD-DEA7236665B5} +// Matches KSNODETYPE_AUDIO_NOISE_SUPPRESS in post Windows ME DDK's ksmedia.h + DMOCATEGORY_AUDIO_NOISE_SUPPRESS : TGUID = '{E07F903F-62FD-4e60-8CDD-DEA7236665B5}'; + {$EXTERNALSYM DMOCATEGORY_AUDIO_NOISE_SUPPRESS} + +// Automatic Gain Control {E88C9BA0-C557-11D0-8A2B-00A0C9255AC1} +// Matches KSNODETYPE_AGC in ksmedia.h + DMOCATEGORY_AGC : TGUID = '{E88C9BA0-C557-11D0-8A2B-00A0C9255AC1}'; + {$EXTERNALSYM DMOCATEGORY_AGC} + +type + PDMOPartialMediaType = ^TDMOPartialMediaType; + _DMO_PARTIAL_MEDIATYPE = record + type_ : TGUID; + subtype : TGUID; + end; + {$EXTERNALSYM _DMO_PARTIAL_MEDIATYPE} + DMO_PARTIAL_MEDIATYPE = _DMO_PARTIAL_MEDIATYPE; + {$EXTERNALSYM DMO_PARTIAL_MEDIATYPE} + PDMO_PARTIAL_MEDIATYPE = ^DMO_PARTIAL_MEDIATYPE; + {$EXTERNALSYM PDMO_PARTIAL_MEDIATYPE} + TDMOPartialMediaType = _DMO_PARTIAL_MEDIATYPE; + +const + DMO_REGISTERF_IS_KEYED = $00000001; + {$EXTERNALSYM DMO_REGISTERF_IS_KEYED} + DMO_ENUMF_INCLUDE_KEYED = $00000001; + {$EXTERNALSYM DMO_ENUMF_INCLUDE_KEYED} + +type + TDMOName = array[0..79] of WCHAR; + + function DMORegister(szName: PWideChar; const clsidDMO, guidCategory: TGUID; dwFlags: DWORD; // DMO_REGISTERF_XXX + // Register all mediatypes supported by the object. This carries no + // information about which combinations of input/output types would + // actually work. + cInTypes: DWORD; const pInTypes: PDMO_PARTIAL_MEDIATYPE; cOutTypes: DWORD; + const pOutTypes: PDMO_PARTIAL_MEDIATYPE): HResult; stdcall; + {$EXTERNALSYM DMORegister} + + function DMOUnregister(const clsidDMO, + guidCategory: TGUID// optional - GUID_NULL means unregister from all + ): HResult; stdcall; + {$EXTERNALSYM DMOUnregister} + + + function DMOEnum( + const guidCategory: TGUID; // GUID_NULL for "all" + dwFlags: DWORD; // DMO_ENUMF_XXX + // + // Enumerate only objects that support at least one of the specified input types + // and at least one of the specified output types. If no input types are specified, + // enumerate objects regardless of what input types they support. Same for + // output types. + // + cInTypes: DWORD; + pInTypes: PDMO_PARTIAL_MEDIATYPE; // can be NULL only of ulInTypes = 0 + cOutTypes: DWORD; + pOutTypes: PDMO_PARTIAL_MEDIATYPE; // can be NULL only of ulOutTypes = 0 + // + // Output parameter - this receives a pointer to the DMO CLSID enumerator + // + out ppEnum: IEnumDMO): HResult; stdcall; + {$EXTERNALSYM DMOEnum} + + function DMOGetTypes( + const clsidDMO: TGUID; + ulInputTypesRequested: ULONG; + pulInputTypesSupplied: PULONG; + pInputTypes: PDMO_PARTIAL_MEDIATYPE; + ulOutputTypesRequested: ULONG; + pulOutputTypesSupplied: PULONG; + pOutputTypes: PDMO_PARTIAL_MEDIATYPE): HResult; stdcall; + {$EXTERNALSYM DMOGetTypes} + + function DMOGetName(const clsidDMO: TGUID; szName: TDMOName): HResult; stdcall; + {$EXTERNALSYM DMOGetName} + +//------------------------------------------------------------------------------ +// File: DMORt.h +// +// Desc: Miscellaneous runtime support for DirectShow Media Objects +// +// Copyright (c) 1999 - 2000, Microsoft Corporation. All rights reserved. +//------------------------------------------------------------------------------ + +// Mediatype helpers. MoInitMediaType() goes with MoFreeMediaType(), +// MoCreateMediaType() goes with MoDeleteMediaType() - don't mix ! + +// Takes a pointer to an already allocated DMO_MEDIA_TYPE structure, allocates +// a format block of cbFormat bytes, and sets appropriate members of +// DMO_MEDIA_TYPE to point to the newly allocated format block. Also +// initializes the IUnknown pointer inside DMO_MEDIA_TYPE to NULL. +// +// The format block allocated by MoInitMediaType must be freed by calling +// MoFreeMediaType(). + function MoInitMediaType(pmt: PDMOMediaType; cbFormat: DWORD): HResult; stdcall; + {$EXTERNALSYM MoInitMediaType} + +// Frees the format block and releases any IUnknown, but does not free the +// DMO_MEDIA_TYPE structure itself. Input parameter must point to an +// DMO_MEDIA_TYPE structure previously initialized by MoInitMediaType(). + function MoFreeMediaType(pmt: PDMOMediaType): HResult; stdcall; + {$EXTERNALSYM MoFreeMediaType} + +// Copies the DMO_MEDIA_TYPE members. Also duplicates the format block and +// the IUnknown pointer. Both parameters must point to valid DMO_MEDIA_TYPE +// structures. Target structure must be later freed using MoFreeMediaType(). + function MoCopyMediaType(out pmtDest: TDMOMediaType; const pmtSrc: PDMOMediaType): HResult; stdcall; + {$EXTERNALSYM MoCopyMediaType} + +// Allocates a new DMO_MEDIA_TYPE structure and initializes it just like +// MoInitMediaType. I.e., this function allocates both the format block +// and the DMO_MEDIA_TYPE structure itself. Pointer to DMO_MEDIA_TYPE is +// returned as *ppmt. +// +// DMO_MEDIA_TYPE structures allocated by MoCreateMediaType() must be freed +// by calling MoDeleteMediaType(). + function MoCreateMediaType(out ppmt: PDMOMediaType; cbFormat: DWORD): HResult; stdcall; + {$EXTERNALSYM MoCreateMediaType} + +// Frees any format block, releases any IUnknown, and deletes the +// DMO_MEDIA_TYPE structure itself. The input parameter must point to an +// DMO_MEDIA_TYPE structure previously allocated by MoCreateMediaType(). + function MoDeleteMediaType(pmt: PDMOMediaType): HResult; stdcall; + {$EXTERNALSYM MoDeleteMediaType} + +// Allocates a new DMO_MEDIA_TYPE structure and copies pmtSrc into it like +// MoCopyMediaType. I.e., this function allocates a new DMO_MEDIA_TYPE struct +// as well as a new format block for the target mediatype. Trager mediatype +// must later be freed using MoDeleteMediaType(). + function MoDuplicateMediaType(out ppmtDest: PDMOMediaType; const pmtSrc: PDMOMediaType): HResult; stdcall; + {$EXTERNALSYM MoDuplicateMediaType} + +{=============================================================================== + * + * Copyright (C) Microsoft Corporation, 1996 - 1999 + * + * Module Name: ks.h + * Abstract: + * Windows Driver Model/Connection and Streaming Architecture (WDM-CSA) + * core definitions. + * + * Note : All _NTDDK_ specific definitions have been removed from original file + * because never used in DX8SDK. + ===============================================================================} +const +//=========================================================================== + IOCTL_KS_PROPERTY = DWORD(3080195); + {$EXTERNALSYM IOCTL_KS_PROPERTY} + IOCTL_KS_ENABLE_EVENT = DWORD(3080199); + {$EXTERNALSYM IOCTL_KS_ENABLE_EVENT} + IOCTL_KS_DISABLE_EVENT = DWORD(3080203); + {$EXTERNALSYM IOCTL_KS_DISABLE_EVENT} + IOCTL_KS_METHOD = DWORD(3080207); + {$EXTERNALSYM IOCTL_KS_METHOD} + IOCTL_KS_WRITE_STREAM = DWORD(3112979); + {$EXTERNALSYM IOCTL_KS_WRITE_STREAM} + IOCTL_KS_READ_STREAM = DWORD(3096599); + {$EXTERNALSYM IOCTL_KS_READ_STREAM} + IOCTL_KS_RESET_STATE = DWORD(3080219); + {$EXTERNALSYM IOCTL_KS_RESET_STATE} +//=========================================================================== + +type + KSRESET = ( + KSRESET_BEGIN, + KSRESET_END + ); + {$EXTERNALSYM KSRESET} + TKSReset = KSRESET; + + KSSTATE = ( + KSSTATE_STOP, + KSSTATE_ACQUIRE, + KSSTATE_PAUSE, + KSSTATE_RUN + ); + {$EXTERNALSYM KSSTATE} + PKSSTATE = ^KSSTATE; + {$EXTERNALSYM PKSSTATE} + TKSState = KSSTATE; + +const + KSPRIORITY_LOW = $00000001; + {$EXTERNALSYM KSPRIORITY_LOW} + KSPRIORITY_NORMAL = $40000000; + {$EXTERNALSYM KSPRIORITY_NORMAL} + KSPRIORITY_HIGH = $80000000; + {$EXTERNALSYM KSPRIORITY_HIGH} + KSPRIORITY_EXCLUSIVE = $FFFFFFFF; + {$EXTERNALSYM KSPRIORITY_EXCLUSIVE} + +type + KSPRIORITY = record + PriorityClass : ULONG; + PrioritySubClass : ULONG; + end; + {$EXTERNALSYM KSPRIORITY} + PKSPRIORITY = ^KSPRIORITY; + {$EXTERNALSYM PKSPRIORITY} + TKSPriority = KSPRIORITY; + + KSIDENTIFIER = record + case Integer of + 0: ( + Set_ : TGUID; + Id : ULONG; + Flags : ULONG); + 1: ( + Alignment : int64); + end; + {$EXTERNALSYM KSIDENTIFIER} + PKSIDENTIFIER = ^KSIDENTIFIER; + {$EXTERNALSYM PKSIDENTIFIER} + TKSIdentifier = KSIDENTIFIER; + + KSPROPERTY = {$IFDEF TYPE_IDENTITY}type {$ENDIF} KSIDENTIFIER; + {$EXTERNALSYM KSPROPERTY} + PKSPROPERTY = ^KSPROPERTY; + {$EXTERNALSYM PKSPROPERTY} + KSMETHOD = PKSPROPERTY; + {$EXTERNALSYM KSMETHOD} + PKSMETHOD = ^KSMETHOD; + {$EXTERNALSYM PKSMETHOD} + KSEVENT = PKSMETHOD; + {$EXTERNALSYM KSEVENT} + PKSEVENT = ^KSEVENT; + {$EXTERNALSYM PKSEVENT} + +const + KSMETHOD_TYPE_NONE = $00000000; + {$EXTERNALSYM KSMETHOD_TYPE_NONE} + KSMETHOD_TYPE_READ = $00000001; + {$EXTERNALSYM KSMETHOD_TYPE_READ} + KSMETHOD_TYPE_WRITE = $00000002; + {$EXTERNALSYM KSMETHOD_TYPE_WRITE} + KSMETHOD_TYPE_MODIFY = $00000003; + {$EXTERNALSYM KSMETHOD_TYPE_MODIFY} + KSMETHOD_TYPE_SOURCE = $00000004; + {$EXTERNALSYM KSMETHOD_TYPE_SOURCE} + + KSMETHOD_TYPE_SEND = $00000001; + {$EXTERNALSYM KSMETHOD_TYPE_SEND} + KSMETHOD_TYPE_SETSUPPORT = $00000100; + {$EXTERNALSYM KSMETHOD_TYPE_SETSUPPORT} + KSMETHOD_TYPE_BASICSUPPORT = $00000200; + {$EXTERNALSYM KSMETHOD_TYPE_BASICSUPPORT} + + KSMETHOD_TYPE_TOPOLOGY = $10000000; + {$EXTERNALSYM KSMETHOD_TYPE_TOPOLOGY} + + KSPROPERTY_TYPE_GET = $00000001; + {$EXTERNALSYM KSPROPERTY_TYPE_GET} + KSPROPERTY_TYPE_SET = $00000002; + {$EXTERNALSYM KSPROPERTY_TYPE_SET} + KSPROPERTY_TYPE_SETSUPPORT = $00000100; + {$EXTERNALSYM KSPROPERTY_TYPE_SETSUPPORT} + KSPROPERTY_TYPE_BASICSUPPORT = $00000200; + {$EXTERNALSYM KSPROPERTY_TYPE_BASICSUPPORT} + KSPROPERTY_TYPE_RELATIONS = $00000400; + {$EXTERNALSYM KSPROPERTY_TYPE_RELATIONS} + KSPROPERTY_TYPE_SERIALIZESET = $00000800; + {$EXTERNALSYM KSPROPERTY_TYPE_SERIALIZESET} + KSPROPERTY_TYPE_UNSERIALIZESET = $00001000; + {$EXTERNALSYM KSPROPERTY_TYPE_UNSERIALIZESET} + KSPROPERTY_TYPE_SERIALIZERAW = $00002000; + {$EXTERNALSYM KSPROPERTY_TYPE_SERIALIZERAW} + KSPROPERTY_TYPE_UNSERIALIZERAW = $00004000; + {$EXTERNALSYM KSPROPERTY_TYPE_UNSERIALIZERAW} + KSPROPERTY_TYPE_SERIALIZESIZE = $00008000; + {$EXTERNALSYM KSPROPERTY_TYPE_SERIALIZESIZE} + KSPROPERTY_TYPE_DEFAULTVALUES = $00010000; + {$EXTERNALSYM KSPROPERTY_TYPE_DEFAULTVALUES} + + KSPROPERTY_TYPE_TOPOLOGY = $10000000; + {$EXTERNALSYM KSPROPERTY_TYPE_TOPOLOGY} + +type + PKSPNode = ^TKSPNode; + KSP_NODE = record + Property_ : KSPROPERTY; + NodeId : ULONG; + Reserved : ULONG; + end; + {$EXTERNALSYM KSP_NODE} + PKSP_NODE = ^KSP_NODE; + {$EXTERNALSYM PKSP_NODE} + TKSPNode = KSP_NODE; + + PKSMNode = ^TKSMNode; + KSM_NODE = record + Method : KSMETHOD; + NodeId : ULONG; + Reserved : ULONG; + end; + {$EXTERNALSYM KSM_NODE} + PKSM_NODE = ^KSM_NODE; + {$EXTERNALSYM PKSM_NODE} + TKSMNode = KSM_NODE; + + PKSENode = ^TKSENode; + KSE_NODE = record + Event : KSEVENT; + NodeId : ULONG; + Reserved : ULONG; + end; + {$EXTERNALSYM KSE_NODE} + PKSE_NODE = ^KSE_NODE; + {$EXTERNALSYM PKSE_NODE} + TKSENode = KSE_NODE; + +const + KSPROPTYPESETID_General : TGUID = '{97E99BA0-BDEA-11CF-A5D6-28DB04C10000}'; + {$EXTERNALSYM KSPROPTYPESETID_General} + +type + PKSMultipleItem = ^TKSMultipleItem; + KSMULTIPLE_ITEM = record + Size : ULONG; + Count : ULONG; + end; + {$EXTERNALSYM KSMULTIPLE_ITEM} + PKSMULTIPLE_ITEM = ^KSMULTIPLE_ITEM; + {$EXTERNALSYM PKSMULTIPLE_ITEM} + TKSMultipleItem = KSMULTIPLE_ITEM; + + PKSPropertyDescription = ^TKSPropertyDescription; + KSPROPERTY_DESCRIPTION = record + AccessFlags : ULONG; + DescriptionSize : ULONG; + PropTypeSet : TKSIDENTIFIER; + MembersListCount : ULONG; + Reserved : ULONG; + end; + {$EXTERNALSYM KSPROPERTY_DESCRIPTION} + PKSPROPERTY_DESCRIPTION = ^KSPROPERTY_DESCRIPTION; + {$EXTERNALSYM PKSPROPERTY_DESCRIPTION} + TKSPropertyDescription = KSPROPERTY_DESCRIPTION; + +const + KSPROPERTY_MEMBER_RANGES = $00000001; + {$EXTERNALSYM KSPROPERTY_MEMBER_RANGES} + KSPROPERTY_MEMBER_STEPPEDRANGES = $00000002; + {$EXTERNALSYM KSPROPERTY_MEMBER_STEPPEDRANGES} + KSPROPERTY_MEMBER_VALUES = $00000003; + {$EXTERNALSYM KSPROPERTY_MEMBER_VALUES} + + KSPROPERTY_MEMBER_FLAG_DEFAULT = $00000001; + {$EXTERNALSYM KSPROPERTY_MEMBER_FLAG_DEFAULT} + +type + PKSPropertyMembersHeader = ^TKSPropertyMembersHeader; + KSPROPERTY_MEMBERSHEADER = record + MembersFlags : ULONG; + MembersSize : ULONG; + MembersCount : ULONG; + Flags : ULONG; + end; + {$EXTERNALSYM KSPROPERTY_MEMBERSHEADER} + PKSPROPERTY_MEMBERSHEADER = ^KSPROPERTY_MEMBERSHEADER; + {$EXTERNALSYM PKSPROPERTY_MEMBERSHEADER} + TKSPropertyMembersHeader = KSPROPERTY_MEMBERSHEADER; + + PKSPropertyBoundsLong = ^TKSPropertyBoundsLong; + KSPROPERTY_BOUNDS_LONG = record + case Integer of + 0: ( + SignedMinimum : Longint; + SignedMaximum : Longint); + 1: ( + UnsignedMinimum : ULONG; + UnsignedMaximum : ULONG); + end; + {$EXTERNALSYM KSPROPERTY_BOUNDS_LONG} + PKSPROPERTY_BOUNDS_LONG = ^KSPROPERTY_BOUNDS_LONG; + {$EXTERNALSYM PKSPROPERTY_BOUNDS_LONG} + TKSPropertyBoundsLong = KSPROPERTY_BOUNDS_LONG; + + PKSPropertyBoundsLongLong = ^TKSPropertyBoundsLongLong; + KSPROPERTY_BOUNDS_LONGLONG = record + case Integer of + 0: ( + SignedMinimum : TLargeInteger; + SignedMaximum : TLargeInteger); + 1: ( + UnsignedMinimum : TULargeInteger; + UnsignedMaximum : TULargeInteger); + end; + {$EXTERNALSYM KSPROPERTY_BOUNDS_LONGLONG} + PKSPROPERTY_BOUNDS_LONGLONG = ^KSPROPERTY_BOUNDS_LONGLONG; + {$EXTERNALSYM PKSPROPERTY_BOUNDS_LONGLONG} + TKSPropertyBoundsLongLong = KSPROPERTY_BOUNDS_LONGLONG; + + PKSPropertySteppingLong = ^TKSPropertySteppingLong; + KSPROPERTY_STEPPING_LONG = record + SteppingDelta : ULONG; + Reserved : ULONG; + Bounds : TKSPropertyBoundsLong; + end; + {$EXTERNALSYM KSPROPERTY_STEPPING_LONG} + PKSPROPERTY_STEPPING_LONG = ^KSPROPERTY_STEPPING_LONG; + {$EXTERNALSYM PKSPROPERTY_STEPPING_LONG} + TKSPropertySteppingLong = KSPROPERTY_STEPPING_LONG; + + PKSPropertySteppingLongLong = ^TKSPropertySteppingLongLong; + KSPROPERTY_STEPPING_LONGLONG = record + SteppingDelta : TULargeInteger; + Bounds : TKSPropertyBoundsLongLong; + end; + {$EXTERNALSYM KSPROPERTY_STEPPING_LONGLONG} + PKSPROPERTY_STEPPING_LONGLONG = KSPROPERTY_STEPPING_LONGLONG; + {$EXTERNALSYM PKSPROPERTY_STEPPING_LONGLONG} + TKSPropertySteppingLongLong = KSPROPERTY_STEPPING_LONGLONG; + +//=========================================================================== + PKSWORKER = pointer; + {$EXTERNALSYM PKSWORKER} + + KSEVENTDATA = record + NotificationType : ULONG; + case integer of + 0: ( // EventHandle + Event : THandle; + Reserved : array[0..1] of ULONG); + 1: ( // SemaphoreHandle + Semaphore : THandle; + Reserved_ : ULONG; + Adjustment : Longint); + 2: ( // Alignment + Unused : Pointer; + Alignment : array[0..1] of Longint); + end; + {$EXTERNALSYM KSEVENTDATA} + PKSEVENTDATA = ^KSEVENTDATA; + {$EXTERNALSYM PKSEVENTDATA} + TKSEventData = KSEVENTDATA; + +const + KSEVENTF_EVENT_HANDLE = $00000001; + {$EXTERNALSYM KSEVENTF_EVENT_HANDLE} + KSEVENTF_SEMAPHORE_HANDLE = $00000002; + {$EXTERNALSYM KSEVENTF_SEMAPHORE_HANDLE} + + KSEVENT_TYPE_ENABLE = $00000001; + {$EXTERNALSYM KSEVENT_TYPE_ENABLE} + KSEVENT_TYPE_ONESHOT = $00000002; + {$EXTERNALSYM KSEVENT_TYPE_ONESHOT} + KSEVENT_TYPE_ENABLEBUFFERED = $00000004; + {$EXTERNALSYM KSEVENT_TYPE_ENABLEBUFFERED} + KSEVENT_TYPE_SETSUPPORT = $00000100; + {$EXTERNALSYM KSEVENT_TYPE_SETSUPPORT} + KSEVENT_TYPE_BASICSUPPORT = $00000200; + {$EXTERNALSYM KSEVENT_TYPE_BASICSUPPORT} + KSEVENT_TYPE_QUERYBUFFER = $00000400; + {$EXTERNALSYM KSEVENT_TYPE_QUERYBUFFER} + + KSEVENT_TYPE_TOPOLOGY = $10000000; + {$EXTERNALSYM KSEVENT_TYPE_TOPOLOGY} + +type + KSQUERYBUFFER = record + Event : KSEVENT; + EventData : PKSEVENTDATA; + Reserved : Pointer; + end; + {$EXTERNALSYM KSQUERYBUFFER} + PKSQUERYBUFFER = ^KSQUERYBUFFER; + {$EXTERNALSYM PKSQUERYBUFFER} + TKSQueryBuffer = KSQUERYBUFFER; + + KSRELATIVEEVENT = record + Size : ULONG; + Flags : ULONG; + case integer of + 0: ( ObjectHandle : THandle; + Reserved : Pointer; + Event : KSEVENT; + EventData : TKSEVENTDATA); + 1: ( ObjectPointer : Pointer); + + end; + {$EXTERNALSYM KSRELATIVEEVENT} + TKSRelativeEvent = KSRELATIVEEVENT; + +const + KSRELATIVEEVENT_FLAG_HANDLE = $00000001; + {$EXTERNALSYM KSRELATIVEEVENT_FLAG_HANDLE} + KSRELATIVEEVENT_FLAG_POINTER = $00000002; + {$EXTERNALSYM KSRELATIVEEVENT_FLAG_POINTER} + +//=========================================================================== + +type + PKSEventTimeMark = ^TKSEventTimeMark; + KSEVENT_TIME_MARK = record + EventData : TKSEVENTDATA; + MarkTime : int64; + end; + {$EXTERNALSYM KSEVENT_TIME_MARK} + PKSEVENT_TIME_MARK = ^KSEVENT_TIME_MARK; + {$EXTERNALSYM PKSEVENT_TIME_MARK} + TKSEventTimeMark = KSEVENT_TIME_MARK; + + PKSEventTimeInterval = ^TKSEventTimeInterval; + KSEVENT_TIME_INTERVAL = record + EventData : TKSEVENTDATA; + TimeBase : int64; + Interval : int64; + end; + {$EXTERNALSYM KSEVENT_TIME_INTERVAL} + PKSEVENT_TIME_INTERVAL = ^KSEVENT_TIME_INTERVAL; + {$EXTERNALSYM PKSEVENT_TIME_INTERVAL} + TKSEventTimeInterval = KSEVENT_TIME_INTERVAL; + + KSINTERVAL = record + TimeBase : int64; + Interval : int64; + end; + {$EXTERNALSYM KSINTERVAL} + PKSINTERVAL = ^KSINTERVAL; + {$EXTERNALSYM PKSINTERVAL} + TKSInterval = KSINTERVAL; + +//=========================================================================== +const + KSPROPSETID_General : TGUID = '{1464EDA5-6A8F-11D1-9AA7-00A0C9223196}'; + {$EXTERNALSYM KSPROPSETID_General} + +type + KSPROPERTY_GENERAL = ( + {$EXTERNALSYM KSPROPERTY_GENERAL} + KSPROPERTY_GENERAL_COMPONENTID + ); + TKSPropertyGeneral = KSPROPERTY_GENERAL; + + KSCOMPONENTID = record + Manufacturer : TGUID; + Product : TGUID; + Component : TGUID; + Name : TGUID; + Version : ULONG; + Revision : ULONG; + end; + {$EXTERNALSYM KSCOMPONENTID} + PKSCOMPONENTID = ^KSCOMPONENTID; + {$EXTERNALSYM PKSCOMPONENTID} + TKSComponentID = KSCOMPONENTID; + +const + KSMETHODSETID_StreamIo : TGUID = '{65D003CA-1523-11D2-B27A-00A0C9223196}'; + {$EXTERNALSYM KSMETHODSETID_StreamIo} + +type + KSMETHOD_STREAMIO = ( + KSMETHOD_STREAMIO_READ, + KSMETHOD_STREAMIO_WRITE + ); + {$EXTERNALSYM KSMETHOD_STREAMIO} + TKSMethodStreamIO = KSMETHOD_STREAMIO; + +const + KSPROPSETID_MediaSeeking : TGUID = '{EE904F0C-D09B-11D0-ABE9-00A0C9223196}'; + {$EXTERNALSYM KSPROPSETID_MediaSeeking} + +type + KSPROPERTY_MEDIASEEKING = ( + KSPROPERTY_MEDIASEEKING_CAPABILITIES, + KSPROPERTY_MEDIASEEKING_FORMATS, + KSPROPERTY_MEDIASEEKING_TIMEFORMAT, + KSPROPERTY_MEDIASEEKING_POSITION, + KSPROPERTY_MEDIASEEKING_STOPPOSITION, + KSPROPERTY_MEDIASEEKING_POSITIONS, + KSPROPERTY_MEDIASEEKING_DURATION, + KSPROPERTY_MEDIASEEKING_AVAILABLE, + KSPROPERTY_MEDIASEEKING_PREROLL, + KSPROPERTY_MEDIASEEKING_CONVERTTIMEFORMAT + ); + {$EXTERNALSYM KSPROPERTY_MEDIASEEKING} + TKSPropertyMediaSeeking = KSPROPERTY_MEDIASEEKING; + + KS_SEEKING_FLAGS = {$IFDEF TYPE_IDENTITY}type {$ENDIF} LongWord; + {$EXTERNALSYM KS_SEEKING_FLAGS} + const + KS_SEEKING_NoPositioning = $0; + {$EXTERNALSYM KS_SEEKING_NoPositioning} + KS_SEEKING_AbsolutePositioning = $1; + {$EXTERNALSYM KS_SEEKING_AbsolutePositioning} + KS_SEEKING_RelativePositioning = $2; + {$EXTERNALSYM KS_SEEKING_RelativePositioning} + KS_SEEKING_IncrementalPositioning = $3; + {$EXTERNALSYM KS_SEEKING_IncrementalPositioning} + KS_SEEKING_PositioningBitsMask = $3; + {$EXTERNALSYM KS_SEEKING_PositioningBitsMask} + KS_SEEKING_SeekToKeyFrame = $4; + {$EXTERNALSYM KS_SEEKING_SeekToKeyFrame} + KS_SEEKING_ReturnTime = $8; + {$EXTERNALSYM KS_SEEKING_ReturnTime} + +type + KS_SEEKING_CAPABILITIES = {$IFDEF TYPE_IDENTITY}type {$ENDIF} LongWord; + {$EXTERNALSYM KS_SEEKING_CAPABILITIES} + const + KS_SEEKING_CanSeekAbsolute = $1; + {$EXTERNALSYM KS_SEEKING_CanSeekAbsolute} + KS_SEEKING_CanSeekForwards = $2; + {$EXTERNALSYM KS_SEEKING_CanSeekForwards} + KS_SEEKING_CanSeekBackwards = $4; + {$EXTERNALSYM KS_SEEKING_CanSeekBackwards} + KS_SEEKING_CanGetCurrentPos = $8; + {$EXTERNALSYM KS_SEEKING_CanGetCurrentPos} + KS_SEEKING_CanGetStopPos = $10; + {$EXTERNALSYM KS_SEEKING_CanGetStopPos} + KS_SEEKING_CanGetDuration = $20; + {$EXTERNALSYM KS_SEEKING_CanGetDuration} + KS_SEEKING_CanPlayBackwards = $40; + {$EXTERNALSYM KS_SEEKING_CanPlayBackwards} + +type + PKSPropertyPositions = ^TKSPropertyPositions; + KSPROPERTY_POSITIONS = record + Current : int64; + Stop : int64; + CurrentFlags : KS_SEEKING_FLAGS; + StopFlags : KS_SEEKING_FLAGS; + end; + {$EXTERNALSYM KSPROPERTY_POSITIONS} + PKSPROPERTY_POSITIONS = ^KSPROPERTY_POSITIONS; + {$EXTERNALSYM PKSPROPERTY_POSITIONS} + TKSPropertyPositions = KSPROPERTY_POSITIONS; + + PKSPropertyMediaAvailable = ^TKSPropertyMediaAvailable; + KSPROPERTY_MEDIAAVAILABLE = record + Earliest : int64; + Latest : int64; + end; + {$EXTERNALSYM KSPROPERTY_MEDIAAVAILABLE} + PKSPROPERTY_MEDIAAVAILABLE = ^KSPROPERTY_MEDIAAVAILABLE; + {$EXTERNALSYM PKSPROPERTY_MEDIAAVAILABLE} + TKSPropertyMediaAvailable = KSPROPERTY_MEDIAAVAILABLE; + + PKSPTimeFormat = ^TKSPTimeFormat; + KSP_TIMEFORMAT = record + Property_ : KSPROPERTY; + SourceFormat : TGUID; + TargetFormat : TGUID; + Time : int64; + end; + {$EXTERNALSYM KSP_TIMEFORMAT} + PKSP_TIMEFORMAT = ^KSP_TIMEFORMAT; + {$EXTERNALSYM PKSP_TIMEFORMAT} + TKSPTimeFormat = KSP_TIMEFORMAT; + +//=========================================================================== + +const + KSPROPSETID_Topology : TGUID = '{720D4AC0-7533-11D0-A5D6-28DB04C10000}'; + {$EXTERNALSYM KSPROPSETID_Topology} + +type + KSPROPERTY_TOPOLOGY = ( + KSPROPERTY_TOPOLOGY_CATEGORIES, + KSPROPERTY_TOPOLOGY_NODES, + KSPROPERTY_TOPOLOGY_CONNECTIONS, + KSPROPERTY_TOPOLOGY_NAME + ); + {$EXTERNALSYM KSPROPERTY_TOPOLOGY} + TKSPropertyTopology = KSPROPERTY_TOPOLOGY; + +const + KSCATEGORY_BRIDGE : TGUID = '{085AFF00-62CE-11CF-A5D6-28DB04C10000}'; + {$EXTERNALSYM KSCATEGORY_BRIDGE} + KSCATEGORY_CAPTURE : TGUID = '{65E8773D-8F56-11D0-A3B9-00A0C9223196}'; + {$EXTERNALSYM KSCATEGORY_CAPTURE} + KSCATEGORY_RENDER : TGUID = '{65E8773E-8F56-11D0-A3B9-00A0C9223196}'; + {$EXTERNALSYM KSCATEGORY_RENDER} + KSCATEGORY_MIXER : TGUID = '{AD809C00-7B88-11D0-A5D6-28DB04C10000}'; + {$EXTERNALSYM KSCATEGORY_MIXER} + KSCATEGORY_SPLITTER : TGUID = '{0A4252A0-7E70-11D0-A5D6-28DB04C10000}'; + {$EXTERNALSYM KSCATEGORY_SPLITTER} + KSCATEGORY_DATACOMPRESSOR : TGUID = '{1E84C900-7E70-11D0-A5D6-28DB04C10000}'; + {$EXTERNALSYM KSCATEGORY_DATACOMPRESSOR} + KSCATEGORY_DATADECOMPRESSOR : TGUID = '{2721AE20-7E70-11D0-A5D6-28DB04C10000}'; + {$EXTERNALSYM KSCATEGORY_DATADECOMPRESSOR} + KSCATEGORY_DATATRANSFORM : TGUID = '{2EB07EA0-7E70-11D0-A5D6-28DB04C10000}'; + {$EXTERNALSYM KSCATEGORY_DATATRANSFORM} + KSCATEGORY_COMMUNICATIONSTRANSFORM : TGUID = '{CF1DDA2C-9743-11D0-A3EE-00A0C9223196}'; + {$EXTERNALSYM KSCATEGORY_COMMUNICATIONSTRANSFORM} + KSCATEGORY_INTERFACETRANSFORM : TGUID = '{CF1DDA2D-9743-11D0-A3EE-00A0C9223196}'; + {$EXTERNALSYM KSCATEGORY_INTERFACETRANSFORM} + KSCATEGORY_MEDIUMTRANSFORM : TGUID = '{CF1DDA2E-9743-11D0-A3EE-00A0C9223196}'; + {$EXTERNALSYM KSCATEGORY_MEDIUMTRANSFORM} + KSCATEGORY_FILESYSTEM : TGUID = '{760FED5E-9357-11D0-A3CC-00A0C9223196}'; + {$EXTERNALSYM KSCATEGORY_FILESYSTEM} + +// KSNAME_Clock + KSCATEGORY_CLOCK : TGUID = '{53172480-4791-11D0-A5D6-28DB04C10000}'; + {$EXTERNALSYM KSCATEGORY_CLOCK} + KSCATEGORY_PROXY : TGUID = '{97EBAACA-95BD-11D0-A3EA-00A0C9223196}'; + {$EXTERNALSYM KSCATEGORY_PROXY} + KSCATEGORY_QUALITY : TGUID = '{97EBAACB-95BD-11D0-A3EA-00A0C9223196}'; + {$EXTERNALSYM KSCATEGORY_QUALITY} + +type + PKSTopologyConnection = ^TKSTopologyConnection; + KSTOPOLOGY_CONNECTION = record + FromNode : ULONG; + FromNodePin : ULONG; + ToNode : ULONG; + ToNodePin : ULONG; + end; + {$EXTERNALSYM KSTOPOLOGY_CONNECTION} + PKSTOPOLOGY_CONNECTION = ^KSTOPOLOGY_CONNECTION; + {$EXTERNALSYM PKSTOPOLOGY_CONNECTION} + TKSTopologyConnection = KSTOPOLOGY_CONNECTION; + + KSTOPOLOGY = record + CategoriesCount : ULONG; + Categories : PGUID; + TopologyNodesCount : ULONG; + TopologyNodes : PGUID; + TopologyConnectionsCount : ULONG; + TopologyConnections : PKSTOPOLOGY_CONNECTION; + TopologyNodesNames : PGUID; + Reserved : ULONG; + end; + {$EXTERNALSYM KSTOPOLOGY} + PKSTOPOLOGY = ^KSTOPOLOGY; + {$EXTERNALSYM PKSTOPOLOGY} + TKSTopology = KSTOPOLOGY; + +const + KSFILTER_NODE = ULONG(-1); + {$EXTERNALSYM KSFILTER_NODE} + KSALL_NODES = ULONG(-1); + {$EXTERNALSYM KSALL_NODES} + +type + PKSNodeCreate = ^TKSNodeCreate; + KSNODE_CREATE = record + CreateFlags : ULONG; + Node : ULONG; + end; + {$EXTERNALSYM KSNODE_CREATE} + PKSNODE_CREATE = ^KSNODE_CREATE; + {$EXTERNALSYM PKSNODE_CREATE} + TKSNodeCreate = KSNODE_CREATE; + +//=========================================================================== +const +// TIME_FORMAT_NONE + KSTIME_FORMAT_NONE : TGUID = '{00000000-0000-0000-0000-000000000000}'; + {$EXTERNALSYM KSTIME_FORMAT_NONE} + +// TIME_FORMAT_FRAME + KSTIME_FORMAT_FRAME : TGUID = '{7b785570-8c82-11cf-bc0c-00aa00ac74f6}'; + {$EXTERNALSYM KSTIME_FORMAT_FRAME} + +// TIME_FORMAT_BYTE + KSTIME_FORMAT_BYTE : TGUID = '{7b785571-8c82-11cf-bc0c-00aa00ac74f6}'; + {$EXTERNALSYM KSTIME_FORMAT_BYTE} + +// TIME_FORMAT_SAMPLE + KSTIME_FORMAT_SAMPLE : TGUID = '{7b785572-8c82-11cf-bc0c-00aa00ac74f6}'; + {$EXTERNALSYM KSTIME_FORMAT_SAMPLE} + +// TIME_FORMAT_FIELD + KSTIME_FORMAT_FIELD : TGUID = '{7b785573-8c82-11cf-bc0c-00aa00ac74f6}'; + {$EXTERNALSYM KSTIME_FORMAT_FIELD} + +// TIME_FORMAT_MEDIA_TIME + KSTIME_FORMAT_MEDIA_TIME : TGUID = '{7b785574-8c82-11cf-bc0c-00aa00ac74f6}'; + {$EXTERNALSYM KSTIME_FORMAT_MEDIA_TIME} + +//=========================================================================== + +type + PKSPIN_INTERFACE = ^KSPIN_INTERFACE; + {$EXTERNALSYM PKSPIN_INTERFACE} + KSPIN_INTERFACE = KSIDENTIFIER; + {$EXTERNALSYM KSPIN_INTERFACE} + + PKSPinInterface = PKSPIN_INTERFACE; + TKSPinInterface = KSPIN_INTERFACE; + +const + KSINTERFACESETID_Standard : TGUID = '{1A8766A0-62CE-11CF-A5D6-28DB04C10000}'; + {$EXTERNALSYM KSINTERFACESETID_Standard} + +type + KSINTERFACE_STANDARD = ( + KSINTERFACE_STANDARD_STREAMING, + KSINTERFACE_STANDARD_LOOPED_STREAMING, + KSINTERFACE_STANDARD_CONTROL + ); + {$EXTERNALSYM KSINTERFACE_STANDARD} + TKSInterfaceStandard = KSINTERFACE_STANDARD; + +const + KSINTERFACESETID_FileIo : TGUID = '{8C6F932C-E771-11D0-B8FF-00A0C9223196}'; + {$EXTERNALSYM KSINTERFACESETID_FileIo} + +type + KSINTERFACE_FILEIO = ( + KSINTERFACE_FILEIO_STREAMING + ); + {$EXTERNALSYM KSINTERFACE_FILEIO} + TKSInterfaceFileIO = KSINTERFACE_FILEIO; + +//=========================================================================== +const + KSMEDIUM_TYPE_ANYINSTANCE = 0; + {$EXTERNALSYM KSMEDIUM_TYPE_ANYINSTANCE} + + KSMEDIUMSETID_Standard : TGUID = '{4747B320-62CE-11CF-A5D6-28DB04C10000}'; + {$EXTERNALSYM KSMEDIUMSETID_Standard} + +//For compatibility only + KSMEDIUM_STANDARD_DEVIO = KSMEDIUM_TYPE_ANYINSTANCE; + {$EXTERNALSYM KSMEDIUM_STANDARD_DEVIO} + +//=========================================================================== + + KSPROPSETID_Pin : TGUID = '{8C134960-51AD-11CF-878A-94F801C10000}'; + {$EXTERNALSYM KSPROPSETID_Pin} + +type + KSPROPERTY_PIN = ( + KSPROPERTY_PIN_CINSTANCES, + KSPROPERTY_PIN_CTYPES, + KSPROPERTY_PIN_DATAFLOW, + KSPROPERTY_PIN_DATARANGES, + KSPROPERTY_PIN_DATAINTERSECTION, + KSPROPERTY_PIN_INTERFACES, + KSPROPERTY_PIN_MEDIUMS, + KSPROPERTY_PIN_COMMUNICATION, + KSPROPERTY_PIN_GLOBALCINSTANCES, + KSPROPERTY_PIN_NECESSARYINSTANCES, + KSPROPERTY_PIN_PHYSICALCONNECTION, + KSPROPERTY_PIN_CATEGORY, + KSPROPERTY_PIN_NAME, + KSPROPERTY_PIN_CONSTRAINEDDATARANGES, + KSPROPERTY_PIN_PROPOSEDATAFORMAT + ); + {$EXTERNALSYM KSPROPERTY_PIN} + TKSPropertyPin = KSPROPERTY_PIN; + + PKSPPin = ^TKSPPin; + KSP_PIN = record + Property_ : KSPROPERTY; + PinId : ULONG; + Reserved : ULONG; + end; + {$EXTERNALSYM KSP_PIN} + PKSP_PIN = ^KSP_PIN; + {$EXTERNALSYM PKSP_PIN} + TKSPPin = KSP_PIN; + +const + KSINSTANCE_INDETERMINATE = ULONG(-1); + {$EXTERNALSYM KSINSTANCE_INDETERMINATE} + +type + PKSPinCInstance = ^TKSPinCInstance; + KSPIN_CINSTANCES = record + PossibleCount : ULONG; + CurrentCount : ULONG; + end; + {$EXTERNALSYM KSPIN_CINSTANCES} + PKSPIN_CINSTANCES = ^KSPIN_CINSTANCES; + {$EXTERNALSYM PKSPIN_CINSTANCES} + TKSPinCInstance = KSPIN_CINSTANCES; + + + PKSPinDataFlow = ^TKSPinDataFlow; + KSPIN_DATAFLOW = ( + KSPIN_DATAFLOW_Invalid, + KSPIN_DATAFLOW_IN, + KSPIN_DATAFLOW_OUT + ); + {$EXTERNALSYM KSPIN_DATAFLOW} + PKSPIN_DATAFLOW = ^KSPIN_DATAFLOW; + {$EXTERNALSYM PKSPIN_DATAFLOW} + TKSPinDataFlow = KSPIN_DATAFLOW; + +const + KSDATAFORMAT_BIT_TEMPORAL_COMPRESSION = 0; + {$EXTERNALSYM KSDATAFORMAT_BIT_TEMPORAL_COMPRESSION} + KSDATAFORMAT_TEMPORAL_COMPRESSION = (1 shl KSDATAFORMAT_BIT_TEMPORAL_COMPRESSION); + {$EXTERNALSYM KSDATAFORMAT_TEMPORAL_COMPRESSION} + KSDATAFORMAT_BIT_ATTRIBUTES = 1; + {$EXTERNALSYM KSDATAFORMAT_BIT_ATTRIBUTES} + KSDATAFORMAT_ATTRIBUTES = (1 shl KSDATAFORMAT_BIT_ATTRIBUTES); + {$EXTERNALSYM KSDATAFORMAT_ATTRIBUTES} + + KSDATARANGE_BIT_ATTRIBUTES = 1; + {$EXTERNALSYM KSDATARANGE_BIT_ATTRIBUTES} + KSDATARANGE_ATTRIBUTES = (1 shl KSDATARANGE_BIT_ATTRIBUTES); + {$EXTERNALSYM KSDATARANGE_ATTRIBUTES} + KSDATARANGE_BIT_REQUIRED_ATTRIBUTES = 2; + {$EXTERNALSYM KSDATARANGE_BIT_REQUIRED_ATTRIBUTES} + KSDATARANGE_REQUIRED_ATTRIBUTES = (1 shl KSDATARANGE_BIT_REQUIRED_ATTRIBUTES); + {$EXTERNALSYM KSDATARANGE_REQUIRED_ATTRIBUTES} + +type + KSDATAFORMAT = record + case integer of + 0: ( + FormatSize : ULONG; + Flags : ULONG; + SampleSize : ULONG; + Reserved : ULONG; + MajorFormat : TGUID; + SubFormat : TGUID; + Specifier : TGUID); + 1: ( + Alignment : int64); + end; + {$EXTERNALSYM KSDATAFORMAT} + PKSDATAFORMAT = ^KSDATAFORMAT; + {$EXTERNALSYM PKSDATAFORMAT} + TKSDataFormat = KSDATAFORMAT; + + PKSDATARANGE = ^KSDATARANGE; + {$EXTERNALSYM PKSDATARANGE} + KSDATARANGE = KSDATAFORMAT; + {$EXTERNALSYM KSDATARANGE} + + TKSDataRange = KSDATARANGE; + +const + KSATTRIBUTE_REQUIRED = $00000001; + {$EXTERNALSYM KSATTRIBUTE_REQUIRED} + +type + KSATTRIBUTE = record + Size : ULONG; + Flags : ULONG; + Attribute : TGUID; + end; + {$EXTERNALSYM KSATTRIBUTE} + PKSATTRIBUTE = ^KSATTRIBUTE; + {$EXTERNALSYM PKSATTRIBUTE} + TKSAttribute = KSATTRIBUTE; + + PKSPinCommunication = ^TKSPinCommunication; + KSPIN_COMMUNICATION = ( + KSPIN_COMMUNICATION_NONE, + KSPIN_COMMUNICATION_SINK, + KSPIN_COMMUNICATION_SOURCE, + KSPIN_COMMUNICATION_BOTH, + KSPIN_COMMUNICATION_BRIDGE + ); + {$EXTERNALSYM KSPIN_COMMUNICATION} + PKSPIN_COMMUNICATION = ^KSPIN_COMMUNICATION; + {$EXTERNALSYM PKSPIN_COMMUNICATION} + TKSPinCommunication = KSPIN_COMMUNICATION; + + PKSPIN_MEDIUM = ^KSPIN_MEDIUM; + {$EXTERNALSYM PKSPIN_MEDIUM} + KSPIN_MEDIUM = KSIDENTIFIER; + {$EXTERNALSYM KSPIN_MEDIUM} + + PKSPinMedium = PKSPIN_MEDIUM; + TKSPinMedium = KSPIN_MEDIUM; + + PKSPinConnect = ^TKSPinConnect; + KSPIN_CONNECT = record + Interface_ : TKSPinInterface; + Medium : TKSPinMedium; + PinId : ULONG; + PinToHandle : THandle; + Priority : TKSPriority; + end; + {$EXTERNALSYM KSPIN_CONNECT} + PKSPIN_CONNECT = KSPIN_CONNECT; + {$EXTERNALSYM PKSPIN_CONNECT} + TKSPinConnect = KSPIN_CONNECT; + + PKSPinPhysicalConnection = ^TKSPinPhysicalConnection; + KSPIN_PHYSICALCONNECTION = record + Size : ULONG; + Pin : ULONG; + SymbolicLinkName : array[0..0] of WCHAR; + end; + {$EXTERNALSYM KSPIN_PHYSICALCONNECTION} + PKSPIN_PHYSICALCONNECTION = KSPIN_PHYSICALCONNECTION; + {$EXTERNALSYM PKSPIN_PHYSICALCONNECTION} + TKSPinPhysicalConnection = KSPIN_PHYSICALCONNECTION; + +const + KSNAME_Filter : TGUID = '{9b365890-165f-11d0-a195-0020afd156e4}'; + {$EXTERNALSYM KSNAME_Filter} + KSSTRING_Filter = '{9B365890-165F-11D0-A195-0020AFD156E4}'; + {$EXTERNALSYM KSSTRING_Filter} + + KSNAME_Pin : TGUID = '{146F1A80-4791-11D0-A5D6-28DB04C10000}'; + {$EXTERNALSYM KSNAME_Pin} + KSSTRING_Pin = '{146F1A80-4791-11D0-A5D6-28DB04C10000}'; + {$EXTERNALSYM KSSTRING_Pin} + + KSNAME_Clock : TGUID = '{53172480-4791-11D0-A5D6-28DB04C10000}'; + {$EXTERNALSYM KSNAME_Clock} + KSSTRING_Clock = '{53172480-4791-11D0-A5D6-28DB04C10000}'; + {$EXTERNALSYM KSSTRING_Clock} + + KSNAME_Allocator : TGUID = '{642F5D00-4791-11D0-A5D6-28DB04C10000}'; + {$EXTERNALSYM KSNAME_Allocator} + KSSTRING_Allocator = '{642F5D00-4791-11D0-A5D6-28DB04C10000}'; + {$EXTERNALSYM KSSTRING_Allocator} + + KSSTRING_AllocatorEx = '{091BB63B-603F-11D1-B067-00A0C9062802}'; + {$EXTERNALSYM KSSTRING_AllocatorEx} + + KSNAME_TopologyNode : TGUID = '{0621061A-EE75-11D0-B915-00A0C9223196}'; + {$EXTERNALSYM KSNAME_TopologyNode} + KSSTRING_TopologyNode = '{0621061A-EE75-11D0-B915-00A0C9223196}'; + {$EXTERNALSYM KSSTRING_TopologyNode} + +//=========================================================================== + +// MEDIATYPE_NULL +const + KSDATAFORMAT_TYPE_WILDCARD : TGUID = '{00000000-0000-0000-0000-000000000000}'; + {$EXTERNALSYM KSDATAFORMAT_TYPE_WILDCARD} + +// MEDIASUBTYPE_NULL + KSDATAFORMAT_SUBTYPE_WILDCARD : TGUID = '{00000000-0000-0000-0000-000000000000}'; + {$EXTERNALSYM KSDATAFORMAT_SUBTYPE_WILDCARD} + +// MEDIATYPE_Stream + KSDATAFORMAT_TYPE_STREAM : TGUID = '{E436EB83-524F-11CE-9F53-0020AF0BA770}'; + {$EXTERNALSYM KSDATAFORMAT_TYPE_STREAM} + +// MEDIASUBTYPE_None + KSDATAFORMAT_SUBTYPE_NONE : TGUID = '{E436EB8E-524F-11CE-9F53-0020AF0BA770}'; + {$EXTERNALSYM KSDATAFORMAT_SUBTYPE_NONE} + + KSDATAFORMAT_SPECIFIER_WILDCARD : TGUID = '{00000000-0000-0000-0000-000000000000}'; + {$EXTERNALSYM KSDATAFORMAT_SPECIFIER_WILDCARD} + + KSDATAFORMAT_SPECIFIER_FILENAME : TGUID = '{AA797B40-E974-11CF-A5D6-28DB04C10000}'; + {$EXTERNALSYM KSDATAFORMAT_SPECIFIER_FILENAME} + KSDATAFORMAT_SPECIFIER_FILEHANDLE: TGUID = '{65E8773C-8F56-11D0-A3B9-00A0C9223196}'; + {$EXTERNALSYM KSDATAFORMAT_SPECIFIER_FILEHANDLE} + +// FORMAT_None + KSDATAFORMAT_SPECIFIER_NONE : TGUID = '{0F6417D6-C318-11D0-A43F-00A0C9223196}'; + {$EXTERNALSYM KSDATAFORMAT_SPECIFIER_NONE} + +//=========================================================================== + + KSPROPSETID_Quality : TGUID = '{D16AD380-AC1A-11CF-A5D6-28DB04C10000}'; + {$EXTERNALSYM KSPROPSETID_Quality} + +type + KSPROPERTY_QUALITY = ( + KSPROPERTY_QUALITY_REPORT, + KSPROPERTY_QUALITY_ERROR + ); + {$EXTERNALSYM KSPROPERTY_QUALITY} + TKSPropertyQuality = KSPROPERTY_QUALITY; + +//=========================================================================== +const + KSPROPSETID_Connection : TGUID = '{1D58C920-AC9B-11CF-A5D6-28DB04C10000}'; + {$EXTERNALSYM KSPROPSETID_Connection} +type + KSPROPERTY_CONNECTION = ( + KSPROPERTY_CONNECTION_STATE, + KSPROPERTY_CONNECTION_PRIORITY, + KSPROPERTY_CONNECTION_DATAFORMAT, + KSPROPERTY_CONNECTION_ALLOCATORFRAMING, + KSPROPERTY_CONNECTION_PROPOSEDATAFORMAT, + KSPROPERTY_CONNECTION_ACQUIREORDERING, + KSPROPERTY_CONNECTION_ALLOCATORFRAMING_EX, + KSPROPERTY_CONNECTION_STARTAT + ); + {$EXTERNALSYM KSPROPERTY_CONNECTION} + TKSPropertyConnection = KSPROPERTY_CONNECTION; + +//=========================================================================== +// +// pins flags +// +const + KSALLOCATOR_REQUIREMENTF_INPLACE_MODIFIER = $00000001; + {$EXTERNALSYM KSALLOCATOR_REQUIREMENTF_INPLACE_MODIFIER} + KSALLOCATOR_REQUIREMENTF_SYSTEM_MEMORY = $00000002; + {$EXTERNALSYM KSALLOCATOR_REQUIREMENTF_SYSTEM_MEMORY} + KSALLOCATOR_REQUIREMENTF_FRAME_INTEGRITY = $00000004; + {$EXTERNALSYM KSALLOCATOR_REQUIREMENTF_FRAME_INTEGRITY} + KSALLOCATOR_REQUIREMENTF_MUST_ALLOCATE = $00000008; + {$EXTERNALSYM KSALLOCATOR_REQUIREMENTF_MUST_ALLOCATE} + KSALLOCATOR_REQUIREMENTF_PREFERENCES_ONLY = $80000000; + {$EXTERNALSYM KSALLOCATOR_REQUIREMENTF_PREFERENCES_ONLY} + + KSALLOCATOR_OPTIONF_COMPATIBLE = $00000001; + {$EXTERNALSYM KSALLOCATOR_OPTIONF_COMPATIBLE} + KSALLOCATOR_OPTIONF_SYSTEM_MEMORY = $00000002; + {$EXTERNALSYM KSALLOCATOR_OPTIONF_SYSTEM_MEMORY} + KSALLOCATOR_OPTIONF_VALID = $00000003; + {$EXTERNALSYM KSALLOCATOR_OPTIONF_VALID} +// +// pins extended framing flags +// + KSALLOCATOR_FLAG_PARTIAL_READ_SUPPORT = $00000010; + {$EXTERNALSYM KSALLOCATOR_FLAG_PARTIAL_READ_SUPPORT} + KSALLOCATOR_FLAG_DEVICE_SPECIFIC = $00000020; + {$EXTERNALSYM KSALLOCATOR_FLAG_DEVICE_SPECIFIC} + KSALLOCATOR_FLAG_CAN_ALLOCATE = $00000040; + {$EXTERNALSYM KSALLOCATOR_FLAG_CAN_ALLOCATE} + KSALLOCATOR_FLAG_INSIST_ON_FRAMESIZE_RATIO = $00000080; + {$EXTERNALSYM KSALLOCATOR_FLAG_INSIST_ON_FRAMESIZE_RATIO} +// +// allocator pipes flags +// +// there is at least one data modification in a pipe + KSALLOCATOR_FLAG_NO_FRAME_INTEGRITY = $00000100; + {$EXTERNALSYM KSALLOCATOR_FLAG_NO_FRAME_INTEGRITY} + KSALLOCATOR_FLAG_MULTIPLE_OUTPUT = $00000200; + {$EXTERNALSYM KSALLOCATOR_FLAG_MULTIPLE_OUTPUT} + KSALLOCATOR_FLAG_CYCLE = $00000400; + {$EXTERNALSYM KSALLOCATOR_FLAG_CYCLE} + KSALLOCATOR_FLAG_ALLOCATOR_EXISTS = $00000800; + {$EXTERNALSYM KSALLOCATOR_FLAG_ALLOCATOR_EXISTS} +// there is no framing dependency between neighbouring pipes. + KSALLOCATOR_FLAG_INDEPENDENT_RANGES = $00001000; + {$EXTERNALSYM KSALLOCATOR_FLAG_INDEPENDENT_RANGES} + KSALLOCATOR_FLAG_ATTENTION_STEPPING = $00002000; + {$EXTERNALSYM KSALLOCATOR_FLAG_ATTENTION_STEPPING} + + +// +// old Framing structure +// +type + PKSAllocatorFraming = ^TKSAllocatorFraming; + KSALLOCATOR_FRAMING = record + case integer of + 0: ( + OptionsFlags : ULONG); // allocator options (create) + 1: ( + RequirementsFlags : ULONG; // allocation requirements (query) + PoolType : ULONG; + Frames : ULONG; // total number of allowable outstanding frames + FrameSize : ULONG; // total size of frame + FileAlignment : ULONG; + Reserved : ULONG); + end; + {$EXTERNALSYM KSALLOCATOR_FRAMING} + PKSALLOCATOR_FRAMING = ^KSALLOCATOR_FRAMING; + {$EXTERNALSYM PKSALLOCATOR_FRAMING} + TKSAllocatorFraming = KSALLOCATOR_FRAMING; + +// +// new Framing structure, eventually will replace KSALLOCATOR_FRAMING. +// + PKSFramingRange = ^TKSFramingRange; + KS_FRAMING_RANGE = record + MinFrameSize : ULONG; + MaxFrameSize : ULONG; + Stepping : ULONG; + end; + {$EXTERNALSYM KS_FRAMING_RANGE} + PKS_FRAMING_RANGE = ^KS_FRAMING_RANGE; + {$EXTERNALSYM PKS_FRAMING_RANGE} + TKSFramingRange = KS_FRAMING_RANGE; + + PKSFramingRangeWeighted = ^TKSFramingRangeWeighted; + KS_FRAMING_RANGE_WEIGHTED = record + Range : TKSFramingRange; + InPlaceWeight : ULONG; + NotInPlaceWeight : ULONG; + end; + {$EXTERNALSYM KS_FRAMING_RANGE_WEIGHTED} + PKS_FRAMING_RANGE_WEIGHTED = ^KS_FRAMING_RANGE_WEIGHTED; + {$EXTERNALSYM PKS_FRAMING_RANGE_WEIGHTED} + TKSFramingRangeWeighted = KS_FRAMING_RANGE_WEIGHTED; + + PKSCompression = ^TKSCompression; + KS_COMPRESSION = record + RatioNumerator : ULONG; // compression/expansion ratio + RatioDenominator : ULONG; + RatioConstantMargin : ULONG; + end; + {$EXTERNALSYM KS_COMPRESSION} + PKS_COMPRESSION = ^KS_COMPRESSION; + {$EXTERNALSYM PKS_COMPRESSION} + TKSCompression = KS_COMPRESSION; + +// +// Memory Types and Buses are repeated in each entry. +// Easiest to use but takes a little more memory than the varsize layout Pin\Memories\Buses\Ranges. +// + PKSFramingItem = ^TKSFramingItem; + KS_FRAMING_ITEM = record + MemoryType : TGUID; + BusType : TGUID; + MemoryFlags : ULONG; + BusFlags : ULONG; + Flags : ULONG; + Frames : ULONG; // total number of allowable outstanding frames + FileAlignment : ULONG; + MemoryTypeWeight : ULONG; // this memory type Weight pin-wide + PhysicalRange : TKSFramingRange; + FramingRange : TKSFramingRangeWeighted; + end; + {$EXTERNALSYM KS_FRAMING_ITEM} + PKS_FRAMING_ITEM = ^KS_FRAMING_ITEM; + {$EXTERNALSYM PKS_FRAMING_ITEM} + TKSFramingItem = KS_FRAMING_ITEM; + + PKSAllocatorFramingEx = ^TKSAllocatorFramingEx; + KSALLOCATOR_FRAMING_EX = record + CountItems : ULONG; // count of FramingItem-s below. + PinFlags : ULONG; + OutputCompression : TKSCompression; + PinWeight : ULONG; // this pin framing's Weight graph-wide + FramingItem : array[0..0] of TKSFramingItem; + end; + {$EXTERNALSYM KSALLOCATOR_FRAMING_EX} + PKSALLOCATOR_FRAMING_EX = ^KSALLOCATOR_FRAMING_EX; + {$EXTERNALSYM PKSALLOCATOR_FRAMING_EX} + TKSAllocatorFramingEx = KSALLOCATOR_FRAMING_EX; + +// +// define memory type GUIDs +// +const + KSMEMORY_TYPE_WILDCARD : TGUID = '{00000000-0000-0000-0000-000000000000}'; + {$EXTERNALSYM KSMEMORY_TYPE_WILDCARD} + KSMEMORY_TYPE_DONT_CARE : TGUID = '{00000000-0000-0000-0000-000000000000}'; + {$EXTERNALSYM KSMEMORY_TYPE_DONT_CARE} + KS_TYPE_DONT_CARE : TGUID = '{00000000-0000-0000-0000-000000000000}'; + {$EXTERNALSYM KS_TYPE_DONT_CARE} + + KSMEMORY_TYPE_SYSTEM : TGUID = '{091bb638-603f-11d1-b067-00a0c9062802}'; + {$EXTERNALSYM KSMEMORY_TYPE_SYSTEM} + KSMEMORY_TYPE_USER : TGUID = '{8cb0fc28-7893-11d1-b069-00a0c9062802}'; + {$EXTERNALSYM KSMEMORY_TYPE_USER} + KSMEMORY_TYPE_KERNEL_PAGED : TGUID = '{d833f8f8-7894-11d1-b069-00a0c9062802}'; + {$EXTERNALSYM KSMEMORY_TYPE_KERNEL_PAGED} + KSMEMORY_TYPE_KERNEL_NONPAGED : TGUID = '{4a6d5fc4-7895-11d1-b069-00a0c9062802}'; + {$EXTERNALSYM KSMEMORY_TYPE_KERNEL_NONPAGED} + +// old KS clients did not specify the device memory type + KSMEMORY_TYPE_DEVICE_UNKNOWN : TGUID = '{091bb639-603f-11d1-b067-00a0c9062802}'; + {$EXTERNALSYM KSMEMORY_TYPE_DEVICE_UNKNOWN} + +// +// Helper framing macros. +// +{#define DECLARE_SIMPLE_FRAMING_EX(FramingExName, MemoryType, Flags, Frames, Alignment, MinFrameSize, MaxFrameSize) \ + const KSALLOCATOR_FRAMING_EX FramingExName = \ + {\ + 1, \ + 0, \ + {\ + 1, \ + 1, \ + 0 \ + }//, \ +// 0, \ + {\ + {\ + MemoryType, \ + STATIC_KS_TYPE_DONT_CARE, \ + 0, \ + 0, \ + Flags, \ + Frames, \ + Alignment, \ + 0, \ + {\ + 0, \ + (ULONG)-1, \ + 1 \ + }//, \ + {\ + {\ + MinFrameSize, \ + MaxFrameSize, \ + 1 \ + }//, \ + // 0, \ + // 0 \ + // }\ + // }\ + // }\ + // } + +{#define SetDefaultKsCompression(KsCompressionPointer) \ +{\ + KsCompressionPointer->RatioNumerator = 1;\ + KsCompressionPointer->RatioDenominator = 1;\ + KsCompressionPointer->RatioConstantMargin = 0;\ +} + +{#define SetDontCareKsFramingRange(KsFramingRangePointer) \ +{\ + KsFramingRangePointer->MinFrameSize = 0;\ + KsFramingRangePointer->MaxFrameSize = (ULONG) -1;\ + KsFramingRangePointer->Stepping = 1;\ +} + +{#define SetKsFramingRange(KsFramingRangePointer, P_MinFrameSize, P_MaxFrameSize) \ +{\ + KsFramingRangePointer->MinFrameSize = P_MinFrameSize;\ + KsFramingRangePointer->MaxFrameSize = P_MaxFrameSize;\ + KsFramingRangePointer->Stepping = 1;\ +} + +{#define SetKsFramingRangeWeighted(KsFramingRangeWeightedPointer, P_MinFrameSize, P_MaxFrameSize) \ +{\ + KS_FRAMING_RANGE *KsFramingRange = &KsFramingRangeWeightedPointer->Range;\ + SetKsFramingRange(KsFramingRange, P_MinFrameSize, P_MaxFrameSize);\ + KsFramingRangeWeightedPointer->InPlaceWeight = 0;\ + KsFramingRangeWeightedPointer->NotInPlaceWeight = 0;\ +} + +{#define INITIALIZE_SIMPLE_FRAMING_EX(FramingExPointer, P_MemoryType, P_Flags, P_Frames, P_Alignment, P_MinFrameSize, P_MaxFrameSize) \ +{\ + KS_COMPRESSION *KsCompression = &FramingExPointer->OutputCompression;\ + KS_FRAMING_RANGE *KsFramingRange = &FramingExPointer->FramingItem[0].PhysicalRange;\ + KS_FRAMING_RANGE_WEIGHTED *KsFramingRangeWeighted = &FramingExPointer->FramingItem[0].FramingRange;\ + FramingExPointer->CountItems = 1;\ + FramingExPointer->PinFlags = 0;\ + SetDefaultKsCompression(KsCompression);\ + FramingExPointer->PinWeight = 0;\ + FramingExPointer->FramingItem[0].MemoryType = P_MemoryType;\ + FramingExPointer->FramingItem[0].BusType = KS_TYPE_DONT_CARE;\ + FramingExPointer->FramingItem[0].MemoryFlags = 0;\ + FramingExPointer->FramingItem[0].BusFlags = 0;\ + FramingExPointer->FramingItem[0].Flags = P_Flags;\ + FramingExPointer->FramingItem[0].Frames = P_Frames;\ + FramingExPointer->FramingItem[0].FileAlignment = P_Alignment;\ + FramingExPointer->FramingItem[0].MemoryTypeWeight = 0;\ + SetDontCareKsFramingRange(KsFramingRange);\ + SetKsFramingRangeWeighted(KsFramingRangeWeighted, P_MinFrameSize, P_MaxFrameSize);\ +} + + KSEVENTSETID_StreamAllocator : TGUID = '{75d95571-073c-11d0-a161-0020afd156e4}'; + {$EXTERNALSYM KSEVENTSETID_StreamAllocator} + +type + KSEVENT_STREAMALLOCATOR = ( + KSEVENT_STREAMALLOCATOR_INTERNAL_FREEFRAME, + KSEVENT_STREAMALLOCATOR_FREEFRAME + ); + {$EXTERNALSYM KSEVENT_STREAMALLOCATOR} + TKSEventStreamAllocator = KSEVENT_STREAMALLOCATOR; + +const + KSMETHODSETID_StreamAllocator : TGUID = '{cf6e4341-ec87-11cf-a130-0020afd156e4}'; + {$EXTERNALSYM KSMETHODSETID_StreamAllocator} + +type + KSMETHOD_STREAMALLOCATOR = ( + KSMETHOD_STREAMALLOCATOR_ALLOC, + KSMETHOD_STREAMALLOCATOR_FREE + ); + {$EXTERNALSYM KSMETHOD_STREAMALLOCATOR} + TKSMethodStreamAllocation = KSMETHOD_STREAMALLOCATOR; + +{#define DEFINE_KSMETHOD_ITEM_STREAMALLOCATOR_ALLOC(Handler)\ + DEFINE_KSMETHOD_ITEM(\ + KSMETHOD_STREAMALLOCATOR_ALLOC,\ + KSMETHOD_TYPE_WRITE,\ + (Handler),\ + sizeof(KSMETHOD),\ + sizeof(PVOID),\ + NULL) + +#define DEFINE_KSMETHOD_ITEM_STREAMALLOCATOR_FREE(Handler)\ + DEFINE_KSMETHOD_ITEM(\ + KSMETHOD_STREAMALLOCATOR_FREE,\ + KSMETHOD_TYPE_READ,\ + (Handler),\ + sizeof(KSMETHOD),\ + sizeof(PVOID),\ + NULL) + +#define DEFINE_KSMETHOD_ALLOCATORSET(AllocatorSet, MethodAlloc, MethodFree)\ +DEFINE_KSMETHOD_TABLE(AllocatorSet) {\ + DEFINE_KSMETHOD_ITEM_STREAMALLOCATOR_ALLOC(MethodAlloc),\ + DEFINE_KSMETHOD_ITEM_STREAMALLOCATOR_FREE(MethodFree)\ +} +const + KSPROPSETID_StreamAllocator : TGUID = '{cf6e4342-ec87-11cf-a130-0020afd156e4}'; + {$EXTERNALSYM KSPROPSETID_StreamAllocator} + +type + PKSStreamAllocatorStatus = ^TKSStreamAllocatorStatus; + KSSTREAMALLOCATOR_STATUS = record + Framing : TKSAllocatorFraming; + AllocatedFrames : ULONG; + Reserved : ULONG; + end; + {$EXTERNALSYM KSSTREAMALLOCATOR_STATUS} + PKSSTREAMALLOCATOR_STATUS = ^KSSTREAMALLOCATOR_STATUS; + {$EXTERNALSYM PKSSTREAMALLOCATOR_STATUS} + TKSStreamAllocatorStatus = KSSTREAMALLOCATOR_STATUS; + + PKSStreamAllocatorStatusEx = ^TKSStreamAllocatorStatusEx; + KSSTREAMALLOCATOR_STATUS_EX = record + Framing : TKSAllocatorFramingEx; + AllocatedFrames : ULONG; + Reserved : ULONG; + end; + {$EXTERNALSYM KSSTREAMALLOCATOR_STATUS_EX} + PKSSTREAMALLOCATOR_STATUS_EX = ^KSSTREAMALLOCATOR_STATUS_EX; + {$EXTERNALSYM PKSSTREAMALLOCATOR_STATUS_EX} + TKSStreamAllocatorStatusEx = KSSTREAMALLOCATOR_STATUS_EX; + +const + KSSTREAM_HEADER_OPTIONSF_SPLICEPOINT = $00000001; + {$EXTERNALSYM KSSTREAM_HEADER_OPTIONSF_SPLICEPOINT} + KSSTREAM_HEADER_OPTIONSF_PREROLL = $00000002; + {$EXTERNALSYM KSSTREAM_HEADER_OPTIONSF_PREROLL} + KSSTREAM_HEADER_OPTIONSF_DATADISCONTINUITY = $00000004; + {$EXTERNALSYM KSSTREAM_HEADER_OPTIONSF_DATADISCONTINUITY} + KSSTREAM_HEADER_OPTIONSF_TYPECHANGED = $00000008; + {$EXTERNALSYM KSSTREAM_HEADER_OPTIONSF_TYPECHANGED} + KSSTREAM_HEADER_OPTIONSF_TIMEVALID = $00000010; + {$EXTERNALSYM KSSTREAM_HEADER_OPTIONSF_TIMEVALID} + KSSTREAM_HEADER_OPTIONSF_TIMEDISCONTINUITY = $00000040; + {$EXTERNALSYM KSSTREAM_HEADER_OPTIONSF_TIMEDISCONTINUITY} + KSSTREAM_HEADER_OPTIONSF_FLUSHONPAUSE = $00000080; + {$EXTERNALSYM KSSTREAM_HEADER_OPTIONSF_FLUSHONPAUSE} + KSSTREAM_HEADER_OPTIONSF_DURATIONVALID = $00000100; + {$EXTERNALSYM KSSTREAM_HEADER_OPTIONSF_DURATIONVALID} + KSSTREAM_HEADER_OPTIONSF_ENDOFSTREAM = $00000200; + {$EXTERNALSYM KSSTREAM_HEADER_OPTIONSF_ENDOFSTREAM} + KSSTREAM_HEADER_OPTIONSF_LOOPEDDATA = $80000000; + {$EXTERNALSYM KSSTREAM_HEADER_OPTIONSF_LOOPEDDATA} + +type + KSTIME = record + Time : int64; + Numerator : ULONG; + Denominator : ULONG; + end; + {$EXTERNALSYM KSTIME} + PKSTIME = ^KSTIME; + {$EXTERNALSYM PKSTIME} + TKSTime = KSTIME; + + PKSStreamHeader = ^TKSStreamHeader; + KSSTREAM_HEADER = record + Size : ULONG; + TypeSpecificFlags : ULONG; + PresentationTime : TKSTIME; + Duration : int64; + FrameExtent : ULONG; + DataUsed : ULONG; + Data : Pointer; + OptionsFlags : ULONG; +//#if _WIN64 +// Reserved : ULONG; +//#endif + end; + {$EXTERNALSYM KSSTREAM_HEADER} + PKSSTREAM_HEADER = ^KSSTREAM_HEADER; + {$EXTERNALSYM PKSSTREAM_HEADER} + TKSStreamHeader = KSSTREAM_HEADER; + +const + KSPROPSETID_StreamInterface : TGUID = '{1fdd8ee1-9cd3-11d0-82aa-0000f822fe8a}'; + {$EXTERNALSYM KSPROPSETID_StreamInterface} +type + KSPROPERTY_STREAMINTERFACE = ( + KSPROPERTY_STREAMINTERFACE_HEADERSIZE + ); + {$EXTERNALSYM KSPROPERTY_STREAMINTERFACE} + TKSPropertyStreamInterface = KSPROPERTY_STREAMINTERFACE; + +{#define DEFINE_KSPROPERTY_ITEM_STREAMINTERFACE_HEADERSIZE( GetHandler )\ + DEFINE_KSPROPERTY_ITEM(\ + KSPROPERTY_STREAMINTERFACE_HEADERSIZE,\ + (GetHandler),\ + sizeof(KSPROPERTY),\ + sizeof(ULONG),\ + NULL, NULL, 0, NULL, NULL, 0) + +#define DEFINE_KSPROPERTY_STREAMINTERFACESET(StreamInterfaceSet,\ + HeaderSizeHandler)\ +DEFINE_KSPROPERTY_TABLE(StreamInterfaceSet) {\ + DEFINE_KSPROPERTY_ITEM_STREAMINTERFACE_HEADERSIZE( HeaderSizeHandler )\ +} +const + KSPROPSETID_Stream : TGUId = '{65aaba60-98ae-11cf-a10d-0020afd156e4}'; + {$EXTERNALSYM KSPROPSETID_Stream} + +type + KSPROPERTY_STREAM = ( + KSPROPERTY_STREAM_ALLOCATOR, + KSPROPERTY_STREAM_QUALITY, + KSPROPERTY_STREAM_DEGRADATION, + KSPROPERTY_STREAM_MASTERCLOCK, + KSPROPERTY_STREAM_TIMEFORMAT, + KSPROPERTY_STREAM_PRESENTATIONTIME, + KSPROPERTY_STREAM_PRESENTATIONEXTENT, + KSPROPERTY_STREAM_FRAMETIME, + KSPROPERTY_STREAM_RATECAPABILITY, + KSPROPERTY_STREAM_RATE, + KSPROPERTY_STREAM_PIPE_ID + ); + {$EXTERNALSYM KSPROPERTY_STREAM} + TKSPropertyStream = KSPROPERTY_STREAM; + +{#define DEFINE_KSPROPERTY_ITEM_STREAM_ALLOCATOR(GetHandler, SetHandler)\ + DEFINE_KSPROPERTY_ITEM(\ + KSPROPERTY_STREAM_ALLOCATOR,\ + (GetHandler),\ + sizeof(KSPROPERTY),\ + sizeof(HANDLE),\ + (SetHandler),\ + NULL, 0, NULL, NULL, 0) + +#define DEFINE_KSPROPERTY_ITEM_STREAM_QUALITY(Handler)\ + DEFINE_KSPROPERTY_ITEM(\ + KSPROPERTY_STREAM_QUALITY,\ + (Handler),\ + sizeof(KSPROPERTY),\ + sizeof(KSQUALITY_MANAGER),\ + NULL, NULL, 0, NULL, NULL, 0) + +#define DEFINE_KSPROPERTY_ITEM_STREAM_DEGRADATION(GetHandler, SetHandler)\ + DEFINE_KSPROPERTY_ITEM(\ + KSPROPERTY_STREAM_DEGRADATION,\ + (GetHandler),\ + sizeof(KSPROPERTY),\ + 0,\ + (SetHandler),\ + NULL, 0, NULL, NULL, 0) + +#define DEFINE_KSPROPERTY_ITEM_STREAM_MASTERCLOCK(GetHandler, SetHandler)\ + DEFINE_KSPROPERTY_ITEM(\ + KSPROPERTY_STREAM_MASTERCLOCK,\ + (GetHandler),\ + sizeof(KSPROPERTY),\ + sizeof(HANDLE),\ + (SetHandler),\ + NULL, 0, NULL, NULL, 0) + +#define DEFINE_KSPROPERTY_ITEM_STREAM_TIMEFORMAT(Handler)\ + DEFINE_KSPROPERTY_ITEM(\ + KSPROPERTY_STREAM_TIMEFORMAT,\ + (Handler),\ + sizeof(KSPROPERTY),\ + sizeof(GUID),\ + NULL, NULL, 0, NULL, NULL, 0) + +#define DEFINE_KSPROPERTY_ITEM_STREAM_PRESENTATIONTIME(GetHandler, SetHandler)\ + DEFINE_KSPROPERTY_ITEM(\ + KSPROPERTY_STREAM_PRESENTATIONTIME,\ + (GetHandler),\ + sizeof(KSPROPERTY),\ + sizeof(KSTIME),\ + (SetHandler),\ + NULL, 0, NULL, NULL, 0) + +#define DEFINE_KSPROPERTY_ITEM_STREAM_PRESENTATIONEXTENT(Handler)\ + DEFINE_KSPROPERTY_ITEM(\ + KSPROPERTY_STREAM_PRESENTATIONEXTENT,\ + (Handler),\ + sizeof(KSPROPERTY),\ + sizeof(LONGLONG),\ + NULL, NULL, 0, NULL, NULL, 0) + +#define DEFINE_KSPROPERTY_ITEM_STREAM_FRAMETIME(Handler)\ + DEFINE_KSPROPERTY_ITEM(\ + KSPROPERTY_STREAM_FRAMETIME,\ + (Handler),\ + sizeof(KSPROPERTY),\ + sizeof(KSFRAMETIME),\ + NULL, NULL, 0, NULL, NULL, 0) + +#define DEFINE_KSPROPERTY_ITEM_STREAM_RATECAPABILITY(Handler)\ + DEFINE_KSPROPERTY_ITEM(\ + KSPROPERTY_STREAM_RATECAPABILITY,\ + (Handler),\ + sizeof(KSRATE_CAPABILITY),\ + sizeof(KSRATE),\ + NULL, NULL, 0, NULL, NULL, 0) + +#define DEFINE_KSPROPERTY_ITEM_STREAM_RATE(GetHandler, SetHandler)\ + DEFINE_KSPROPERTY_ITEM(\ + KSPROPERTY_STREAM_RATE,\ + (GetHandler),\ + sizeof(KSPROPERTY),\ + sizeof(KSRATE),\ + (SetHandler),\ + NULL, 0, NULL, NULL, 0) + +#define DEFINE_KSPROPERTY_ITEM_STREAM_PIPE_ID(GetHandler, SetHandler)\ + DEFINE_KSPROPERTY_ITEM(\ + KSPROPERTY_STREAM_PIPE_ID,\ + (GetHandler),\ + sizeof(KSPROPERTY),\ + sizeof(HANDLE),\ + (SetHandler),\ + NULL, 0, NULL, NULL, 0) } + + PKSQualityManager = ^TKSQualityManager; + KSQUALITY_MANAGER = record + QualityManager : THandle; + Context : Pointer; + end; + {$EXTERNALSYM KSQUALITY_MANAGER} + PKSQUALITY_MANAGER = ^KSQUALITY_MANAGER; + {$EXTERNALSYM PKSQUALITY_MANAGER} + TKSQualityManager = KSQUALITY_MANAGER; + + KSFRAMETIME = record + Duration : int64; + FrameFlags : ULONG; + Reserved : ULONG; + end; + {$EXTERNALSYM KSFRAMETIME} + PKSFRAMETIME = ^KSFRAMETIME; + {$EXTERNALSYM PKSFRAMETIME} + TKSFrameTime = KSFRAMETIME; +const + KSFRAMETIME_VARIABLESIZE = $00000001; + {$EXTERNALSYM KSFRAMETIME_VARIABLESIZE} + +type + KSRATE = record + {$EXTERNALSYM KSRATE} + PresentationStart : int64; + Duration : int64; + Interface_ : TKSPinInterface; + Rate : Longint; + Flags : ULONG; + end; + PKSRATE = ^KSRATE; + {$EXTERNALSYM PKSRATE} + TKSRate = KSRATE; + +const + KSRATE_NOPRESENTATIONSTART = $00000001; + {$EXTERNALSYM KSRATE_NOPRESENTATIONSTART} + KSRATE_NOPRESENTATIONDURATION = $00000002; + {$EXTERNALSYM KSRATE_NOPRESENTATIONDURATION} + +type + PKSRateCapability = ^TKSRateCapability; + KSRATE_CAPABILITY = record + Property_ : KSPROPERTY; + Rate : TKSRATE; + end; + {$EXTERNALSYM KSRATE_CAPABILITY} + PKSRATE_CAPABILITY = ^KSRATE_CAPABILITY; + {$EXTERNALSYM PKSRATE_CAPABILITY} + TKSRateCapability = KSRATE_CAPABILITY; + +const + KSPROPSETID_Clock : TGUID = '{DF12A4C0-AC17-11CF-A5D6-28DB04C10000}'; + {$EXTERNALSYM KSPROPSETID_Clock} + +// +// Performs a x*y/z operation on 64 bit quantities by splitting the operation. The equation +// is simplified with respect to adding in the remainder for the upper 32 bits. +// +// (xh * 10000000 / Frequency) * 2^32 + ((((xh * 10000000) % Frequency) * 2^32 + (xl * 10000000)) / Frequency) +// + NANOSECONDS = 10000000; + {$EXTERNALSYM NANOSECONDS} +{#define KSCONVERT_PERFORMANCE_TIME(Frequency, PerformanceTime) \ + ((((ULONGLONG)(ULONG)(PerformanceTime).HighPart * NANOSECONDS / (Frequency)) << 32) + \ + ((((((ULONGLONG)(ULONG)(PerformanceTime).HighPart * NANOSECONDS) % (Frequency)) << 32) + \ + ((ULONGLONG)(PerformanceTime).LowPart * NANOSECONDS)) / (Frequency)))} + +type + PKSClockCreate = ^TKSClockCreate; + KSCLOCK_CREATE = record + CreateFlags : ULONG; + end; + {$EXTERNALSYM KSCLOCK_CREATE} + PKSCLOCK_CREATE = ^KSCLOCK_CREATE; + {$EXTERNALSYM PKSCLOCK_CREATE} + TKSClockCreate = KSCLOCK_CREATE; + + PKSCorrelatedTime = ^TKSCorrelatedTime; + KSCORRELATED_TIME = record + Time : int64; + SystemTime : int64; + end; + {$EXTERNALSYM KSCORRELATED_TIME} + PKSCORRELATED_TIME = ^KSCORRELATED_TIME; + {$EXTERNALSYM PKSCORRELATED_TIME} + TKSCorrelatedTime = KSCORRELATED_TIME; + + KSRESOLUTION = record + Granularity : int64; + Error : int64; + end; + {$EXTERNALSYM KSRESOLUTION} + PKSRESOLUTION = ^KSRESOLUTION; + {$EXTERNALSYM PKSRESOLUTION} + TKSResolution = KSRESOLUTION; + + KSPROPERTY_CLOCK = ( + KSPROPERTY_CLOCK_TIME, + KSPROPERTY_CLOCK_PHYSICALTIME, + KSPROPERTY_CLOCK_CORRELATEDTIME, + KSPROPERTY_CLOCK_CORRELATEDPHYSICALTIME, + KSPROPERTY_CLOCK_RESOLUTION, + KSPROPERTY_CLOCK_STATE + ); + {$EXTERNALSYM KSPROPERTY_CLOCK} + TKSPropertyClock = KSPROPERTY_CLOCK; + +const + KSEVENTSETID_Clock : TGUID = '{364D8E20-62C7-11CF-A5D6-28DB04C10000}'; + {$EXTERNALSYM KSEVENTSETID_Clock} + +type + KSEVENT_CLOCK_POSITION = ( + KSEVENT_CLOCK_INTERVAL_MARK, + KSEVENT_CLOCK_POSITION_MARK + ); + {$EXTERNALSYM KSEVENT_CLOCK_POSITION} + TKSEventClockPosition = KSEVENT_CLOCK_POSITION; + +const + KSEVENTSETID_Connection : TGUID = '{7f4bcbe0-9ea5-11cf-a5d6-28db04c10000}'; + {$EXTERNALSYM KSEVENTSETID_Connection} + +type + KSEVENT_CONNECTION = ( + KSEVENT_CONNECTION_POSITIONUPDATE, + KSEVENT_CONNECTION_DATADISCONTINUITY, + KSEVENT_CONNECTION_TIMEDISCONTINUITY, + KSEVENT_CONNECTION_PRIORITY, + KSEVENT_CONNECTION_ENDOFSTREAM + ); + {$EXTERNALSYM KSEVENT_CONNECTION} + TKSEventConnection = KSEVENT_CONNECTION; + + KSQUALITY = record + Context : Pointer; + Proportion : ULONG; + DeltaTime : int64; + end; + {$EXTERNALSYM KSQUALITY} + PKSQUALITY = ^KSQUALITY; + {$EXTERNALSYM PKSQUALITY} + TKSQuality = KSQUALITY; + + KSERROR = record + {$EXTERNALSYM KSERROR} + Context : Pointer; + Status : ULONG; + end; + PKSERROR = ^KSERROR; + {$EXTERNALSYM PKSERROR} + TKSError = KSERROR; + + PKSDEGRADE = ^KSDEGRADE; + {$EXTERNALSYM PKSDEGRADE} + KSDEGRADE = KSIDENTIFIER; + {$EXTERNALSYM KSDEGRADE} + + TKSDegrade = KSDEGRADE; + +const + KSDEGRADESETID_Standard : TGUID = '{9F564180-704C-11D0-A5D6-28DB04C10000}'; + {$EXTERNALSYM KSDEGRADESETID_Standard} + +type + KSDEGRADE_STANDARD = ( + KSDEGRADE_STANDARD_SAMPLE, + KSDEGRADE_STANDARD_QUALITY, + KSDEGRADE_STANDARD_COMPUTATION, + KSDEGRADE_STANDARD_SKIP + ); + {$EXTERNALSYM KSDEGRADE_STANDARD} + TKSDegradeStandard = KSDEGRADE_STANDARD; + +//#if !defined( PACK_PRAGMAS_NOT_SUPPORTED ) +//#include +//#endif + + KSPROPERTY_SERIALHDR = record + PropertySet : TGUID; + Count : ULONG; + end; + {$EXTERNALSYM KSPROPERTY_SERIALHDR} + PKSPROPERTY_SERIALHDR = ^KSPROPERTY_SERIALHDR; + {$EXTERNALSYM PKSPROPERTY_SERIALHDR} + TKSPropertySerialHDR = KSPROPERTY_SERIALHDR; + +//#if !defined( PACK_PRAGMAS_NOT_SUPPORTED ) +//#include +//#endif + + PKSPropertySerial = ^TKSPropertySerial; + KSPROPERTY_SERIAL = record + PropTypeSet : TKSIdentifier; + Id : ULONG; + PropertyLength : ULONG; + end; + {$EXTERNALSYM KSPROPERTY_SERIAL} + PKSPROPERTY_SERIAL = ^KSPROPERTY_SERIAL; + {$EXTERNALSYM PKSPROPERTY_SERIAL} + TKSPropertySerial = KSPROPERTY_SERIAL; + +//=========================================================================== +// +// exported prototypes + + +// From WinNT.h (H.GOURVEST) +// Define the access mask as a longword sized structure divided up as +// follows: +// +// 3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 +// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 +// +---------------+---------------+-------------------------------+ +// |G|G|G|G|Res'd|A| StandardRights| SpecificRights | +// |R|W|E|A| |S| | | +// +-+-------------+---------------+-------------------------------+ +// +// typedef struct _ACCESS_MASK { +// WORD SpecificRights; +// BYTE StandardRights; +// BYTE AccessSystemAcl : 1; +// BYTE Reserved : 3; +// BYTE GenericAll : 1; +// BYTE GenericExecute : 1; +// BYTE GenericWrite : 1; +// BYTE GenericRead : 1; +// } ACCESS_MASK; +// typedef ACCESS_MASK *PACCESS_MASK; +// +// but to make life simple for programmer's we'll allow them to specify +// a desired access mask by simply OR'ing together mulitple single rights +// and treat an access mask as a DWORD. For example +// +// DesiredAccess = DELETE | READ_CONTROL +// +// So we'll declare ACCESS_MASK as DWORD +// + + function KsCreateAllocator(ConnectionHandle: THandle; + AllocatorFraming: PKSAllocatorFraming; + out AllocatorHandle: PHandle): DWORD; stdcall; + {$EXTERNALSYM KsCreateAllocator} + + function KsCreateClock(ConnectionHandle: THandle; + ClockCreate: PKSClockCreate; + out ClockHandle: PHandle): DWORD; stdcall; + {$EXTERNALSYM KsCreateClock} + + function KsCreatePin(FilterHandle: THandle; + Connect: PKSPinConnect; + DesiredAccess: ACCESS_MASK ; + out ConnectionHandle: PHandle): DWORD; stdcall; + {$EXTERNALSYM KsCreatePin} + + function KsCreateTopologyNode(ParentHandle: THandle; + NodeCreate: PKSNodeCreate; + DesiredAccess: ACCESS_MASK; + out NodeHandle: PHandle): DWORD; stdcall; + {$EXTERNALSYM KsCreateTopologyNode} + +{=============================================================================== +* +* Copyright (C) Microsoft Corporation, 1996 - 1999 +* Module Name: ksproxy.h +* Abstract : Interface definitions for WDM-CSA proxy filters. +* +*==============================================================================} +const + IID_IKsObject : TGUID = (D1:$423c13a2;D2:$2070;D3:$11d0;D4:($9e,$f7,$00,$aa,$00,$a2,$16,$a1)); + {$EXTERNALSYM IID_IKsObject} + STATIC_IID_IKsObject : TGUID = (D1:$423c13a2;D2:$2070;D3:$11d0;D4:($9e,$f7,$00,$aa,$00,$a2,$16,$a1)); + {$EXTERNALSYM STATIC_IID_IKsObject} + + IID_IKsPinEx : TGUID = (D1:$7bb38260;D2:$d19c;D3:$11d2;D4:($b3,$8a,$00,$a0,$c9,$5e,$c2,$2e)); + {$EXTERNALSYM IID_IKsPinEx} + STATIC_IID_IKsPinEx : TGUID = (D1:$7bb38260;D2:$d19c;D3:$11d2;D4:($b3,$8a,$00,$a0,$c9,$5e,$c2,$2e)); + {$EXTERNALSYM STATIC_IID_IKsPinEx} + + IID_IKsPinPipe : TGUID = (D1:$e539cd90;D2:$a8b4;D3:$11d1;D4:($81,$89,$00,$a0,$c9,$06,$28,$02)); + {$EXTERNALSYM IID_IKsPinPipe} + STATIC_IID_IKsPinPipe : TGUID = (D1:$e539cd90;D2:$a8b4;D3:$11d1;D4:($81,$89,$00,$a0,$c9,$06,$28,$02)); + {$EXTERNALSYM STATIC_IID_IKsPinPipe} + + IID_IKsDataTypeCompletion : TGUID = (D1:$827D1A0E;D2:$0F73;D3:$11D2;D4:($B2,$7A,$00,$A0,$C9,$22,$31,$96)); + {$EXTERNALSYM IID_IKsDataTypeCompletion} + STATIC_IID_IKsDataTypeCompletion : TGUID = (D1:$827D1A0E;D2:$0F73;D3:$11D2;D4:($B2,$7A,$00,$A0,$C9,$22,$31,$96)); + {$EXTERNALSYM STATIC_IID_IKsDataTypeCompletion} + + IID_IKsClockPropertySet : TGUID = (D1:$5C5CBD84;D2:$E755;D3:$11D0;D4:($AC,$18,$00,$A0,$C9,$22,$31,$96)); + {$EXTERNALSYM IID_IKsClockPropertySet} + STATIC_IID_IKsClockPropertySet : TGUID = (D1:$5C5CBD84;D2:$E755;D3:$11D0;D4:($AC,$18,$00,$A0,$C9,$22,$31,$96)); + {$EXTERNALSYM STATIC_IID_IKsClockPropertySet} + + IID_IKsAllocator : TGUID = (D1:$8da64899;D2:$c0d9;D3:$11d0;D4:($84,$13,$00,$00,$f8,$22,$fe,$8a)); + {$EXTERNALSYM IID_IKsAllocator} + STATIC_IID_IKsAllocator : TGUID = (D1:$8da64899;D2:$c0d9;D3:$11d0;D4:($84,$13,$00,$00,$f8,$22,$fe,$8a)); + {$EXTERNALSYM STATIC_IID_IKsAllocator} + + IID_IKsAllocatorEx : TGUID = (D1:$091bb63a;D2:$603f;D3:$11d1;D4:($b0,$67,$00,$a0,$c9,$06,$28,$02)); + {$EXTERNALSYM IID_IKsAllocatorEx} + STATIC_IID_IKsAllocatorEx : TGUID = (D1:$091bb63a;D2:$603f;D3:$11d1;D4:($b0,$67,$00,$a0,$c9,$06,$28,$02)); + {$EXTERNALSYM STATIC_IID_IKsAllocatorEx} + + IID_IKsTopology : TGUID = (D1:$28F54683;D2:$06FD;D3:$11D2;D4:($B2,$7A,$00,$A0,$C9,$22,$31,$96)); + {$EXTERNALSYM IID_IKsTopology} + STATIC_IID_IKsTopology : TGUID = (D1:$28F54683;D2:$06FD;D3:$11D2;D4:($B2,$7A,$00,$A0,$C9,$22,$31,$96)); + {$EXTERNALSYM STATIC_IID_IKsTopology} + + IID_IKsAggregateControl : TGUID = (D1:$7F40EAC0;D2:$3947;D3:$11D2;D4:($87,$4E,$00,$A0,$C9,$22,$31,$96)); + {$EXTERNALSYM IID_IKsAggregateControl} + STATIC_IID_IKsAggregateControl : TGUID = (D1:$7F40EAC0;D2:$3947;D3:$11D2;D4:($87,$4E,$00,$A0,$C9,$22,$31,$96)); + {$EXTERNALSYM STATIC_IID_IKsAggregateControl} + + CLSID_Proxy : TGUID = (D1:$17CCA71B;D2:$ECD7;D3:$11D0;D4:($B9,$08,$00,$A0,$C9,$22,$31,$96)); + {$EXTERNALSYM CLSID_Proxy} + + IID_IKsQualityForwarder : TGUID = '{97EBAACB-95BD-11D0-A3EA-00A0C9223196}'; + {$EXTERNALSYM IID_IKsQualityForwarder} + STATIC_IID_IKsQualityForwarder : TGUID = '{97EBAACB-95BD-11D0-A3EA-00A0C9223196}'; + {$EXTERNALSYM STATIC_IID_IKsQualityForwarder} + + IID_IKsNotifyEvent : TGUID = '{412bd695-f84b-46c1-ac73-54196dbc8fa7}'; + {$EXTERNALSYM IID_IKsNotifyEvent} + +type + KSALLOCATORMODE = ( + KsAllocatorMode_User, + KsAllocatorMode_Kernel + ); + {$EXTERNALSYM KSALLOCATORMODE} + TKSAllocatorMode = KSALLOCATORMODE; + + PFramingProp = ^TFramingProp; + FRAMING_PROP = ( + FramingProp_Uninitialized, + FramingProp_None, + FramingProp_Old, + FramingProp_Ex + ); + {$EXTERNALSYM FRAMING_PROP} + PFRAMING_PROP = ^FRAMING_PROP; + {$EXTERNALSYM PFRAMING_PROP} + TFramingProp = FRAMING_PROP; + + FRAMING_CACHE_OPS = ( + Framing_Cache_Update, // request to bypass cache when read/write + Framing_Cache_ReadLast, + Framing_Cache_ReadOrig, + Framing_Cache_Write + ); + {$EXTERNALSYM FRAMING_CACHE_OPS} + TFramingCacheOps = FRAMING_CACHE_OPS; + + OPTIMAL_WEIGHT_TOTALS = record + MinTotalNominator : int64; + MaxTotalNominator : int64; + TotalDenominator : int64; + end; + {$EXTERNALSYM OPTIMAL_WEIGHT_TOTALS} + TOptimalWeightTotals = OPTIMAL_WEIGHT_TOTALS; + +// +// allocators strategy is defined by graph manager +// +const + AllocatorStrategy_DontCare = 0; + {$EXTERNALSYM AllocatorStrategy_DontCare} + +// +// what to optimize +// + AllocatorStrategy_MinimizeNumberOfFrames = $00000001; + {$EXTERNALSYM AllocatorStrategy_MinimizeNumberOfFrames} + AllocatorStrategy_MinimizeFrameSize = $00000002; + {$EXTERNALSYM AllocatorStrategy_MinimizeFrameSize} + AllocatorStrategy_MinimizeNumberOfAllocators = $00000004; + {$EXTERNALSYM AllocatorStrategy_MinimizeNumberOfAllocators} + AllocatorStrategy_MaximizeSpeed = $00000008; + {$EXTERNALSYM AllocatorStrategy_MaximizeSpeed} + +// +// factors (flags) defining the Pipes properties +// + PipeFactor_None = 0; + {$EXTERNALSYM PipeFactor_None} + PipeFactor_UserModeUpstream = $00000001; + {$EXTERNALSYM PipeFactor_UserModeUpstream} + PipeFactor_UserModeDownstream = $00000002; + {$EXTERNALSYM PipeFactor_UserModeDownstream} + PipeFactor_MemoryTypes = $00000004; + {$EXTERNALSYM PipeFactor_MemoryTypes} + PipeFactor_Flags = $00000008; + {$EXTERNALSYM PipeFactor_Flags} + PipeFactor_PhysicalRanges = $00000010; + {$EXTERNALSYM PipeFactor_PhysicalRanges} + PipeFactor_OptimalRanges = $00000020; + {$EXTERNALSYM PipeFactor_OptimalRanges} + PipeFactor_FixedCompression = $00000040; + {$EXTERNALSYM PipeFactor_FixedCompression} + PipeFactor_UnknownCompression = $00000080; + {$EXTERNALSYM PipeFactor_UnknownCompression} + PipeFactor_Buffers = $00000100; + {$EXTERNALSYM PipeFactor_Buffers} + PipeFactor_Align = $00000200; + {$EXTERNALSYM PipeFactor_Align} + + PipeFactor_PhysicalEnd = $00000400; + {$EXTERNALSYM PipeFactor_PhysicalEnd} + PipeFactor_LogicalEnd = $00000800; + {$EXTERNALSYM PipeFactor_LogicalEnd} + +type + PIPE_STATE = ( + PipeState_DontCare, + PipeState_RangeNotFixed, + PipeState_RangeFixed, + PipeState_CompressionUnknown, + PipeState_Finalized + ); + {$EXTERNALSYM PIPE_STATE} + TPipeState = PIPE_STATE; + +// +// pipe dimensions relative to BeginPin. +// + PPipeDimensions = ^TPipeDimensions; + PIPE_DIMENSIONS = record + AllocatorPin : TKSCompression; + MaxExpansionPin : TKSCompression; + EndPin : TKSCompression; + end; + {$EXTERNALSYM PIPE_DIMENSIONS} + PPIPE_DIMENSIONS = ^PIPE_DIMENSIONS; + {$EXTERNALSYM PPIPE_DIMENSIONS} + TPipeDimensions = PIPE_DIMENSIONS; + + PPipeAllocatorPlace = ^TPipeAllocatorPlace; + PIPE_ALLOCATOR_PLACE = ( + Pipe_Allocator_None, + Pipe_Allocator_FirstPin, + Pipe_Allocator_LastPin, + Pipe_Allocator_MiddlePin + ); + {$EXTERNALSYM PIPE_ALLOCATOR_PLACE} + PPIPE_ALLOCATOR_PLACE = ^PIPE_ALLOCATOR_PLACE; + {$EXTERNALSYM PPIPE_ALLOCATOR_PLACE} + TPipeAllocatorPlace = PIPE_ALLOCATOR_PLACE; + + PKSLogicalMemoryType = ^TKSLogicalMemoryType; + KS_LogicalMemoryType = ( + KS_MemoryTypeDontCare, + KS_MemoryTypeKernelPaged, + KS_MemoryTypeKernelNonPaged, + KS_MemoryTypeDeviceHostMapped, + KS_MemoryTypeDeviceSpecific, + KS_MemoryTypeUser, + KS_MemoryTypeAnyHost + ); + {$EXTERNALSYM KS_LogicalMemoryType} + PKS_LogicalMemoryType = ^KS_LogicalMemoryType; + {$EXTERNALSYM PKS_LogicalMemoryType} + TKSLogicalMemoryType = KS_LogicalMemoryType; + + PIPE_TERMINATION = record + Flags : ULONG; + OutsideFactors : ULONG; + Weigth : ULONG; // outside weight + PhysicalRange : TKSFramingRange; + OptimalRange : TKSFramingRangeWeighted; + Compression : TKSCompression; // relative to the connected pin on a neighboring filter. + end; + {$EXTERNALSYM PIPE_TERMINATION} + TPipeTermination = PIPE_TERMINATION; + + IKsAllocatorEx = interface; + +// +// extended allocator properties +// + PAllocatorPropertiesEx = ^TAllocatorPropertiesEx; + ALLOCATOR_PROPERTIES_EX = record + cBuffers : longint; + cbBuffer : longint; + cbAlign : longint; + cbPrefix : longint; +// new part + MemoryType : TGUID; + BusType : TGUID; // one of the buses this pipe is using + State : TPipeState; + Input : TPipeTermination; + Output : TPipeTermination; + Strategy : ULONG; + Flags : ULONG; + Weight : ULONG; + LogicalMemoryType : TKSLogicalMemoryType; + AllocatorPlace : TPipeAllocatorPlace; + Dimensions : TPipeDimensions; + PhysicalRange : TKSFramingRange; // on allocator pin + PrevSegment : IKsAllocatorEx; // doubly-linked list of KS allocators + CountNextSegments : ULONG; // possible multiple dependent pipes + NextSegments : IKsAllocatorEx; + InsideFactors : ULONG; // existing factors (different from "don't care") + NumberPins : ULONG; + end; + {$EXTERNALSYM ALLOCATOR_PROPERTIES_EX} + PALLOCATOR_PROPERTIES_EX =^ALLOCATOR_PROPERTIES_EX; + {$EXTERNALSYM PALLOCATOR_PROPERTIES_EX} + TAllocatorPropertiesEx = ALLOCATOR_PROPERTIES_EX; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IKsClockPropertySet;'} + {$EXTERNALSYM IKsClockPropertySet} + IKsClockPropertySet = interface(IUnknown) + ['{5C5CBD84-E755-11D0-AC18-00A0C9223196}'] + (*** IKsClockPropertySet methods ***) + procedure KsGetTime(out Time: int64); stdcall; + procedure KsSetTime(Time: int64); stdcall; + procedure KsGetPhysicalTime(out Time: int64); stdcall; + procedure KsSetPhysicalTime(Time: int64); stdcall; + procedure KsGetCorrelatedTime(out CorrelatedTime: TKSCorrelatedTime); stdcall; + procedure KsSetCorrelatedTime(CorrelatedTime: TKSCorrelatedTime); stdcall; + procedure KsGetCorrelatedPhysicalTime(out CorrelatedTime: TKSCorrelatedTime); stdcall; + procedure KsSetCorrelatedPhysicalTime(CorrelatedTime: TKSCorrelatedTime); stdcall; + procedure KsGetResolution(out Resolution: TKSResolution); stdcall; + procedure KsGetState(out State: TKSState); stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IKsAllocator;'} + {$EXTERNALSYM IKsAllocator} + IKsAllocator = interface(IUnknown) + ['{8da64899-c0d9-11d0-8413-0000f822fe8a}'] + (*** IKsAllocator methods ***) + function KsGetAllocatorHandle: THandle; stdcall; + function KsGetAllocatorMode: TKSALLOCATORMODE; stdcall; + procedure KsGetAllocatorStatus(AllocatorStatus: PKSSTREAMALLOCATOR_STATUS); stdcall; + procedure KsSetAllocatorMode(Mode: TKSALLOCATORMODE); stdcall; + end; + + IKsPin = interface; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IKsAllocatorEx;'} + {$EXTERNALSYM IKsAllocatorEx} + IKsAllocatorEx = interface(IKsAllocator) + ['{091bb63a-603f-11d1-b067-00a0c9062802}'] + (*** IKsAllocatorEx methods ***) + function KsGetProperties: TAllocatorPropertiesEx; stdcall; + procedure KsSetProperties(PROPERTIES: PALLOCATOR_PROPERTIES_EX); stdcall; + procedure KsSetAllocatorHandle(AllocatorHandle: THandle); stdcall; + function KsCreateAllocatorAndGetHandle(KsPin: IKsPin): THandle; stdcall; + end; + + KSPEEKOPERATION = ( + KsPeekOperation_PeekOnly, + KsPeekOperation_AddRef + ); + {$EXTERNALSYM KSPEEKOPERATION} + TKSPeekOperation = KSPEEKOPERATION; + + IKsInterfaceHandler = interface; + IKsDataTypeHandler = interface; + + KSIOOPERATION = ( + KsIoOperation_Write, + KsIoOperation_Read + ); + {$EXTERNALSYM KSIOOPERATION} + TKSIOOperation = KSIOOPERATION; + + PKSStreamSegment = ^TKSStreamSegment; + KSSTREAM_SEGMENT = record + KsInterfaceHandler : IKsInterfaceHandler; + KsDataTypeHandler : IKsDataTypeHandler; + IoOperation : TKSIOOPERATION; + CompletionEvent : THandle; + end; + {$EXTERNALSYM KSSTREAM_SEGMENT} + PKSSTREAM_SEGMENT = ^KSSTREAM_SEGMENT; + {$EXTERNALSYM PKSSTREAM_SEGMENT} + TKSStreamSegment = KSSTREAM_SEGMENT; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IKsPin;'} + {$EXTERNALSYM IKsPin} + IKsPin = interface(IUnknown) + ['{b61178d1-a2d9-11cf-9e53-00aa00a216a1}'] + (*** IKsPin methods ***) + // [pjh, 2003-07-14] fix wrong translation + function KsQueryMediums(out MediumList: PKSMULTIPLE_ITEM): HResult; stdcall; + function KsQueryInterfaces(InterfaceList: PKSMULTIPLE_ITEM): HResult; stdcall; + function KsCreateSinkPinHandle(Interface_: TKSPinInterface; Medium: TKSPinMedium): HResult; stdcall; + function KsGetCurrentCommunication(Communication: PKSPIN_COMMUNICATION; + Interface_: PKSPIN_INTERFACE; Medium: PKSPIN_MEDIUM): HResult; stdcall; + function KsPropagateAcquire: HResult; stdcall; + function KsDeliver(Sample: IMediaSample; Flags: ULONG): HResult; stdcall; + function KsMediaSamplesCompleted(StreamSegment: PKSSTREAM_SEGMENT): HResult; stdcall; + function KsPeekAllocator(Operation: TKSPEEKOPERATION): IMemAllocator; stdcall; + function KsReceiveAllocator(MemAllocator: IMemAllocator): HResult; stdcall; + function KsRenegotiateAllocator: HResult; stdcall; + function KsIncrementPendingIoCount: Longint; stdcall; + function KsDecrementPendingIoCount: Longint; stdcall; + function KsQualityNotify(Proportion: ULONG; TimeDelta: TReferenceTime): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IKsPinEx;'} + {$EXTERNALSYM IKsPinEx} + IKsPinEx = interface(IKsPin) + ['{7bb38260-d19c-11d2-b38a-00a0c95ec22e}'] + (*** IKsPinEx methods ***) + procedure KsNotifyError(Sample: IMediaSample; hr: HResult); + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IKsPinPipe;'} + {$EXTERNALSYM IKsPinPipe} + IKsPinPipe = interface(IUnknown) + ['{e539cd90-a8b4-11d1-8189-00a0c9062802}'] + (*** IKsPinPipe methods ***) + procedure KsGetPinFramingCache(FramingEx: PKSALLOCATOR_FRAMING_EX; + FramingProp: PFRAMING_PROP; Option: TFramingCacheOps); stdcall; + procedure KsSetPinFramingCache(FramingEx: PKSALLOCATOR_FRAMING_EX; + FramingProp: PFRAMING_PROP; Option: TFramingCacheOps); stdcall; + function KsGetConnectedPin: IPin; stdcall; + function KsGetPipe(Operation: TKSPEEKOPERATION): IKsAllocatorEx; stdcall; + procedure KsSetPipe(KsAllocator: IKsAllocatorEx); stdcall; + function KsGetPipeAllocatorFlag: ULONG; stdcall; + procedure KsSetPipeAllocatorFlag(Flag: ULONG); stdcall; + function KsGetPinBusCache: TGUID; stdcall; + procedure KsSetPinBusCache(const Bus: TGUID); stdcall; + // very useful methods for tracing. + function KsGetPinName: PWideChar; stdcall; + function KsGetFilterName: PWideChar; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IKsPinFactory;'} + {$EXTERNALSYM IKsPinFactory} + IKsPinFactory = interface(IUnknown) + ['{CD5EBE6B-8B6E-11D1-8AE0-00A0C9223196}'] + (*** IKsPinFactory methods ***) + procedure KsPinFactory(PinFactory: PULONG); stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IKsDataTypeHandler;'} + {$EXTERNALSYM IKsDataTypeHandler} + IKsDataTypeHandler = interface(IUnknown) + ['{5ffbaa02-49a3-11d0-9f36-00aa00a216a1}'] + (*** IKsDataTypeHandler methods ***) + procedure KsCompleteIoOperation(Sample: IMediaSample; StreamHeader: Pointer; + IoOperation: TKSIOOPERATION; Cancelled: BOOL); stdcall; + procedure KsIsMediaTypeInRanges(DataRanges: Pointer); stdcall; + procedure KsPrepareIoOperation(Sample: IMediaSample; StreamHeader: Pointer; + IoOperation: TKSIOOPERATION); stdcall; + procedure KsQueryExtendedSize(var ExtendedSize: ULONG); stdcall; + procedure KsSetMediaType(const AmMediaType: TAMMediaType); stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IKsDataTypeCompletion;'} + {$EXTERNALSYM IKsDataTypeCompletion} + IKsDataTypeCompletion = interface(IUnknown) + ['{827D1A0E-0F73-11D2-B27A-00A0C9223196}'] + (*** IKsDataTypeCompletion methods ***) + procedure KsCompleteMediaType(FilterHandle: THandle; PinFactoryId: ULONG; + var AmMediaType: TAMMediaType); stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IKsInterfaceHandler;'} + {$EXTERNALSYM IKsInterfaceHandler} + IKsInterfaceHandler = interface(IUnknown) + ['{D3ABC7E0-9A61-11d0-A40D-00A0C9223196}'] + (*** IKsInterfaceHandler methods ***) + procedure KsSetPin(KsPin: IKsPin); stdcall; + procedure KsProcessMediaSamples(KsDataTypeHandler: IKsDataTypeHandler; + SampleList: IMediaSample; SampleCount: PLongint; + IoOperation: TKSIOOPERATION; StreamSegment: PKSSTREAM_SEGMENT); stdcall; + procedure KsCompleteIo(StreamSegment: PKSSTREAM_SEGMENT); stdcall; + end; + + +// +// This structure definition is the common header required by the proxy to +// dispatch the stream segment to the interface handler. Interface handlers +// will create extended structures to include other information such as +// media samples, extended header size and so on. + + + {$HPPEMIT 'typedef System::DelphiInterface _di_IKsObject;'} + {$EXTERNALSYM IKsObject} + IKsObject = interface(IUnknown) + ['{423c13a2-2070-11d0-9ef7-00aa00a216a1}'] + (*** IKsObject methods ***) + function KsGetObjectHandle: THandle; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IKsQualityForwarder;'} + {$EXTERNALSYM IKsQualityForwarder} + IKsQualityForwarder = interface(IUnknown) + ['{97ebaacb-95bd-11d0-a3ea-00a0c9223196}'] + (*** IKsQualityForwarder methods ***) + procedure KsFlushClient(Pin: IKsPin); stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IKsNotifyEvent;'} + {$EXTERNALSYM IKsNotifyEvent} + IKsNotifyEvent = interface(IUnknown) + ['{412bd695-f84b-46c1-ac73-54196dbc8fa7}'] + (*** IKsNotifyEvent methods ***) + procedure KsNotifyEvent(Event,lParam1, lParam2: ULONG); stdcall; + end; + + function KsResolveRequiredAttributes(DataRange: PKSDATARANGE; + {OPTIONAL}Attributes: PKSMULTIPLE_ITEM): HResult; stdcall; + {$EXTERNALSYM KsResolveRequiredAttributes} + + function KsOpenDefaultDevice(Category: TGUID; Access: ACCESS_MASK; + DeviceHandle: PHANDLE): HResult; stdcall; + {$EXTERNALSYM KsOpenDefaultDevice} + + function KsSynchronousDeviceControl(Handle: THandle; IoControl: ULONG; + InBuffer: Pointer; InLength: ULONG; OutBuffer: Pointer; + OutLength: ULONG; BytesReturned: PULONG): HResult; stdcall; + {$EXTERNALSYM KsSynchronousDeviceControl} + + function KsGetMultiplePinFactoryItems(FilterHandle: THandle; PinFactoryId: ULONG; + PropertyId: ULONG; Items: Pointer): HResult; stdcall; + {$EXTERNALSYM KsGetMultiplePinFactoryItems} + + function KsGetMediaTypeCount(FilterHandle: THandle; PinFactoryId: ULONG; + out MediaTypeCount: ULONG): HResult; stdcall; + {$EXTERNALSYM KsGetMediaTypeCount} + + function KsGetMediaType(Position: integer; out AmMediaType: TAMMediaType; + FilterHandle: THandle; PinFactoryId: ULONG): HResult; stdcall; + {$EXTERNALSYM KsGetMediaType} + +type + {$HPPEMIT 'typedef System::DelphiInterface _di_IKsAggregateControl;'} + {$EXTERNALSYM IKsAggregateControl} + IKsAggregateControl = interface(IUnknown) + ['{7F40EAC0-3947-11D2-874E-00A0C9223196}'] + (*** IKsAggregateControl methods ***) + procedure KsAddAggregate(const AggregateClass: TGUID); stdcall; + procedure KsRemoveAggregate(const AggregateClass: TGUID); stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IKsTopology;'} + {$EXTERNALSYM IKsTopology} + IKsTopology = interface(IUnknown) + ['{28F54683-06FD-11D2-B27A-00A0C9223196}'] + (*** IKsTopology methods ***) + procedure CreateNodeInstance(NodeId: ULONG; Flags: ULONG; DesiredAccess: ACCESS_MASK; + {OPTIONAL}UnkOuter: IUnknown; const InterfaceId: TGUID; out Interface_); stdcall; + end; + + {***************************************************************************** + * Copyright (C) Microsoft Corporation, 1996 - 2000 * + * * + * Module Name: ksmedia.h * + * * + * Abstract: WDM-CSA Multimedia Definitions. * + * * + *****************************************************************************} + + PKSMultipleDataProp = ^TKSMultipleDataProp; + KSMULTIPLE_DATA_PROP = record + Property_ : KSPROPERTY; + MultipleItem : TKSMultipleItem; + end; + {$EXTERNALSYM KSMULTIPLE_DATA_PROP} + PKSMULTIPLE_DATA_PROP = ^KSMULTIPLE_DATA_PROP; + {$EXTERNALSYM PKSMULTIPLE_DATA_PROP} + TKSMultipleDataProp = KSMULTIPLE_DATA_PROP; + +const + KSMEDIUMSETID_MidiBus : TGUID = '{05908040-3246-11D0-A5D6-28DB04C10000}'; + {$EXTERNALSYM KSMEDIUMSETID_MidiBus} + KSMEDIUMSETID_VPBus : TGUID = '{A18C15EC-CE43-11D0-ABE7-00A0C9223196}'; + {$EXTERNALSYM KSMEDIUMSETID_VPBus} + KSINTERFACESETID_Media : TGUID = '{3A13EB40-30A7-11D0-A5D6-28DB04C10000}'; + {$EXTERNALSYM KSINTERFACESETID_Media} + +type + KSINTERFACE_MEDIA = ( + KSINTERFACE_MEDIA_MUSIC, + KSINTERFACE_MEDIA_WAVE_BUFFERED, + KSINTERFACE_MEDIA_WAVE_QUEUED + ); + {$EXTERNALSYM KSINTERFACE_MEDIA} + TKSInterfaceMedia = KSINTERFACE_MEDIA; + +// USB Terminals +//#define INIT_USB_TERMINAL(guid, id)\ +{\ + (guid)->Data1 = 0xDFF219E0 + (USHORT)(id);\ + (guid)->Data2 = 0xF70F;\ + (guid)->Data3 = 0x11D0;\ + (guid)->Data4[0] = 0xb9;\ + (guid)->Data4[1] = 0x17;\ + (guid)->Data4[2] = 0x00;\ + (guid)->Data4[3] = 0xa0;\ + (guid)->Data4[4] = 0xc9;\ + (guid)->Data4[5] = 0x22;\ + (guid)->Data4[6] = 0x31;\ + (guid)->Data4[7] = 0x96;\ +} + +{#define EXTRACT_USB_TERMINAL(guid)\ + (USHORT)((guid)->Data1 - 0xDFF219E0) +#define DEFINE_USB_TERMINAL_GUID(id)\ + 0xDFF219E0+(USHORT)(id), 0xF70F, 0x11D0, 0xB9, 0x17, 0x00, 0xA0, 0xC9, 0x22, 0x31, 0x96} +const + KSNODETYPE_MICROPHONE : TGUID = '{DFF21BE1-F70F-11D0-B917-00A0C9223196}'; + {$EXTERNALSYM KSNODETYPE_MICROPHONE} + KSNODETYPE_DESKTOP_MICROPHONE : TGUID = '{DFF21BE2-F70F-11D0-B917-00A0C9223196}'; + {$EXTERNALSYM KSNODETYPE_DESKTOP_MICROPHONE} + KSNODETYPE_PERSONAL_MICROPHONE : TGUID = '{DFF21BE3-F70F-11D0-B917-00A0C9223196}'; + {$EXTERNALSYM KSNODETYPE_PERSONAL_MICROPHONE} + KSNODETYPE_OMNI_DIRECTIONAL_MICROPHONE : TGUID = '{DFF21BE4-F70F-11D0-B917-00A0C9223196}'; + {$EXTERNALSYM KSNODETYPE_OMNI_DIRECTIONAL_MICROPHONE} + KSNODETYPE_MICROPHONE_ARRAY : TGUID = '{DFF21BE5-F70F-11D0-B917-00A0C9223196}'; + {$EXTERNALSYM KSNODETYPE_MICROPHONE_ARRAY} + KSNODETYPE_PROCESSING_MICROPHONE_ARRAY : TGUID = '{DFF21BE6-F70F-11D0-B917-00A0C9223196}'; + {$EXTERNALSYM KSNODETYPE_PROCESSING_MICROPHONE_ARRAY} + KSCATEGORY_MICROPHONE_ARRAY_PROCESSOR : TGUID = '{830a44f2-a32d-476b-be97-42845673b35a}'; + {$EXTERNALSYM KSCATEGORY_MICROPHONE_ARRAY_PROCESSOR} + KSNODETYPE_SPEAKER : TGUID = '{DFF21CE1-F70F-11D0-B917-00A0C9223196}'; + {$EXTERNALSYM KSNODETYPE_SPEAKER} + KSNODETYPE_HEADPHONES : TGUID = '{DFF21CE2-F70F-11D0-B917-00A0C9223196}'; + {$EXTERNALSYM KSNODETYPE_HEADPHONES} + KSNODETYPE_HEAD_MOUNTED_DISPLAY_AUDIO : TGUID = '{DFF21CE3-F70F-11D0-B917-00A0C9223196}'; + {$EXTERNALSYM KSNODETYPE_HEAD_MOUNTED_DISPLAY_AUDIO} + KSNODETYPE_DESKTOP_SPEAKER : TGUID = '{DFF21CE4-F70F-11D0-B917-00A0C9223196}'; + {$EXTERNALSYM KSNODETYPE_DESKTOP_SPEAKER} + KSNODETYPE_ROOM_SPEAKER : TGUID = '{DFF21CE5-F70F-11D0-B917-00A0C9223196}'; + {$EXTERNALSYM KSNODETYPE_ROOM_SPEAKER} + KSNODETYPE_COMMUNICATION_SPEAKER : TGUID = '{DFF21CE6-F70F-11D0-B917-00A0C9223196}'; + {$EXTERNALSYM KSNODETYPE_COMMUNICATION_SPEAKER} + KSNODETYPE_LOW_FREQUENCY_EFFECTS_SPEAKER : TGUID = '{DFF21CE7-F70F-11D0-B917-00A0C9223196}'; + {$EXTERNALSYM KSNODETYPE_LOW_FREQUENCY_EFFECTS_SPEAKER} + KSNODETYPE_HANDSET : TGUID = '{DFF21DE1-F70F-11D0-B917-00A0C9223196}'; + {$EXTERNALSYM KSNODETYPE_HANDSET} + KSNODETYPE_HEADSET : TGUID = '{DFF21DE2-F70F-11D0-B917-00A0C9223196}'; + {$EXTERNALSYM KSNODETYPE_HEADSET} + KSNODETYPE_SPEAKERPHONE_NO_ECHO_REDUCTION : TGUID = '{DFF21DE3-F70F-11D0-B917-00A0C9223196}'; + {$EXTERNALSYM KSNODETYPE_SPEAKERPHONE_NO_ECHO_REDUCTION} + KSNODETYPE_ECHO_SUPPRESSING_SPEAKERPHONE : TGUID = '{DFF21DE4-F70F-11D0-B917-00A0C9223196}'; + {$EXTERNALSYM KSNODETYPE_ECHO_SUPPRESSING_SPEAKERPHONE} + KSNODETYPE_ECHO_CANCELING_SPEAKERPHONE : TGUID = '{DFF21DE5-F70F-11D0-B917-00A0C9223196}'; + {$EXTERNALSYM KSNODETYPE_ECHO_CANCELING_SPEAKERPHONE} + KSNODETYPE_PHONE_LINE : TGUID = '{DFF21EE1-F70F-11D0-B917-00A0C9223196}'; + {$EXTERNALSYM KSNODETYPE_PHONE_LINE} + KSNODETYPE_TELEPHONE : TGUID = '{DFF21EE2-F70F-11D0-B917-00A0C9223196}'; + {$EXTERNALSYM KSNODETYPE_TELEPHONE} + KSNODETYPE_DOWN_LINE_PHONE : TGUID = '{DFF21EE3-F70F-11D0-B917-00A0C9223196}'; + {$EXTERNALSYM KSNODETYPE_DOWN_LINE_PHONE} + KSNODETYPE_ANALOG_CONNECTOR : TGUID = '{DFF21FE1-F70F-11D0-B917-00A0C9223196}'; + {$EXTERNALSYM KSNODETYPE_ANALOG_CONNECTOR} + KSNODETYPE_DIGITAL_AUDIO_INTERFACE : TGUID = '{DFF21FE2-F70F-11D0-B917-00A0C9223196}'; + {$EXTERNALSYM KSNODETYPE_DIGITAL_AUDIO_INTERFACE} + KSNODETYPE_LINE_CONNECTOR : TGUID = '{DFF21FE3-F70F-11D0-B917-00A0C9223196}'; + {$EXTERNALSYM KSNODETYPE_LINE_CONNECTOR} + KSNODETYPE_LEGACY_AUDIO_CONNECTOR : TGUID = '{DFF21FE4-F70F-11D0-B917-00A0C9223196}'; + {$EXTERNALSYM KSNODETYPE_LEGACY_AUDIO_CONNECTOR} + KSNODETYPE_SPDIF_INTERFACE : TGUID = '{DFF21FE5-F70F-11D0-B917-00A0C9223196}'; + {$EXTERNALSYM KSNODETYPE_SPDIF_INTERFACE} + KSNODETYPE_1394_DA_STREAM : TGUID = '{DFF21FE6-F70F-11D0-B917-00A0C9223196}'; + {$EXTERNALSYM KSNODETYPE_1394_DA_STREAM} + KSNODETYPE_1394_DV_STREAM_SOUNDTRACK : TGUID = '{DFF21FE7-F70F-11D0-B917-00A0C9223196}'; + {$EXTERNALSYM KSNODETYPE_1394_DV_STREAM_SOUNDTRACK} + KSNODETYPE_LEVEL_CALIBRATION_NOISE_SOURCE : TGUID = '{DFF220E1-F70F-11D0-B917-00A0C9223196}'; + {$EXTERNALSYM KSNODETYPE_LEVEL_CALIBRATION_NOISE_SOURCE} + KSNODETYPE_EQUALIZATION_NOISE : TGUID = '{DFF220E2-F70F-11D0-B917-00A0C9223196}'; + {$EXTERNALSYM KSNODETYPE_EQUALIZATION_NOISE} + KSNODETYPE_CD_PLAYER : TGUID = '{DFF220E3-F70F-11D0-B917-00A0C9223196}'; + {$EXTERNALSYM KSNODETYPE_CD_PLAYER} + KSNODETYPE_DAT_IO_DIGITAL_AUDIO_TAPE : TGUID = '{DFF220E4-F70F-11D0-B917-00A0C9223196}'; + {$EXTERNALSYM KSNODETYPE_DAT_IO_DIGITAL_AUDIO_TAPE} + KSNODETYPE_DCC_IO_DIGITAL_COMPACT_CASSETTE : TGUID = '{DFF220E5-F70F-11D0-B917-00A0C9223196}'; + {$EXTERNALSYM KSNODETYPE_DCC_IO_DIGITAL_COMPACT_CASSETTE} + KSNODETYPE_MINIDISK : TGUID = '{DFF220E6-F70F-11D0-B917-00A0C9223196}'; + {$EXTERNALSYM KSNODETYPE_MINIDISK} + KSNODETYPE_ANALOG_TAPE : TGUID = '{DFF220E7-F70F-11D0-B917-00A0C9223196}'; + {$EXTERNALSYM KSNODETYPE_ANALOG_TAPE} + KSNODETYPE_PHONOGRAPH : TGUID = '{DFF220E8-F70F-11D0-B917-00A0C9223196}'; + {$EXTERNALSYM KSNODETYPE_PHONOGRAPH} + KSNODETYPE_VCR_AUDIO : TGUID = '{DFF220E9-F70F-11D0-B917-00A0C9223196}'; + {$EXTERNALSYM KSNODETYPE_VCR_AUDIO} + KSNODETYPE_VIDEO_DISC_AUDIO : TGUID = '{DFF220EA-F70F-11D0-B917-00A0C9223196}'; + {$EXTERNALSYM KSNODETYPE_VIDEO_DISC_AUDIO} + KSNODETYPE_DVD_AUDIO : TGUID = '{DFF220EB-F70F-11D0-B917-00A0C9223196}'; + {$EXTERNALSYM KSNODETYPE_DVD_AUDIO} + KSNODETYPE_TV_TUNER_AUDIO : TGUID = '{DFF220EC-F70F-11D0-B917-00A0C9223196}'; + {$EXTERNALSYM KSNODETYPE_TV_TUNER_AUDIO} + KSNODETYPE_SATELLITE_RECEIVER_AUDIO : TGUID = '{DFF220ED-F70F-11D0-B917-00A0C9223196}'; + {$EXTERNALSYM KSNODETYPE_SATELLITE_RECEIVER_AUDIO} + KSNODETYPE_CABLE_TUNER_AUDIO : TGUID = '{DFF220EE-F70F-11D0-B917-00A0C9223196}'; + {$EXTERNALSYM KSNODETYPE_CABLE_TUNER_AUDIO} + KSNODETYPE_DSS_AUDIO : TGUID = '{DFF220EF-F70F-11D0-B917-00A0C9223196}'; + {$EXTERNALSYM KSNODETYPE_DSS_AUDIO} + KSNODETYPE_RADIO_RECEIVER : TGUID = '{DFF220F0-F70F-11D0-B917-00A0C9223196}'; + {$EXTERNALSYM KSNODETYPE_RADIO_RECEIVER} + KSNODETYPE_RADIO_TRANSMITTER : TGUID = '{DFF220F1-F70F-11D0-B917-00A0C9223196}'; + {$EXTERNALSYM KSNODETYPE_RADIO_TRANSMITTER} + KSNODETYPE_MULTITRACK_RECORDER : TGUID = '{DFF220F2-F70F-11D0-B917-00A0C9223196}'; + {$EXTERNALSYM KSNODETYPE_MULTITRACK_RECORDER} + KSNODETYPE_SYNTHESIZER : TGUID = '{DFF220F3-F70F-11D0-B917-00A0C9223196}'; + {$EXTERNALSYM KSNODETYPE_SYNTHESIZER} +// Microsoft's WDMAUD virtual swsynth pin name guid + KSNODETYPE_SWSYNTH : TGUID = '{423274A0-8B81-11D1-A050-0000F8004788}'; + {$EXTERNALSYM KSNODETYPE_SWSYNTH} +// Microsoft's SWMIDI midi pin and node name guid + KSNODETYPE_SWMIDI : TGUID = '{CB9BEFA0-A251-11D1-A050-0000F8004788}'; + {$EXTERNALSYM KSNODETYPE_SWMIDI} + KSNODETYPE_DRM_DESCRAMBLE : TGUID = '{FFBB6E3F-CCFE-4D84-90D9-421418B03A8E}'; + {$EXTERNALSYM KSNODETYPE_DRM_DESCRAMBLE} +// General categories + KSCATEGORY_AUDIO : TGUID = '{6994AD04-93EF-11D0-A3CC-00A0C9223196}'; + {$EXTERNALSYM KSCATEGORY_AUDIO} + KSCATEGORY_VIDEO : TGUID = '{6994AD05-93EF-11D0-A3CC-00A0C9223196}'; + {$EXTERNALSYM KSCATEGORY_VIDEO} + KSCATEGORY_TEXT : TGUID = '{6994AD06-93EF-11D0-A3CC-00A0C9223196}'; + {$EXTERNALSYM KSCATEGORY_TEXT} + KSCATEGORY_NETWORK : TGUID = '{67C9CC3C-69C4-11D2-8759-00A0C9223196}'; + {$EXTERNALSYM KSCATEGORY_NETWORK} + KSCATEGORY_TOPOLOGY : TGUID = '{DDA54A40-1E4C-11D1-A050-405705C10000}'; + {$EXTERNALSYM KSCATEGORY_TOPOLOGY} + KSCATEGORY_VIRTUAL : TGUID = '{3503EAC4-1F26-11D1-8AB0-00A0C9223196}'; + {$EXTERNALSYM KSCATEGORY_VIRTUAL} + KSCATEGORY_ACOUSTIC_ECHO_CANCEL : TGUID = '{BF963D80-C559-11D0-8A2B-00A0C9255AC1}'; + {$EXTERNALSYM KSCATEGORY_ACOUSTIC_ECHO_CANCEL} + KSCATEGORY_SYSAUDIO : TGUID = '{A7C7A5B1-5AF3-11D1-9CED-00A024BF0407}'; + {$EXTERNALSYM KSCATEGORY_SYSAUDIO} + KSCATEGORY_WDMAUD : TGUID = '{3E227E76-690D-11D2-8161-0000F8775BF1}'; + {$EXTERNALSYM KSCATEGORY_WDMAUD} + KSCATEGORY_AUDIO_GFX : TGUID = '{9BAF9572-340C-11D3-ABDC-00A0C90AB16F}'; + {$EXTERNALSYM KSCATEGORY_AUDIO_GFX} + KSCATEGORY_AUDIO_SPLITTER : TGUID = '{9EA331FA-B91B-45F8-9285-BD2BC77AFCDE}'; + {$EXTERNALSYM KSCATEGORY_AUDIO_SPLITTER} + + KSCATEGORY_SYNTHESIZER : TGUID = '{DFF220F3-F70F-11D0-B917-00A0C9223196}'; //KSNODETYPE_SYNTHESIZER + {$EXTERNALSYM KSCATEGORY_SYNTHESIZER} + KSCATEGORY_DRM_DESCRAMBLE : TGUID = '{FFBB6E3F-CCFE-4D84-90D9-421418B03A8E}'; //KSNODETYPE_DRM_DESCRAMBLE + {$EXTERNALSYM KSCATEGORY_DRM_DESCRAMBLE} + + KSCATEGORY_AUDIO_DEVICE : TGUID = '{FBF6F530-07B9-11D2-A71E-0000F8004788}'; + {$EXTERNALSYM KSCATEGORY_AUDIO_DEVICE} + KSCATEGORY_PREFERRED_WAVEOUT_DEVICE : TGUID = '{D6C5066E-72C1-11D2-9755-0000F8004788}'; + {$EXTERNALSYM KSCATEGORY_PREFERRED_WAVEOUT_DEVICE} + KSCATEGORY_PREFERRED_WAVEIN_DEVICE : TGUID = '{D6C50671-72C1-11D2-9755-0000F8004788}'; + {$EXTERNALSYM KSCATEGORY_PREFERRED_WAVEIN_DEVICE} + KSCATEGORY_PREFERRED_MIDIOUT_DEVICE : TGUID = '{D6C50674-72C1-11D2-9755-0000F8004788}'; + {$EXTERNALSYM KSCATEGORY_PREFERRED_MIDIOUT_DEVICE} +// Special pin category for wdmaud + KSCATEGORY_WDMAUD_USE_PIN_NAME : TGUID = '{47A4FA20-A251-11D1-A050-0000F8004788}'; + {$EXTERNALSYM KSCATEGORY_WDMAUD_USE_PIN_NAME} +// Escalante Platform Interface + KSCATEGORY_ESCALANTE_PLATFORM_DRIVER : TGUID = '{74f3aea8-9768-11d1-8e07-00a0c95ec22e}'; + {$EXTERNALSYM KSCATEGORY_ESCALANTE_PLATFORM_DRIVER} +// -- major types --- + +// 'vids' == MEDIATYPE_Video, + KSDATAFORMAT_TYPE_VIDEO : TGUID = '{73646976-0000-0010-8000-00aa00389b71}'; + {$EXTERNALSYM KSDATAFORMAT_TYPE_VIDEO} +// 'auds' == MEDIATYPE_Audio + KSDATAFORMAT_TYPE_AUDIO : TGUID = '{73647561-0000-0010-8000-00aa00389b71}'; + {$EXTERNALSYM KSDATAFORMAT_TYPE_AUDIO} +// 'txts' == MEDIATYPE_Text + KSDATAFORMAT_TYPE_TEXT : TGUID = '{73747874-0000-0010-8000-00aa00389b71}'; + {$EXTERNALSYM KSDATAFORMAT_TYPE_TEXT} + +{#if !defined( DEFINE_WAVEFORMATEX_GUID ) +#define DEFINE_WAVEFORMATEX_GUID(x) (USHORT)(x), 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71 +#endif} + + KSDATAFORMAT_SUBTYPE_WAVEFORMATEX : TGUID = '{00000000-0000-0010-8000-00aa00389b71}'; + {$EXTERNALSYM KSDATAFORMAT_SUBTYPE_WAVEFORMATEX} + +//#define INIT_WAVEFORMATEX_GUID(Guid, x)\ +{\ + *(Guid) = KSDATAFORMAT_SUBTYPE_WAVEFORMATEX;\ + (Guid)->Data1 = (USHORT)(x);\ +} + +{#define EXTRACT_WAVEFORMATEX_ID(Guid)\ + (USHORT)((Guid)->Data1) + +#define IS_VALID_WAVEFORMATEX_GUID(Guid)\ + (!memcmp(((PUSHORT)&KSDATAFORMAT_SUBTYPE_WAVEFORMATEX) + 1, ((PUSHORT)(Guid)) + 1, sizeof(GUID) - sizeof(USHORT))) + +#if !defined(INIT_MMREG_MID)} +//{d5a47fa7-6d98-11d1-a21a-00a0c9223196} +//#define INIT_MMREG_MID(guid, id)\ +{\ + (guid)->Data1 = 0xd5a47fa7 + (USHORT)(id);\ + (guid)->Data2 = 0x6d98;\ + (guid)->Data3 = 0x11d1;\ + (guid)->Data4[0] = 0xa2;\ + (guid)->Data4[1] = 0x1a;\ + (guid)->Data4[2] = 0x00;\ + (guid)->Data4[3] = 0xa0;\ + (guid)->Data4[4] = 0xc9;\ + (guid)->Data4[5] = 0x22;\ + (guid)->Data4[6] = 0x31;\ + (guid)->Data4[7] = 0x96;\ +} +{#define EXTRACT_MMREG_MID(guid)\ + (USHORT)((guid)->Data1 - 0xd5a47fa7) +#define DEFINE_MMREG_MID_GUID(id)\ + 0xd5a47fa7+(USHORT)(id), 0x6d98, 0x11d1, 0xa2, 0x1a, 0x00, 0xa0, 0xc9, 0x22, 0x31, 0x96 + +#define IS_COMPATIBLE_MMREG_MID(guid)\ + (((guid)->Data1 >= 0xd5a47fa7) &&\ + ((guid)->Data1 < 0xd5a47fa7 + 0xffff) &&\ + ((guid)->Data2 == 0x6d98) &&\ + ((guid)->Data3 == 0x11d1) &&\ + ((guid)->Data4[0] == 0xa2) &&\ + ((guid)->Data4[1] == 0x1a) &&\ + ((guid)->Data4[2] == 0x00) &&\ + ((guid)->Data4[3] == 0xa0) &&\ + ((guid)->Data4[4] == 0xc9) &&\ + ((guid)->Data4[5] == 0x22) &&\ + ((guid)->Data4[6] == 0x31) &&\ + ((guid)->Data4[7] == 0x96)) +#endif // !defined(INIT_MMREG_MID) + +#if !defined(INIT_MMREG_PID) +//{e36dc2ac-6d9a-11d1-a21a-00a0c9223196} +//#define INIT_MMREG_PID(guid, id)\ +{\ + (guid)->Data1 = 0xe36dc2ac + (USHORT)(id);\ + (guid)->Data2 = 0x6d9a;\ + (guid)->Data3 = 0x11d1;\ + (guid)->Data4[0] = 0xa2;\ + (guid)->Data4[1] = 0x1a;\ + (guid)->Data4[2] = 0x00;\ + (guid)->Data4[3] = 0xa0;\ + (guid)->Data4[4] = 0xc9;\ + (guid)->Data4[5] = 0x22;\ + (guid)->Data4[6] = 0x31;\ + (guid)->Data4[7] = 0x96;\ +} +{#define EXTRACT_MMREG_PID(guid)\ + (USHORT)((guid)->Data1 - 0xe36dc2ac) +#define DEFINE_MMREG_PID_GUID(id)\ + 0xe36dc2ac+(USHORT)(id), 0x6d9a, 0x11d1, 0xa2, 0x1a, 0x00, 0xa0, 0xc9, 0x22, 0x31, 0x96 + +#define IS_COMPATIBLE_MMREG_PID(guid)\ + (((guid)->Data1 >= 0xe36dc2ac) &&\ + ((guid)->Data1 < 0xe36dc2ac + 0xffff) &&\ + ((guid)->Data2 == 0x6d9a) &&\ + ((guid)->Data3 == 0x11d1) &&\ + ((guid)->Data4[0] == 0xa2) &&\ + ((guid)->Data4[1] == 0x1a) &&\ + ((guid)->Data4[2] == 0x00) &&\ + ((guid)->Data4[3] == 0xa0) &&\ + ((guid)->Data4[4] == 0xc9) &&\ + ((guid)->Data4[5] == 0x22) &&\ + ((guid)->Data4[6] == 0x31) &&\ + ((guid)->Data4[7] == 0x96)) +#endif // !defined(INIT_MMREG_PID)} + + KSDATAFORMAT_SUBTYPE_ANALOG : TGUID = '{6dba3190-67bd-11cf-a0f7-0020afd156e4}'; + {$EXTERNALSYM KSDATAFORMAT_SUBTYPE_ANALOG} + KSDATAFORMAT_SUBTYPE_PCM : TGUID = '{00000001-0000-0010-8000-00aa00389b71}'; + {$EXTERNALSYM KSDATAFORMAT_SUBTYPE_PCM} + KSDATAFORMAT_SUBTYPE_IEEE_FLOAT : TGUID = '{00000003-0000-0010-8000-00aa00389b71}'; + {$EXTERNALSYM KSDATAFORMAT_SUBTYPE_IEEE_FLOAT} + KSDATAFORMAT_SUBTYPE_DRM : TGUID = '{00000009-0000-0010-8000-00aa00389b71}'; + {$EXTERNALSYM KSDATAFORMAT_SUBTYPE_DRM} + KSDATAFORMAT_SUBTYPE_ALAW : TGUID = '{00000006-0000-0010-8000-00aa00389b71}'; + {$EXTERNALSYM KSDATAFORMAT_SUBTYPE_ALAW} + KSDATAFORMAT_SUBTYPE_MULAW : TGUID = '{00000007-0000-0010-8000-00aa00389b71}'; + {$EXTERNALSYM KSDATAFORMAT_SUBTYPE_MULAW} + KSDATAFORMAT_SUBTYPE_ADPCM : TGUID = '{00000002-0000-0010-8000-00aa00389b71}'; + {$EXTERNALSYM KSDATAFORMAT_SUBTYPE_ADPCM} + KSDATAFORMAT_SUBTYPE_MPEG : TGUID = '{00000050-0000-0010-8000-00aa00389b71}'; + {$EXTERNALSYM KSDATAFORMAT_SUBTYPE_MPEG} + KSDATAFORMAT_SPECIFIER_VC_ID : TGUID = '{AD98D184-AAC3-11D0-A41C-00A0C9223196}'; + {$EXTERNALSYM KSDATAFORMAT_SPECIFIER_VC_ID} + KSDATAFORMAT_SPECIFIER_WAVEFORMATEX : TGUID = '{05589f81-c356-11ce-bf01-00aa0055595a}'; + {$EXTERNALSYM KSDATAFORMAT_SPECIFIER_WAVEFORMATEX} + KSDATAFORMAT_SPECIFIER_DSOUND : TGUID = '{518590a2-a184-11d0-8522-00c04fd9baf3}'; + {$EXTERNALSYM KSDATAFORMAT_SPECIFIER_DSOUND} + +type + PKSDataFormatWaveFormatEx = ^TKSDataFormatWaveFormatEx; + KSDATAFORMAT_WAVEFORMATEX = record + DataFormat : TKSDATAFORMAT; + WaveFormatEx : TWAVEFORMATEX; + end; + {$EXTERNALSYM KSDATAFORMAT_WAVEFORMATEX} + PKSDATAFORMAT_WAVEFORMATEX = ^KSDATAFORMAT_WAVEFORMATEX; + {$EXTERNALSYM PKSDATAFORMAT_WAVEFORMATEX} + TKSDataFormatWaveFormatEx = KSDATAFORMAT_WAVEFORMATEX; + + // + // The WAVEFORMATEXTENSIBLE structure defines the format of waveform-audio data for formats having more than two channels. + // This structure is part of the Platform SDK and is not declared in Dsound.h. It is included here for convenience. + // + TWaveFormatExtensibleSamples = record + case byte of + 0: (wValidBitsPerSample : Word); // bits of precision + 1: (wSamplesPerBlock : Word); // valid if wBitsPerSample = 0 + 2: (wReserved : Word); // If neither applies, set to zero. + end; + {$EXTERNALSYM TWaveFormatExtensibleSamples} + + PWaveFormatExtensible = ^TWaveFormatExtensible; + WAVEFORMATEXTENSIBLE = record + Format: TWaveFormatEx; + Samples: TWaveFormatExtensibleSamples; + dwChannelMask : DWORD; // which channels are present in stream + SubFormat : TGUID; + end; + {$EXTERNALSYM WAVEFORMATEXTENSIBLE} + TWaveFormatExtensible = WAVEFORMATEXTENSIBLE; + +const + WAVE_FORMAT_EXTENSIBLE = $FFFE; + {$EXTERNALSYM WAVE_FORMAT_EXTENSIBLE} + +type +// DirectSound buffer description + PKSDSoundBufferDesc = ^TKSDSoundBufferDesc; + KSDSOUND_BUFFERDESC = record + Flags : ULONG; + Control : ULONG; + WaveFormatEx : TWAVEFORMATEX; + end; + {$EXTERNALSYM KSDSOUND_BUFFERDESC} + PKSDSOUND_BUFFERDESC = ^KSDSOUND_BUFFERDESC; + {$EXTERNALSYM PKSDSOUND_BUFFERDESC} + TKSDSoundBufferDesc = KSDSOUND_BUFFERDESC; + +// DirectSound format + PKSDataFormatDSound = ^TKSDataFormatDSound; + KSDATAFORMAT_DSOUND = record + DataFormat :TKSDataFormat; + BufferDesc :TKSDSoundBufferDesc; + end; + {$EXTERNALSYM KSDATAFORMAT_DSOUND} + PKSDATAFORMAT_DSOUND = ^KSDATAFORMAT_DSOUND; + {$EXTERNALSYM PKSDATAFORMAT_DSOUND} + TKSDataFormatDSound = KSDATAFORMAT_DSOUND; + +const +// DirectSound buffer flags + KSDSOUND_BUFFER_PRIMARY = $00000001; + {$EXTERNALSYM KSDSOUND_BUFFER_PRIMARY} + KSDSOUND_BUFFER_STATIC = $00000002; + {$EXTERNALSYM KSDSOUND_BUFFER_STATIC} + KSDSOUND_BUFFER_LOCHARDWARE = $00000004; + {$EXTERNALSYM KSDSOUND_BUFFER_LOCHARDWARE} + KSDSOUND_BUFFER_LOCSOFTWARE = $00000008; + {$EXTERNALSYM KSDSOUND_BUFFER_LOCSOFTWARE} + +// DirectSound buffer control flags + KSDSOUND_BUFFER_CTRL_3D = $00000001; + {$EXTERNALSYM KSDSOUND_BUFFER_CTRL_3D} + KSDSOUND_BUFFER_CTRL_FREQUENCY = $00000002; + {$EXTERNALSYM KSDSOUND_BUFFER_CTRL_FREQUENCY} + KSDSOUND_BUFFER_CTRL_PAN = $00000004; + {$EXTERNALSYM KSDSOUND_BUFFER_CTRL_PAN} + KSDSOUND_BUFFER_CTRL_VOLUME = $00000008; + {$EXTERNALSYM KSDSOUND_BUFFER_CTRL_VOLUME} + KSDSOUND_BUFFER_CTRL_POSITIONNOTIFY = $00000010; + {$EXTERNALSYM KSDSOUND_BUFFER_CTRL_POSITIONNOTIFY} + + KSDSOUND_BUFFER_CTRL_HRTF_3D = $40000000; + {$EXTERNALSYM KSDSOUND_BUFFER_CTRL_HRTF_3D} + +type + PKSAudioPosition = ^TKSAudioPosition; + KSAUDIO_POSITION = record + PlayOffset :int64; + WriteOffset :int64; + end; + {$EXTERNALSYM KSAUDIO_POSITION} + PKSAUDIO_POSITION = ^KSAUDIO_POSITION; + {$EXTERNALSYM PKSAUDIO_POSITION} + TKSAudioPosition = KSAUDIO_POSITION; + +// DirectSound3D FIR context +// PKSDS3DITDParams = ^TKSDS3DITDParams; +// KSDS3D_ITD_PARAMS = record +// Channel : longint; +// VolSmoothScale : single; +// TotalDryAttenuation : single; +// TotalWetAttenuation : single; +// SmoothFrequency : longint; +// Delay : longint; +// end; +// {$EXTERNALSYM KSDS3D_ITD_PARAMS} +// PKSDS3D_ITD_PARAMS = ^KSDS3D_ITD_PARAMS; +// {$EXTERNALSYM PKSDS3D_ITD_PARAMS} +// TKSDS3DITDParams = KSDS3D_ITD_PARAMS; + +// PKSDS3DITDParamsMsg = ^TKSDS3DITDParamsMsg; +// KSDS3D_ITD_PARAMS_MSG = record +// Enabled :ULONG; +// LeftParams :TKSDS3DITDParams; +// RightParams :TKSDS3DITDParams; +// Reserved :ULONG; +// end; +// {$EXTERNALSYM KSDS3D_ITD_PARAMS_MSG} +// PKSDS3D_ITD_PARAMS_MSG = ^KSDS3D_ITD_PARAMS_MSG; +// {$EXTERNALSYM PKSDS3D_ITD_PARAMS_MSG} +// TKSDS3DITDParamsMsg = KSDS3D_ITD_PARAMS_MSG; + +// DirectSound3D HRTF messages + +// PKSDS3DHRTFParamsMsg = ^TKSDS3DHRTFParamsMsg; +// KSDS3D_HRTF_PARAMS_MSG = record +// Size :ULONG; // This is the size of the struct in bytes +// Enabled :ULONG; +// SwapChannels :BOOL; +// ZeroAzimuth :BOOL; +// CrossFadeOutput :BOOL; +// FilterSize :ULONG; // This is the additional size of the filter coeff in bytes +// end; +// {$EXTERNALSYM KSDS3D_HRTF_PARAMS_MSG} +// PKSDS3D_HRTF_PARAMS_MSG = ^KSDS3D_HRTF_PARAMS_MSG; +// {$EXTERNALSYM PKSDS3D_HRTF_PARAMS_MSG} +// TKSDS3DHRTFParamsMsg = KSDS3D_HRTF_PARAMS_MSG; + +// HRTF filter quality levels +// KSDS3D_HRTF_FILTER_QUALITY = ( +// FULL_FILTER, +// LIGHT_FILTER, +// KSDS3D_FILTER_QUALITY_COUNT +// ); +// {$EXTERNALSYM KSDS3D_HRTF_FILTER_QUALITY} +// TKSDS3DHRTFFilterQuality = KSDS3D_HRTF_FILTER_QUALITY; + +// PKSDS3DHRTFInitMsg = ^TKSDS3DHRTFInitMsg; +// KSDS3D_HRTF_INIT_MSG = record +// Size : ULONG; // This is the size of the struct in bytes +// Quality : TKSDS3DHRTFFilterQuality; +// SampleRate : single; +// MaxFilterSize : ULONG; +// FilterTransientMuteLength : ULONG; +// FilterOverlapBufferLength : ULONG; +// OutputOverlapBufferLength : ULONG; +// Reserved : ULONG; +// end; +// {$EXTERNALSYM KSDS3D_HRTF_INIT_MSG} +// PKSDS3D_HRTF_INIT_MSG = ^KSDS3D_HRTF_INIT_MSG; +// {$EXTERNALSYM PKSDS3D_HRTF_INIT_MSG} +// TKSDS3DHRTFInitMsg = KSDS3D_HRTF_INIT_MSG; + +// Coefficient formats +// KSDS3D_HRTF_COEFF_FORMAT = ( +// FLOAT_COEFF, +// SHORT_COEFF, +// KSDS3D_COEFF_COUNT +// ); +// {$EXTERNALSYM KSDS3D_HRTF_COEFF_FORMAT} +// TKSDS3DHRTFCoeffFormat = KSDS3D_HRTF_COEFF_FORMAT; + +//// Filter methods +// KSDS3D_HRTF_FILTER_METHOD = ( +// DIRECT_FORM, +// CASCADE_FORM, +// KSDS3D_FILTER_METHOD_COUNT +// ); +// {$EXTERNALSYM KSDS3D_HRTF_FILTER_METHOD} +// TKSDS3DHRTFFilterMethod = KSDS3D_HRTF_FILTER_METHOD; + +// Filter methods +// KSDS3D_HRTF_FILTER_VERSION = ( +// DS3D_HRTF_VERSION_1 +// ); +// {$EXTERNALSYM KSDS3D_HRTF_FILTER_VERSION} +// TKSDS3DHRTFFilterVersion = KSDS3D_HRTF_FILTER_VERSION; + +// PKSDS3DHRTFFilterFormatMsg = ^TKSDS3DHRTFFilterFormatMsg; +// KSDS3D_HRTF_FILTER_FORMAT_MSG = record +// FilterMethod : TKSDS3DHRTFFilterMethod; +// CoeffFormat : TKSDS3DHRTFCoeffFormat; +// Version : TKSDS3DHRTFFilterVersion; +// Reserved : ULONG; +// end; +// {$EXTERNALSYM KSDS3D_HRTF_FILTER_FORMAT_MSG} +// PKSDS3D_HRTF_FILTER_FORMAT_MSG = ^KSDS3D_HRTF_FILTER_FORMAT_MSG; +// {$EXTERNALSYM PKSDS3D_HRTF_FILTER_FORMAT_MSG} +// TKSDS3DHRTFFilterFormatMsg = KSDS3D_HRTF_FILTER_FORMAT_MSG; + +//=========================================================================== +// DirectSound3D HAL + + + _DS3DVECTOR = record + case integer of + 0: ( + x : single; + y : single; + z : single); + 1: ( + dvX : single; + dvY : single; + dvZ : single); + end; + {$EXTERNALSYM _DS3DVECTOR} + DS3DVECTOR = _DS3DVECTOR; + {$EXTERNALSYM DS3DVECTOR} + PDS3DVECTOR = ^DS3DVECTOR; + {$EXTERNALSYM PDS3DVECTOR} + TDS3DVector = DS3DVECTOR; + +//=========================================================================== +//=========================================================================== + +// KSPROPSETID_DirectSound3DListener : {437B3414-D060-11d0-8583-00C04FD9BAF3} +const + KSPROPSETID_DirectSound3DListener : TGUID = '{437b3414-d060-11d0-8583-00c04fd9baf3}'; + {$EXTERNALSYM KSPROPSETID_DirectSound3DListener} + +type + KSPROPERTY_DIRECTSOUND3DLISTENER = ( + KSPROPERTY_DIRECTSOUND3DLISTENER_ALL, + KSPROPERTY_DIRECTSOUND3DLISTENER_POSITION, + KSPROPERTY_DIRECTSOUND3DLISTENER_VELOCITY, + KSPROPERTY_DIRECTSOUND3DLISTENER_ORIENTATION, + KSPROPERTY_DIRECTSOUND3DLISTENER_DISTANCEFACTOR, + KSPROPERTY_DIRECTSOUND3DLISTENER_ROLLOFFFACTOR, + KSPROPERTY_DIRECTSOUND3DLISTENER_DOPPLERFACTOR, + KSPROPERTY_DIRECTSOUND3DLISTENER_BATCH, + KSPROPERTY_DIRECTSOUND3DLISTENER_ALLOCATION + ); + {$EXTERNALSYM KSPROPERTY_DIRECTSOUND3DLISTENER} + TKSPropertyDirectSound3DListener = KSPROPERTY_DIRECTSOUND3DLISTENER; + + PKSDS3DListenerAll = ^TKSDS3DListenerAll; + KSDS3D_LISTENER_ALL = record + Position : TDS3DVECTOR; + Velocity : TDS3DVECTOR; + OrientFront : TDS3DVECTOR; + OrientTop : TDS3DVECTOR; + DistanceFactor : single; + RolloffFactor : single; + DopplerFactor : single; + end; + {$EXTERNALSYM KSDS3D_LISTENER_ALL} + PKSDS3D_LISTENER_ALL = ^KSDS3D_LISTENER_ALL; + {$EXTERNALSYM PKSDS3D_LISTENER_ALL} + TKSDS3DListenerAll = KSDS3D_LISTENER_ALL; + + + KSDS3D_LISTENER_ORIENTATION = record + Front : TDS3DVECTOR; + Top : TDS3DVECTOR; + end; + {$EXTERNALSYM KSDS3D_LISTENER_ORIENTATION} + PKSDS3D_LISTENER_ORIENTATION = ^KSDS3D_LISTENER_ORIENTATION; + {$EXTERNALSYM PKSDS3D_LISTENER_ORIENTATION} + TKSDS3DListenerOrientation = KSDS3D_LISTENER_ORIENTATION; + +//=========================================================================== +//=========================================================================== +// KSPROPSETID_DirectSound3DBuffer : {437B3411-D060-11d0-8583-00C04FD9BAF3} +const + KSPROPSETID_DirectSound3DBuffer : TGUID = '{437B3411-D060-11d0-8583-00C04FD9BAF3}'; + {$EXTERNALSYM KSPROPSETID_DirectSound3DBuffer} + +type + KSPROPERTY_DIRECTSOUND3DBUFFER = ( + KSPROPERTY_DIRECTSOUND3DBUFFER_ALL, + KSPROPERTY_DIRECTSOUND3DBUFFER_POSITION, + KSPROPERTY_DIRECTSOUND3DBUFFER_VELOCITY, + KSPROPERTY_DIRECTSOUND3DBUFFER_CONEANGLES, + KSPROPERTY_DIRECTSOUND3DBUFFER_CONEORIENTATION, + KSPROPERTY_DIRECTSOUND3DBUFFER_CONEOUTSIDEVOLUME, + KSPROPERTY_DIRECTSOUND3DBUFFER_MINDISTANCE, + KSPROPERTY_DIRECTSOUND3DBUFFER_MAXDISTANCE, + KSPROPERTY_DIRECTSOUND3DBUFFER_MODE + ); + {$EXTERNALSYM KSPROPERTY_DIRECTSOUND3DBUFFER} + TKSPropertyDirectSound3DBuffer = KSPROPERTY_DIRECTSOUND3DBUFFER; + + KSDS3D_BUFFER_ALL = record + Position : TDS3DVECTOR; + Velocity : TDS3DVECTOR; + InsideConeAngle : ULONG; + OutsideConeAngle : ULONG; + ConeOrientation : TDS3DVECTOR; + ConeOutsideVolume : longint; + MinDistance : single; + MaxDistance : single; + Mode : ULONG; + end; + {$EXTERNALSYM KSDS3D_BUFFER_ALL} + PKSDS3D_BUFFER_ALL = ^KSDS3D_BUFFER_ALL; + {$EXTERNALSYM PKSDS3D_BUFFER_ALL} + TKSDS3DBufferAll = KSDS3D_BUFFER_ALL; + + KSDS3D_BUFFER_CONE_ANGLES = record + InsideConeAngle : ULONG; + OutsideConeAngle : ULONG; + end; + {$EXTERNALSYM KSDS3D_BUFFER_CONE_ANGLES} + PKSDS3D_BUFFER_CONE_ANGLES = ^KSDS3D_BUFFER_CONE_ANGLES; + {$EXTERNALSYM PKSDS3D_BUFFER_CONE_ANGLES} + TKSDS3DBufferConeAngles = KSDS3D_BUFFER_CONE_ANGLES; + +const + KSAUDIO_STEREO_SPEAKER_GEOMETRY_HEADPHONE = -1; + {$EXTERNALSYM KSAUDIO_STEREO_SPEAKER_GEOMETRY_HEADPHONE} + KSAUDIO_STEREO_SPEAKER_GEOMETRY_MIN = 5; + {$EXTERNALSYM KSAUDIO_STEREO_SPEAKER_GEOMETRY_MIN} + KSAUDIO_STEREO_SPEAKER_GEOMETRY_NARROW = 10; + {$EXTERNALSYM KSAUDIO_STEREO_SPEAKER_GEOMETRY_NARROW} + KSAUDIO_STEREO_SPEAKER_GEOMETRY_WIDE = 20; + {$EXTERNALSYM KSAUDIO_STEREO_SPEAKER_GEOMETRY_WIDE} + KSAUDIO_STEREO_SPEAKER_GEOMETRY_MAX = 180; + {$EXTERNALSYM KSAUDIO_STEREO_SPEAKER_GEOMETRY_MAX} + + KSDSOUND_3D_MODE_NORMAL = $00000000; + {$EXTERNALSYM KSDSOUND_3D_MODE_NORMAL} + KSDSOUND_3D_MODE_HEADRELATIVE = $00000001; + {$EXTERNALSYM KSDSOUND_3D_MODE_HEADRELATIVE} + KSDSOUND_3D_MODE_DISABLE = $00000002; + {$EXTERNALSYM KSDSOUND_3D_MODE_DISABLE} + +type + KSDATARANGE_AUDIO = record + DataRange : TKSDataRange; + MaximumChannels : ULONG; + MinimumBitsPerSample : ULONG; + MaximumBitsPerSample : ULONG; + MinimumSampleFrequency : ULONG; + MaximumSampleFrequency : ULONG; + end; + {$EXTERNALSYM KSDATARANGE_AUDIO} + PKSDATARANGE_AUDIO = ^KSDATARANGE_AUDIO; + {$EXTERNALSYM PKSDATARANGE_AUDIO} + TKSDataRangeAudio = KSDATARANGE_AUDIO; + +//--------------------------------------------------------------------------- +const + KSDATAFORMAT_SUBTYPE_RIFF : TGUID = '{4995DAEE-9EE6-11D0-A40E-00A0C9223196}'; + {$EXTERNALSYM KSDATAFORMAT_SUBTYPE_RIFF} + KSDATAFORMAT_SUBTYPE_RIFFWAVE : TGUID = '{e436eb8b-524f-11ce-9f53-0020af0ba770}'; + {$EXTERNALSYM KSDATAFORMAT_SUBTYPE_RIFFWAVE} + +//=========================================================================== +//=========================================================================== + + KSPROPSETID_Bibliographic : TGUID = '{07BA150E-E2B1-11D0-AC17-00A0C9223196}'; + {$EXTERNALSYM KSPROPSETID_Bibliographic} + +//Repeatable tags contain all entries within the property, each preceeded by length +type + KSPROPERTY_BIBLIOGRAPHIC = {$IFDEF TYPE_IDENTITY}type {$ENDIF} LongWord; + {$EXTERNALSYM KSPROPERTY_BIBLIOGRAPHIC} + const + KSPROPERTY_BIBLIOGRAPHIC_LEADER = 'RDL '; + {$EXTERNALSYM KSPROPERTY_BIBLIOGRAPHIC_LEADER} + KSPROPERTY_BIBLIOGRAPHIC_LCCN = '010 '; + {$EXTERNALSYM KSPROPERTY_BIBLIOGRAPHIC_LCCN} + KSPROPERTY_BIBLIOGRAPHIC_ISBN = '020 '; + {$EXTERNALSYM KSPROPERTY_BIBLIOGRAPHIC_ISBN} + KSPROPERTY_BIBLIOGRAPHIC_ISSN = '220 '; + {$EXTERNALSYM KSPROPERTY_BIBLIOGRAPHIC_ISSN} + KSPROPERTY_BIBLIOGRAPHIC_CATALOGINGSOURCE = '040 '; + {$EXTERNALSYM KSPROPERTY_BIBLIOGRAPHIC_CATALOGINGSOURCE} + KSPROPERTY_BIBLIOGRAPHIC_MAINPERSONALNAME = '001 '; + {$EXTERNALSYM KSPROPERTY_BIBLIOGRAPHIC_MAINPERSONALNAME} + KSPROPERTY_BIBLIOGRAPHIC_MAINCORPORATEBODY = '011 '; + {$EXTERNALSYM KSPROPERTY_BIBLIOGRAPHIC_MAINCORPORATEBODY} + KSPROPERTY_BIBLIOGRAPHIC_MAINMEETINGNAME = '111 '; + {$EXTERNALSYM KSPROPERTY_BIBLIOGRAPHIC_MAINMEETINGNAME} + KSPROPERTY_BIBLIOGRAPHIC_MAINUNIFORMTITLE = '031 '; + {$EXTERNALSYM KSPROPERTY_BIBLIOGRAPHIC_MAINUNIFORMTITLE} + KSPROPERTY_BIBLIOGRAPHIC_UNIFORMTITLE = '042 '; + {$EXTERNALSYM KSPROPERTY_BIBLIOGRAPHIC_UNIFORMTITLE} + KSPROPERTY_BIBLIOGRAPHIC_TITLESTATEMENT = '542 '; + {$EXTERNALSYM KSPROPERTY_BIBLIOGRAPHIC_TITLESTATEMENT} + KSPROPERTY_BIBLIOGRAPHIC_VARYINGFORMTITLE = '642 '; + {$EXTERNALSYM KSPROPERTY_BIBLIOGRAPHIC_VARYINGFORMTITLE} + KSPROPERTY_BIBLIOGRAPHIC_PUBLICATION = '062 '; + {$EXTERNALSYM KSPROPERTY_BIBLIOGRAPHIC_PUBLICATION} + KSPROPERTY_BIBLIOGRAPHIC_PHYSICALDESCRIPTION = '003 '; + {$EXTERNALSYM KSPROPERTY_BIBLIOGRAPHIC_PHYSICALDESCRIPTION} + KSPROPERTY_BIBLIOGRAPHIC_ADDEDENTRYTITLE = '044 '; + {$EXTERNALSYM KSPROPERTY_BIBLIOGRAPHIC_ADDEDENTRYTITLE} + KSPROPERTY_BIBLIOGRAPHIC_SERIESSTATEMENT = '094 '; + {$EXTERNALSYM KSPROPERTY_BIBLIOGRAPHIC_SERIESSTATEMENT} + KSPROPERTY_BIBLIOGRAPHIC_GENERALNOTE = '005 '; + {$EXTERNALSYM KSPROPERTY_BIBLIOGRAPHIC_GENERALNOTE} + KSPROPERTY_BIBLIOGRAPHIC_BIBLIOGRAPHYNOTE = '405 '; + {$EXTERNALSYM KSPROPERTY_BIBLIOGRAPHIC_BIBLIOGRAPHYNOTE} + KSPROPERTY_BIBLIOGRAPHIC_CONTENTSNOTE = '505 '; + {$EXTERNALSYM KSPROPERTY_BIBLIOGRAPHIC_CONTENTSNOTE} + KSPROPERTY_BIBLIOGRAPHIC_CREATIONCREDIT = '805 '; + {$EXTERNALSYM KSPROPERTY_BIBLIOGRAPHIC_CREATIONCREDIT} + KSPROPERTY_BIBLIOGRAPHIC_CITATION = '015 '; + {$EXTERNALSYM KSPROPERTY_BIBLIOGRAPHIC_CITATION} + KSPROPERTY_BIBLIOGRAPHIC_PARTICIPANT = '115 '; + {$EXTERNALSYM KSPROPERTY_BIBLIOGRAPHIC_PARTICIPANT} + KSPROPERTY_BIBLIOGRAPHIC_SUMMARY = '025 '; + {$EXTERNALSYM KSPROPERTY_BIBLIOGRAPHIC_SUMMARY} + KSPROPERTY_BIBLIOGRAPHIC_TARGETAUDIENCE = '125 '; + {$EXTERNALSYM KSPROPERTY_BIBLIOGRAPHIC_TARGETAUDIENCE} + KSPROPERTY_BIBLIOGRAPHIC_ADDEDFORMAVAILABLE = '035 '; + {$EXTERNALSYM KSPROPERTY_BIBLIOGRAPHIC_ADDEDFORMAVAILABLE} + KSPROPERTY_BIBLIOGRAPHIC_SYSTEMDETAILS = '835 '; + {$EXTERNALSYM KSPROPERTY_BIBLIOGRAPHIC_SYSTEMDETAILS} + KSPROPERTY_BIBLIOGRAPHIC_AWARDS = '685 '; + {$EXTERNALSYM KSPROPERTY_BIBLIOGRAPHIC_AWARDS} + KSPROPERTY_BIBLIOGRAPHIC_ADDEDENTRYPERSONALNAME = '006 '; + {$EXTERNALSYM KSPROPERTY_BIBLIOGRAPHIC_ADDEDENTRYPERSONALNAME} + KSPROPERTY_BIBLIOGRAPHIC_ADDEDENTRYTOPICALTERM = '056 '; + {$EXTERNALSYM KSPROPERTY_BIBLIOGRAPHIC_ADDEDENTRYTOPICALTERM} + KSPROPERTY_BIBLIOGRAPHIC_ADDEDENTRYGEOGRAPHIC = '156 '; + {$EXTERNALSYM KSPROPERTY_BIBLIOGRAPHIC_ADDEDENTRYGEOGRAPHIC} + KSPROPERTY_BIBLIOGRAPHIC_INDEXTERMGENRE = '556 '; + {$EXTERNALSYM KSPROPERTY_BIBLIOGRAPHIC_INDEXTERMGENRE} + KSPROPERTY_BIBLIOGRAPHIC_INDEXTERMCURRICULUM = '856 '; + {$EXTERNALSYM KSPROPERTY_BIBLIOGRAPHIC_INDEXTERMCURRICULUM} + KSPROPERTY_BIBLIOGRAPHIC_ADDEDENTRYUNIFORMTITLE = '037 '; + {$EXTERNALSYM KSPROPERTY_BIBLIOGRAPHIC_ADDEDENTRYUNIFORMTITLE} + KSPROPERTY_BIBLIOGRAPHIC_ADDEDENTRYRELATED = '047 '; + {$EXTERNALSYM KSPROPERTY_BIBLIOGRAPHIC_ADDEDENTRYRELATED} + KSPROPERTY_BIBLIOGRAPHIC_SERIESSTATEMENTPERSONALNAME = '008 '; + {$EXTERNALSYM KSPROPERTY_BIBLIOGRAPHIC_SERIESSTATEMENTPERSONALNAME} + KSPROPERTY_BIBLIOGRAPHIC_SERIESSTATEMENTUNIFORMTITLE = '038 '; + {$EXTERNALSYM KSPROPERTY_BIBLIOGRAPHIC_SERIESSTATEMENTUNIFORMTITLE} + + KSPROPSETID_TopologyNode : TGUID = '{45FFAAA1-6E1B-11D0-BCF2-444553540000}'; + {$EXTERNALSYM KSPROPSETID_TopologyNode} + +type + KSPROPERTY_TOPOLOGYNODE = ( + {$IFNDEF COMPILER6_UP} + KSPROPERTY_TOPOLOGYNODE_INVALID_0, + KSPROPERTY_TOPOLOGYNODE_ENABLE, + KSPROPERTY_TOPOLOGYNODE_RESET + {$ELSE} + KSPROPERTY_TOPOLOGYNODE_ENABLE = 1, + KSPROPERTY_TOPOLOGYNODE_RESET = 2 + {$ENDIF} + ); + {$EXTERNALSYM KSPROPERTY_TOPOLOGYNODE} + TKSPropertyTopologyNode = KSPROPERTY_TOPOLOGYNODE; + +//=========================================================================== +const + KSPROPSETID_DrmAudioStream : TGUID = '{2F2C8DDD-4198-4fac-BA29-61BB05B7DE06}'; + {$EXTERNALSYM KSPROPSETID_DrmAudioStream} + +type + KSPROPERTY_DRMAUDIOSTREAM = ( + KSPROPERTY_DRMAUDIOSTREAM_CONTENTID, + KSPROPERTY_DRMAUDIOSTREAM_AUTHENTICATEFUNCTION + ); + {$EXTERNALSYM KSPROPERTY_DRMAUDIOSTREAM} + TKSPRopertyDRMAudioStream = KSPROPERTY_DRMAUDIOSTREAM; + +//=========================================================================== +const + KSPROPSETID_Audio : TGUID = '{45FFAAA0-6E1B-11D0-BCF2-444553540000}'; + {$EXTERNALSYM KSPROPSETID_Audio} + +type + KSPROPERTY_AUDIO = ( + {$IFNDEF COMPILER6_UP} + KSPROPERTY_AUDIO_INVALID_0, + KSPROPERTY_AUDIO_LATENCY, + {$ELSE} + KSPROPERTY_AUDIO_LATENCY = 1, + {$ENDIF} + KSPROPERTY_AUDIO_COPY_PROTECTION, + KSPROPERTY_AUDIO_CHANNEL_CONFIG, + KSPROPERTY_AUDIO_VOLUMELEVEL, + KSPROPERTY_AUDIO_POSITION, + KSPROPERTY_AUDIO_DYNAMIC_RANGE, + KSPROPERTY_AUDIO_QUALITY, + KSPROPERTY_AUDIO_SAMPLING_RATE, + KSPROPERTY_AUDIO_DYNAMIC_SAMPLING_RATE, + KSPROPERTY_AUDIO_MIX_LEVEL_TABLE, + KSPROPERTY_AUDIO_MIX_LEVEL_CAPS, + KSPROPERTY_AUDIO_MUX_SOURCE, + KSPROPERTY_AUDIO_MUTE, + KSPROPERTY_AUDIO_BASS, + KSPROPERTY_AUDIO_MID, + KSPROPERTY_AUDIO_TREBLE, + KSPROPERTY_AUDIO_BASS_BOOST, + KSPROPERTY_AUDIO_EQ_LEVEL, + KSPROPERTY_AUDIO_NUM_EQ_BANDS, + KSPROPERTY_AUDIO_EQ_BANDS, + KSPROPERTY_AUDIO_AGC, + KSPROPERTY_AUDIO_DELAY, + KSPROPERTY_AUDIO_LOUDNESS, + KSPROPERTY_AUDIO_WIDE_MODE, + KSPROPERTY_AUDIO_WIDENESS, + KSPROPERTY_AUDIO_REVERB_LEVEL, + KSPROPERTY_AUDIO_CHORUS_LEVEL, + KSPROPERTY_AUDIO_DEV_SPECIFIC, + KSPROPERTY_AUDIO_DEMUX_DEST, + KSPROPERTY_AUDIO_STEREO_ENHANCE, + KSPROPERTY_AUDIO_MANUFACTURE_GUID, + KSPROPERTY_AUDIO_PRODUCT_GUID, + KSPROPERTY_AUDIO_CPU_RESOURCES, + KSPROPERTY_AUDIO_STEREO_SPEAKER_GEOMETRY, + KSPROPERTY_AUDIO_SURROUND_ENCODE, + KSPROPERTY_AUDIO_3D_INTERFACE, + KSPROPERTY_AUDIO_PEAKMETER, + KSPROPERTY_AUDIO_ALGORITHM_INSTANCE + ); + {$EXTERNALSYM KSPROPERTY_AUDIO} + TKSPropertyAudio = KSPROPERTY_AUDIO; + +// Audio quality constants +const + KSAUDIO_QUALITY_WORST = $0; + {$EXTERNALSYM KSAUDIO_QUALITY_WORST} + KSAUDIO_QUALITY_PC = $1; + {$EXTERNALSYM KSAUDIO_QUALITY_PC} + KSAUDIO_QUALITY_BASIC = $2; + {$EXTERNALSYM KSAUDIO_QUALITY_BASIC} + KSAUDIO_QUALITY_ADVANCED = $3; + {$EXTERNALSYM KSAUDIO_QUALITY_ADVANCED} + +// Audio CPU resource constants + KSAUDIO_CPU_RESOURCES_NOT_HOST_CPU = $00000000; + {$EXTERNALSYM KSAUDIO_CPU_RESOURCES_NOT_HOST_CPU} + KSAUDIO_CPU_RESOURCES_HOST_CPU = $7FFFFFFF; + {$EXTERNALSYM KSAUDIO_CPU_RESOURCES_HOST_CPU} + +type + PKSAudioCopyProtection = ^TKSAudioCopyProtection; + KSAUDIO_COPY_PROTECTION = record + fCopyrighted : BOOL; + fOriginal : BOOL; + end; + {$EXTERNALSYM KSAUDIO_COPY_PROTECTION} + PKSAUDIO_COPY_PROTECTION = ^KSAUDIO_COPY_PROTECTION; + {$EXTERNALSYM PKSAUDIO_COPY_PROTECTION} + TKSAudioCopyProtection = KSAUDIO_COPY_PROTECTION; + + PKSAudioChannelConfig = ^TKSAudioChannelConfig; + KSAUDIO_CHANNEL_CONFIG = record + ActiveSpeakerPositions : Longint; + end; + {$EXTERNALSYM KSAUDIO_CHANNEL_CONFIG} + PKSAUDIO_CHANNEL_CONFIG = ^KSAUDIO_CHANNEL_CONFIG; + {$EXTERNALSYM PKSAUDIO_CHANNEL_CONFIG} + TKSAudioChannelConfig = KSAUDIO_CHANNEL_CONFIG; + +// Speaker Positions: +const + SPEAKER_FRONT_LEFT = $1; + {$EXTERNALSYM SPEAKER_FRONT_LEFT} + SPEAKER_FRONT_RIGHT = $2; + {$EXTERNALSYM SPEAKER_FRONT_RIGHT} + SPEAKER_FRONT_CENTER = $4; + {$EXTERNALSYM SPEAKER_FRONT_CENTER} + SPEAKER_LOW_FREQUENCY = $8; + {$EXTERNALSYM SPEAKER_LOW_FREQUENCY} + SPEAKER_BACK_LEFT = $10; + {$EXTERNALSYM SPEAKER_BACK_LEFT} + SPEAKER_BACK_RIGHT = $20; + {$EXTERNALSYM SPEAKER_BACK_RIGHT} + SPEAKER_FRONT_LEFT_OF_CENTER = $40; + {$EXTERNALSYM SPEAKER_FRONT_LEFT_OF_CENTER} + SPEAKER_FRONT_RIGHT_OF_CENTER = $80; + {$EXTERNALSYM SPEAKER_FRONT_RIGHT_OF_CENTER} + SPEAKER_BACK_CENTER = $100; + {$EXTERNALSYM SPEAKER_BACK_CENTER} + SPEAKER_SIDE_LEFT = $200; + {$EXTERNALSYM SPEAKER_SIDE_LEFT} + SPEAKER_SIDE_RIGHT = $400; + {$EXTERNALSYM SPEAKER_SIDE_RIGHT} + SPEAKER_TOP_CENTER = $800; + {$EXTERNALSYM SPEAKER_TOP_CENTER} + SPEAKER_TOP_FRONT_LEFT = $1000; + {$EXTERNALSYM SPEAKER_TOP_FRONT_LEFT} + SPEAKER_TOP_FRONT_CENTER = $2000; + {$EXTERNALSYM SPEAKER_TOP_FRONT_CENTER} + SPEAKER_TOP_FRONT_RIGHT = $4000; + {$EXTERNALSYM SPEAKER_TOP_FRONT_RIGHT} + SPEAKER_TOP_BACK_LEFT = $8000; + {$EXTERNALSYM SPEAKER_TOP_BACK_LEFT} + SPEAKER_TOP_BACK_CENTER = $10000; + {$EXTERNALSYM SPEAKER_TOP_BACK_CENTER} + SPEAKER_TOP_BACK_RIGHT = $20000; + {$EXTERNALSYM SPEAKER_TOP_BACK_RIGHT} + +// Bit mask locations reserved for future use + SPEAKER_RESERVED = $7FFC0000; + {$EXTERNALSYM SPEAKER_RESERVED} + +// Used to specify that any possible permutation of speaker configurations + SPEAKER_ALL = $80000000; + {$EXTERNALSYM SPEAKER_ALL} + +// DirectSound Speaker Config + KSAUDIO_SPEAKER_MONO = (SPEAKER_FRONT_CENTER); + {$EXTERNALSYM KSAUDIO_SPEAKER_MONO} + KSAUDIO_SPEAKER_STEREO = (SPEAKER_FRONT_LEFT or SPEAKER_FRONT_RIGHT); + {$EXTERNALSYM KSAUDIO_SPEAKER_STEREO} + KSAUDIO_SPEAKER_QUAD = (SPEAKER_FRONT_LEFT or SPEAKER_FRONT_RIGHT or + SPEAKER_BACK_LEFT or SPEAKER_BACK_RIGHT); + {$EXTERNALSYM KSAUDIO_SPEAKER_QUAD} + KSAUDIO_SPEAKER_SURROUND = (SPEAKER_FRONT_LEFT or SPEAKER_FRONT_RIGHT or + SPEAKER_FRONT_CENTER or SPEAKER_BACK_CENTER); + {$EXTERNALSYM KSAUDIO_SPEAKER_SURROUND} + KSAUDIO_SPEAKER_5POINT1 = (SPEAKER_FRONT_LEFT or SPEAKER_FRONT_RIGHT or + SPEAKER_FRONT_CENTER or SPEAKER_LOW_FREQUENCY or + SPEAKER_BACK_LEFT or SPEAKER_BACK_RIGHT); + {$EXTERNALSYM KSAUDIO_SPEAKER_5POINT1} + KSAUDIO_SPEAKER_7POINT1 = (SPEAKER_FRONT_LEFT or SPEAKER_FRONT_RIGHT or + SPEAKER_FRONT_CENTER or SPEAKER_LOW_FREQUENCY or + SPEAKER_BACK_LEFT or SPEAKER_BACK_RIGHT or + SPEAKER_FRONT_LEFT_OF_CENTER or SPEAKER_FRONT_RIGHT_OF_CENTER); + {$EXTERNALSYM KSAUDIO_SPEAKER_7POINT1} + KSAUDIO_SPEAKER_5POINT1_SURROUND = (SPEAKER_FRONT_LEFT or SPEAKER_FRONT_RIGHT or + SPEAKER_FRONT_CENTER or SPEAKER_LOW_FREQUENCY or + SPEAKER_SIDE_LEFT or SPEAKER_SIDE_RIGHT); + {$EXTERNALSYM KSAUDIO_SPEAKER_5POINT1_SURROUND} + KSAUDIO_SPEAKER_7POINT1_SURROUND = (SPEAKER_FRONT_LEFT or SPEAKER_FRONT_RIGHT or + SPEAKER_FRONT_CENTER or SPEAKER_LOW_FREQUENCY or + SPEAKER_BACK_LEFT or SPEAKER_BACK_RIGHT or + SPEAKER_SIDE_LEFT or SPEAKER_SIDE_RIGHT); + {$EXTERNALSYM KSAUDIO_SPEAKER_7POINT1_SURROUND} +// The following are obsolete 5.1 and 7.1 settings (they lack side speakers). Note this means +// that the default 5.1 and 7.1 settings (KSAUDIO_SPEAKER_5POINT1 and KSAUDIO_SPEAKER_7POINT1 are +// similarly obsolete but are unchanged for compatibility reasons). + KSAUDIO_SPEAKER_5POINT1_BACK = KSAUDIO_SPEAKER_5POINT1; + {$EXTERNALSYM KSAUDIO_SPEAKER_5POINT1_BACK} + KSAUDIO_SPEAKER_7POINT1_WIDE = KSAUDIO_SPEAKER_7POINT1; + {$EXTERNALSYM KSAUDIO_SPEAKER_7POINT1_WIDE} + + +// DVD Speaker Positions + KSAUDIO_SPEAKER_GROUND_FRONT_LEFT = SPEAKER_FRONT_LEFT; + {$EXTERNALSYM KSAUDIO_SPEAKER_GROUND_FRONT_LEFT} + KSAUDIO_SPEAKER_GROUND_FRONT_CENTER = SPEAKER_FRONT_CENTER; + {$EXTERNALSYM KSAUDIO_SPEAKER_GROUND_FRONT_CENTER} + KSAUDIO_SPEAKER_GROUND_FRONT_RIGHT = SPEAKER_FRONT_RIGHT; + {$EXTERNALSYM KSAUDIO_SPEAKER_GROUND_FRONT_RIGHT} + KSAUDIO_SPEAKER_GROUND_REAR_LEFT = SPEAKER_BACK_LEFT; + {$EXTERNALSYM KSAUDIO_SPEAKER_GROUND_REAR_LEFT} + KSAUDIO_SPEAKER_GROUND_REAR_RIGHT = SPEAKER_BACK_RIGHT; + {$EXTERNALSYM KSAUDIO_SPEAKER_GROUND_REAR_RIGHT} + KSAUDIO_SPEAKER_TOP_MIDDLE = SPEAKER_TOP_CENTER; + {$EXTERNALSYM KSAUDIO_SPEAKER_TOP_MIDDLE} + KSAUDIO_SPEAKER_SUPER_WOOFER = SPEAKER_LOW_FREQUENCY; + {$EXTERNALSYM KSAUDIO_SPEAKER_SUPER_WOOFER} + +type + PKSAudioDynamicRange = ^TKSAudioDynamicRange; + KSAUDIO_DYNAMIC_RANGE = record + QuietCompression : ULONG; + LoudCompression : ULONG; + end; + {$EXTERNALSYM KSAUDIO_DYNAMIC_RANGE} + PKSAUDIO_DYNAMIC_RANGE = ^KSAUDIO_DYNAMIC_RANGE; + {$EXTERNALSYM PKSAUDIO_DYNAMIC_RANGE} + TKSAudioDynamicRange = KSAUDIO_DYNAMIC_RANGE; + + PKSAudioMixLevel = ^TKSAudioMixLevel; + KSAUDIO_MIXLEVEL = record + Mute : BOOL; + Level : Longint; + end; + {$EXTERNALSYM KSAUDIO_MIXLEVEL} + PKSAUDIO_MIXLEVEL = ^KSAUDIO_MIXLEVEL; + {$EXTERNALSYM PKSAUDIO_MIXLEVEL} + TKSAudioMixLevel = KSAUDIO_MIXLEVEL; + + PKSAudioMixCaps = ^TKSAudioMixCaps; + KSAUDIO_MIX_CAPS = record + Mute : BOOL; + Minimum : longint; + Maximum : longint; + Reset : longint; + end; + {$EXTERNALSYM KSAUDIO_MIX_CAPS} + PKSAUDIO_MIX_CAPS = ^KSAUDIO_MIX_CAPS; + {$EXTERNALSYM PKSAUDIO_MIX_CAPS} + TKSAudioMixCaps = KSAUDIO_MIX_CAPS; + + PKSaudioMixcapTable = ^TKSaudioMixcapTable; + KSAUDIO_MIXCAP_TABLE = record + InputChannels : ULONG; + OutputChannels : ULONG; + Capabilities : array[0..0] of TKSAudioMixCaps; + end; + {$EXTERNALSYM KSAUDIO_MIXCAP_TABLE} + PKSAUDIO_MIXCAP_TABLE = ^KSAUDIO_MIXCAP_TABLE; + {$EXTERNALSYM PKSAUDIO_MIXCAP_TABLE} + TKSaudioMixcapTable = KSAUDIO_MIXCAP_TABLE; + + SE_TECHNIQUE = ( + SE_TECH_NONE, + SE_TECH_ANALOG_DEVICES_PHAT, + SE_TECH_CREATIVE, + SE_TECH_NATIONAL_SEMI, + SE_TECH_YAMAHA_YMERSION, + SE_TECH_BBE, + SE_TECH_CRYSTAL_SEMI, + SE_TECH_QSOUND_QXPANDER, + SE_TECH_SPATIALIZER, + SE_TECH_SRS, + SE_TECH_PLATFORM_TECH, + SE_TECH_AKM, + SE_TECH_AUREAL, + SE_TECH_AZTECH, + SE_TECH_BINAURA, + SE_TECH_ESS_TECH, + SE_TECH_HARMAN_VMAX, + SE_TECH_NVIDEA, + SE_TECH_PHILIPS_INCREDIBLE, + SE_TECH_TEXAS_INST, + SE_TECH_VLSI_TECH + ); + {$EXTERNALSYM SE_TECHNIQUE} + TSETechnique = SE_TECHNIQUE; + + PKSAudioStereoEnhance = ^TKSAudioStereoEnhance; + KSAUDIO_STEREO_ENHANCE = record + Technique : TSETechnique; + Center : ULONG; + Depth : ULONG; + Reserved : ULONG; + end; + {$EXTERNALSYM KSAUDIO_STEREO_ENHANCE} + PKSAUDIO_STEREO_ENHANCE = ^KSAUDIO_STEREO_ENHANCE; + {$EXTERNALSYM PKSAUDIO_STEREO_ENHANCE} + TKSAudioStereoEnhance = KSAUDIO_STEREO_ENHANCE; + +//=========================================================================== +// Topology Node Type GUIDs +const + KSNODETYPE_DAC : TGUID = '{507AE360-C554-11D0-8A2B-00A0C9255AC1}'; + {$EXTERNALSYM KSNODETYPE_DAC} + KSNODETYPE_ADC : TGUID = '{4D837FE0-C555-11D0-8A2B-00A0C9255AC1}'; + {$EXTERNALSYM KSNODETYPE_ADC} + KSNODETYPE_SRC : TGUID = '{9DB7B9E0-C555-11D0-8A2B-00A0C9255AC1}'; + {$EXTERNALSYM KSNODETYPE_SRC} + KSNODETYPE_SUPERMIX : TGUID = '{E573ADC0-C555-11D0-8A2B-00A0C9255AC1}'; + {$EXTERNALSYM KSNODETYPE_SUPERMIX} + KSNODETYPE_MUX : TGUID = '{2CEAF780-C556-11D0-8A2B-00A0C9255AC1}'; + {$EXTERNALSYM KSNODETYPE_MUX} + KSNODETYPE_DEMUX : TGUID = '{C0EB67D4-E807-11D0-958A-00C04FB925D3}'; + {$EXTERNALSYM KSNODETYPE_DEMUX} + KSNODETYPE_SUM : TGUID = '{DA441A60-C556-11D0-8A2B-00A0C9255AC1}'; + {$EXTERNALSYM KSNODETYPE_SUM} + KSNODETYPE_MUTE : TGUID = '{02B223C0-C557-11D0-8A2B-00A0C9255AC1}'; + {$EXTERNALSYM KSNODETYPE_MUTE} + KSNODETYPE_VOLUME : TGUID = '{3A5ACC00-C557-11D0-8A2B-00A0C9255AC1}'; + {$EXTERNALSYM KSNODETYPE_VOLUME} + KSNODETYPE_TONE : TGUID = '{7607E580-C557-11D0-8A2B-00A0C9255AC1}'; + {$EXTERNALSYM KSNODETYPE_TONE} + KSNODETYPE_EQUALIZER : TGUID = '{9D41B4A0-C557-11D0-8A2B-00A0C9255AC1}'; + {$EXTERNALSYM KSNODETYPE_EQUALIZER} + KSNODETYPE_AGC : TGUID = '{E88C9BA0-C557-11D0-8A2B-00A0C9255AC1}'; + {$EXTERNALSYM KSNODETYPE_AGC} + KSNODETYPE_NOISE_SUPPRESS : TGUID = '{E07F903F-62FD-4e60-8CDD-DEA7236665B5}'; + {$EXTERNALSYM KSNODETYPE_NOISE_SUPPRESS} + KSNODETYPE_DELAY : TGUID = '{144981E0-C558-11D0-8A2B-00A0C9255AC1}'; + {$EXTERNALSYM KSNODETYPE_DELAY} + KSNODETYPE_LOUDNESS : TGUID = '{41887440-C558-11D0-8A2B-00A0C9255AC1}'; + {$EXTERNALSYM KSNODETYPE_LOUDNESS} + KSNODETYPE_PROLOGIC_DECODER : TGUID = '{831C2C80-C558-11D0-8A2B-00A0C9255AC1}'; + {$EXTERNALSYM KSNODETYPE_PROLOGIC_DECODER} + KSNODETYPE_STEREO_WIDE : TGUID = '{A9E69800-C558-11D0-8A2B-00A0C9255AC1}'; + {$EXTERNALSYM KSNODETYPE_STEREO_WIDE} + KSNODETYPE_STEREO_ENHANCE : TGUID = '{AF6878AC-E83F-11D0-958A-00C04FB925D3}'; + {$EXTERNALSYM KSNODETYPE_STEREO_ENHANCE} + KSNODETYPE_REVERB : TGUID = '{EF0328E0-C558-11D0-8A2B-00A0C9255AC1}'; + {$EXTERNALSYM KSNODETYPE_REVERB} + KSNODETYPE_CHORUS : TGUID = '{20173F20-C559-11D0-8A2B-00A0C9255AC1}'; + {$EXTERNALSYM KSNODETYPE_CHORUS} + KSNODETYPE_3D_EFFECTS : TGUID = '{55515860-C559-11D0-8A2B-00A0C9255AC1}'; + {$EXTERNALSYM KSNODETYPE_3D_EFFECTS} + + KSNODETYPE_ACOUSTIC_ECHO_CANCEL : TGUID = '{BF963D80-C559-11D0-8A2B-00A0C9255AC1}'; //KSCATEGORY_ACOUSTIC_ECHO_CANCEL + {$EXTERNALSYM KSNODETYPE_ACOUSTIC_ECHO_CANCEL} + KSNODETYPE_MICROPHONE_ARRAY_PROCESSOR : TGUID = '{830a44f2-a32d-476b-be97-42845673b35a}'; //KSCATEGORY_MICROPHONE_ARRAY_PROCESSOR + {$EXTERNALSYM KSNODETYPE_MICROPHONE_ARRAY_PROCESSOR} + + KSNODETYPE_DEV_SPECIFIC : TGUID = '{941C7AC0-C559-11D0-8A2B-00A0C9255AC1}'; + {$EXTERNALSYM KSNODETYPE_DEV_SPECIFIC} + KSNODETYPE_SURROUND_ENCODER : TGUID = '{8074C5B2-3C66-11D2-B45A-3078302C2030}'; + {$EXTERNALSYM KSNODETYPE_SURROUND_ENCODER} + KSNODETYPE_PEAKMETER : TGUID = '{A085651E-5F0D-4b36-A869-D195D6AB4B9E}'; + {$EXTERNALSYM KSNODETYPE_PEAKMETER} + +//=========================================================================== +// Topology Node Name GUIDs for common audio nodes + KSAUDFNAME_BASS : TGUID = '{185FEDE0-9905-11D1-95A9-00C04FB925D3}'; + {$EXTERNALSYM KSAUDFNAME_BASS} + KSAUDFNAME_TREBLE : TGUID = '{185FEDE1-9905-11D1-95A9-00C04FB925D3}'; + {$EXTERNALSYM KSAUDFNAME_TREBLE} + KSAUDFNAME_3D_STEREO : TGUID = '{185FEDE2-9905-11D1-95A9-00C04FB925D3}'; + {$EXTERNALSYM KSAUDFNAME_3D_STEREO} + KSAUDFNAME_MASTER_VOLUME : TGUID = '{185FEDE3-9905-11D1-95A9-00C04FB925D3}'; + {$EXTERNALSYM KSAUDFNAME_MASTER_VOLUME} + KSAUDFNAME_MASTER_MUTE : TGUID = '{185FEDE4-9905-11D1-95A9-00C04FB925D3}'; + {$EXTERNALSYM KSAUDFNAME_MASTER_MUTE} + KSAUDFNAME_WAVE_VOLUME : TGUID = '{185FEDE5-9905-11D1-95A9-00C04FB925D3}'; + {$EXTERNALSYM KSAUDFNAME_WAVE_VOLUME} + KSAUDFNAME_WAVE_MUTE : TGUID = '{185FEDE6-9905-11D1-95A9-00C04FB925D3}'; + {$EXTERNALSYM KSAUDFNAME_WAVE_MUTE} + KSAUDFNAME_MIDI_VOLUME : TGUID = '{185FEDE7-9905-11D1-95A9-00C04FB925D3}'; + {$EXTERNALSYM KSAUDFNAME_MIDI_VOLUME} + KSAUDFNAME_MIDI_MUTE : TGUID = '{185FEDE8-9905-11D1-95A9-00C04FB925D3}'; + {$EXTERNALSYM KSAUDFNAME_MIDI_MUTE} + KSAUDFNAME_CD_VOLUME : TGUID = '{185FEDE9-9905-11D1-95A9-00C04FB925D3}'; + {$EXTERNALSYM KSAUDFNAME_CD_VOLUME} + KSAUDFNAME_CD_MUTE : TGUID = '{185FEDEA-9905-11D1-95A9-00C04FB925D3}'; + {$EXTERNALSYM KSAUDFNAME_CD_MUTE} + KSAUDFNAME_LINE_VOLUME : TGUID = '{185FEDEB-9905-11D1-95A9-00C04FB925D3}'; + {$EXTERNALSYM KSAUDFNAME_LINE_VOLUME} + KSAUDFNAME_LINE_MUTE : TGUID = '{185FEDEC-9905-11D1-95A9-00C04FB925D3}'; + {$EXTERNALSYM KSAUDFNAME_LINE_MUTE} + KSAUDFNAME_MIC_VOLUME : TGUID = '{185FEDED-9905-11D1-95A9-00C04FB925D3}'; + {$EXTERNALSYM KSAUDFNAME_MIC_VOLUME} + KSAUDFNAME_MIC_MUTE : TGUID = '{185FEDEE-9905-11D1-95A9-00C04FB925D3}'; + {$EXTERNALSYM KSAUDFNAME_MIC_MUTE} + KSAUDFNAME_RECORDING_SOURCE : TGUID = '{185FEDEF-9905-11D1-95A9-00C04FB925D3}'; + {$EXTERNALSYM KSAUDFNAME_RECORDING_SOURCE} + KSAUDFNAME_PC_SPEAKER_VOLUME : TGUID = '{185FEDF0-9905-11D1-95A9-00C04FB925D3}'; + {$EXTERNALSYM KSAUDFNAME_PC_SPEAKER_VOLUME} + KSAUDFNAME_PC_SPEAKER_MUTE : TGUID = '{185FEDF1-9905-11D1-95A9-00C04FB925D3}'; + {$EXTERNALSYM KSAUDFNAME_PC_SPEAKER_MUTE} + KSAUDFNAME_MIDI_IN_VOLUME : TGUID = '{185FEDF2-9905-11D1-95A9-00C04FB925D3}'; + {$EXTERNALSYM KSAUDFNAME_MIDI_IN_VOLUME} + KSAUDFNAME_CD_IN_VOLUME : TGUID = '{185FEDF3-9905-11D1-95A9-00C04FB925D3}'; + {$EXTERNALSYM KSAUDFNAME_CD_IN_VOLUME} + KSAUDFNAME_LINE_IN_VOLUME : TGUID = '{185FEDF4-9905-11D1-95A9-00C04FB925D3}'; + {$EXTERNALSYM KSAUDFNAME_LINE_IN_VOLUME} + KSAUDFNAME_MIC_IN_VOLUME : TGUID = '{185FEDF5-9905-11D1-95A9-00C04FB925D3}'; + {$EXTERNALSYM KSAUDFNAME_MIC_IN_VOLUME} + KSAUDFNAME_WAVE_IN_VOLUME : TGUID = '{185FEDF6-9905-11D1-95A9-00C04FB925D3}'; + {$EXTERNALSYM KSAUDFNAME_WAVE_IN_VOLUME} + KSAUDFNAME_VOLUME_CONTROL : TGUID = '{185FEDF7-9905-11D1-95A9-00C04FB925D3}'; + {$EXTERNALSYM KSAUDFNAME_VOLUME_CONTROL} + KSAUDFNAME_MIDI : TGUID = '{185FEDF8-9905-11D1-95A9-00C04FB925D3}'; + {$EXTERNALSYM KSAUDFNAME_MIDI} + KSAUDFNAME_LINE_IN : TGUID = '{185FEDF9-9905-11D1-95A9-00C04FB925D3}'; + {$EXTERNALSYM KSAUDFNAME_LINE_IN} + KSAUDFNAME_RECORDING_CONTROL : TGUID = '{185FEDFA-9905-11D1-95A9-00C04FB925D3}'; + {$EXTERNALSYM KSAUDFNAME_RECORDING_CONTROL} + KSAUDFNAME_CD_AUDIO : TGUID = '{185FEDFB-9905-11D1-95A9-00C04FB925D3}'; + {$EXTERNALSYM KSAUDFNAME_CD_AUDIO} + KSAUDFNAME_AUX_VOLUME : TGUID = '{185FEDFC-9905-11D1-95A9-00C04FB925D3}'; + {$EXTERNALSYM KSAUDFNAME_AUX_VOLUME} + KSAUDFNAME_AUX_MUTE : TGUID = '{185FEDFD-9905-11D1-95A9-00C04FB925D3}'; + {$EXTERNALSYM KSAUDFNAME_AUX_MUTE} + KSAUDFNAME_AUX : TGUID = '{185FEDFE-9905-11D1-95A9-00C04FB925D3}'; + {$EXTERNALSYM KSAUDFNAME_AUX} + KSAUDFNAME_PC_SPEAKER : TGUID = '{185FEDFF-9905-11D1-95A9-00C04FB925D3}'; + {$EXTERNALSYM KSAUDFNAME_PC_SPEAKER} + KSAUDFNAME_WAVE_OUT_MIX : TGUID = '{185FEE00-9905-11D1-95A9-00C04FB925D3}'; + {$EXTERNALSYM KSAUDFNAME_WAVE_OUT_MIX} + KSAUDFNAME_MONO_OUT : TGUID = '{F9B41DC3-96E2-11d2-AC4C-00C04F8EFB68}'; + {$EXTERNALSYM KSAUDFNAME_MONO_OUT} + KSAUDFNAME_STEREO_MIX : TGUID = '{00DFF077-96E3-11d2-AC4C-00C04F8EFB68}'; + {$EXTERNALSYM KSAUDFNAME_STEREO_MIX} + KSAUDFNAME_MONO_MIX : TGUID = '{00DFF078-96E3-11d2-AC4C-00C04F8EFB68}'; + {$EXTERNALSYM KSAUDFNAME_MONO_MIX} + KSAUDFNAME_MONO_OUT_VOLUME : TGUID = '{1AD247EB-96E3-11d2-AC4C-00C04F8EFB68}'; + {$EXTERNALSYM KSAUDFNAME_MONO_OUT_VOLUME} + KSAUDFNAME_MONO_OUT_MUTE : TGUID = '{1AD247EC-96E3-11d2-AC4C-00C04F8EFB68}'; + {$EXTERNALSYM KSAUDFNAME_MONO_OUT_MUTE} + KSAUDFNAME_STEREO_MIX_VOLUME : TGUID = '{1AD247ED-96E3-11d2-AC4C-00C04F8EFB68}'; + {$EXTERNALSYM KSAUDFNAME_STEREO_MIX_VOLUME} + KSAUDFNAME_STEREO_MIX_MUTE : TGUID = '{22B0EAFD-96E3-11d2-AC4C-00C04F8EFB68}'; + {$EXTERNALSYM KSAUDFNAME_STEREO_MIX_MUTE} + KSAUDFNAME_MONO_MIX_VOLUME : TGUID = '{22B0EAFE-96E3-11d2-AC4C-00C04F8EFB68}'; + {$EXTERNALSYM KSAUDFNAME_MONO_MIX_VOLUME} + KSAUDFNAME_MONO_MIX_MUTE : TGUID = '{2BC31D69-96E3-11d2-AC4C-00C04F8EFB68}'; + {$EXTERNALSYM KSAUDFNAME_MONO_MIX_MUTE} + KSAUDFNAME_MICROPHONE_BOOST : TGUID = '{2BC31D6A-96E3-11d2-AC4C-00C04F8EFB68}'; + {$EXTERNALSYM KSAUDFNAME_MICROPHONE_BOOST} + KSAUDFNAME_ALTERNATE_MICROPHONE : TGUID = '{2BC31D6B-96E3-11d2-AC4C-00C04F8EFB68}'; + {$EXTERNALSYM KSAUDFNAME_ALTERNATE_MICROPHONE} + KSAUDFNAME_3D_DEPTH : TGUID = '{63FF5747-991F-11d2-AC4D-00C04F8EFB68}'; + {$EXTERNALSYM KSAUDFNAME_3D_DEPTH} + KSAUDFNAME_3D_CENTER : TGUID = '{9F0670B4-991F-11d2-AC4D-00C04F8EFB68}'; + {$EXTERNALSYM KSAUDFNAME_3D_CENTER} + KSAUDFNAME_VIDEO_VOLUME : TGUID = '{9B46E708-992A-11d2-AC4D-00C04F8EFB68}'; + {$EXTERNALSYM KSAUDFNAME_VIDEO_VOLUME} + KSAUDFNAME_VIDEO_MUTE : TGUID = '{9B46E709-992A-11d2-AC4D-00C04F8EFB68}'; + {$EXTERNALSYM KSAUDFNAME_VIDEO_MUTE} + KSAUDFNAME_VIDEO : TGUID = '{915DAEC4-A434-11d2-AC52-00C04F8EFB68}'; + {$EXTERNALSYM KSAUDFNAME_VIDEO} + KSAUDFNAME_PEAKMETER : TGUID = '{57E24340-FC5B-4612-A562-72B11A29DFAE}'; + {$EXTERNALSYM KSAUDFNAME_PEAKMETER} + +// Internal topology node pin definitions + + KSNODEPIN_STANDARD_IN = 1; + {$EXTERNALSYM KSNODEPIN_STANDARD_IN} + KSNODEPIN_STANDARD_OUT = 0; + {$EXTERNALSYM KSNODEPIN_STANDARD_OUT} + + KSNODEPIN_SUM_MUX_IN = 1; // can be >= 1 + {$EXTERNALSYM KSNODEPIN_SUM_MUX_IN} + KSNODEPIN_SUM_MUX_OUT = 0; + {$EXTERNALSYM KSNODEPIN_SUM_MUX_OUT} + + KSNODEPIN_DEMUX_IN = 0; + {$EXTERNALSYM KSNODEPIN_DEMUX_IN} + KSNODEPIN_DEMUX_OUT = 1; // can be >= 1 + {$EXTERNALSYM KSNODEPIN_DEMUX_OUT} + + KSNODEPIN_AEC_RENDER_IN = 1; + {$EXTERNALSYM KSNODEPIN_AEC_RENDER_IN} + KSNODEPIN_AEC_RENDER_OUT = 0; + {$EXTERNALSYM KSNODEPIN_AEC_RENDER_OUT} + KSNODEPIN_AEC_CAPTURE_IN = 2; + {$EXTERNALSYM KSNODEPIN_AEC_CAPTURE_IN} + KSNODEPIN_AEC_CAPTURE_OUT = 3; + {$EXTERNALSYM KSNODEPIN_AEC_CAPTURE_OUT} + +//=========================================================================== +//=========================================================================== + + KSMETHODSETID_Wavetable : TGUID = '{DCEF31EB-D907-11D0-9583-00C04FB925D3}'; + {$EXTERNALSYM KSMETHODSETID_Wavetable} + +type + KSMETHOD_WAVETABLE = ( + KSMETHOD_WAVETABLE_WAVE_ALLOC, + KSMETHOD_WAVETABLE_WAVE_FREE, + KSMETHOD_WAVETABLE_WAVE_FIND, + KSMETHOD_WAVETABLE_WAVE_WRITE + ); + {$EXTERNALSYM KSMETHOD_WAVETABLE} + TKSMethodWavetable = KSMETHOD_WAVETABLE; + + PKSWaveTableWaveDesc = ^TKSWaveTableWaveDesc; + KSWAVETABLE_WAVE_DESC = record + Identifier : TKSIdentifier; // wave identifier + Size : ULONG; // wave size + Looped : BOOL; // wave looped flag + LoopPoint : ULONG; // wave loop point + InROM : BOOL; // wave InROM flag + Format : TKSDataFormat; // wave format + end; + {$EXTERNALSYM KSWAVETABLE_WAVE_DESC} + PKSWAVETABLE_WAVE_DESC = ^KSWAVETABLE_WAVE_DESC; + {$EXTERNALSYM PKSWAVETABLE_WAVE_DESC} + TKSWaveTableWaveDesc = KSWAVETABLE_WAVE_DESC; + +//=========================================================================== +//=========================================================================== + +// +// Property sets and items +// + +//=========================================================================== +//=========================================================================== + +const + KSPROPSETID_Itd3d : TGUID = '{6429f090-9fd9-11d0-a75b-00a0c90365e3}'; + {$EXTERNALSYM KSPROPSETID_Itd3d} + +//type +// KSPROPERTY_ITD3D = ( +// KSPROPERTY_ITD3D_PARAMS +// ); +// {$EXTERNALSYM KSPROPERTY_ITD3D} +// TKSPropertyITD3D = KSPROPERTY_ITD3D; + +//=========================================================================== +//=========================================================================== +const + KSPROPSETID_Hrtf3d: TGUID = '{b66decb0-a083-11d0-851e-00c04fd9baf3}'; + {$EXTERNALSYM KSPROPSETID_Hrtf3d} + +//type +// KSPROPERTY_HRTF3D = ( +// KSPROPERTY_HRTF3D_PARAMS, +// KSPROPERTY_HRTF3D_INITIALIZE, +// KSPROPERTY_HRTF3D_FILTER_FORMAT +// ); +// {$EXTERNALSYM KSPROPERTY_HRTF3D} +// TKSPropertyHRTF3D = KSPROPERTY_HRTF3D; + +//=========================================================================== +//=========================================================================== +const + KSPROPSETID_Wave_Queued : TGUID = '{16a15b10-16f0-11d0-a195-0020afd156e4}'; + {$EXTERNALSYM KSPROPSETID_Wave_Queued} + + KSPROPERTY_WAVE_QUEUED_POSITION = $00000001; + {$EXTERNALSYM KSPROPERTY_WAVE_QUEUED_POSITION} + + KSMETHODSETID_Wave_Queued : TGUID = '{7432c160-8827-11cf-a102-0020afd156e4}'; + {$EXTERNALSYM KSMETHODSETID_Wave_Queued} + + KSMETHOD_WAVE_QUEUED_BREAKLOOP = $00000001; + {$EXTERNALSYM KSMETHOD_WAVE_QUEUED_BREAKLOOP} + + KSPROPSETID_Wave : TGUID = '{924e54b0-630f-11cf-ada7-08003e30494a}'; + {$EXTERNALSYM KSPROPSETID_Wave} + +type + KSPROPERTY_WAVE = ( + KSPROPERTY_WAVE_COMPATIBLE_CAPABILITIES, + KSPROPERTY_WAVE_INPUT_CAPABILITIES, + KSPROPERTY_WAVE_OUTPUT_CAPABILITIES, + KSPROPERTY_WAVE_BUFFER, + KSPROPERTY_WAVE_FREQUENCY, + KSPROPERTY_WAVE_VOLUME, + KSPROPERTY_WAVE_PAN + ); + {$EXTERNALSYM KSPROPERTY_WAVE} + TKSPropertyWave = KSPROPERTY_WAVE; + + PKSWaveCompatCaps = ^TKSWaveCompatCaps; + KSWAVE_COMPATCAPS = record + ulDeviceType : ULONG; + end; + {$EXTERNALSYM KSWAVE_COMPATCAPS} + PKSWAVE_COMPATCAPS = ^KSWAVE_COMPATCAPS; + {$EXTERNALSYM PKSWAVE_COMPATCAPS} + TKSWaveCompatCaps = KSWAVE_COMPATCAPS; + +const + KSWAVE_COMPATCAPS_INPUT = $00000000; + {$EXTERNALSYM KSWAVE_COMPATCAPS_INPUT} + KSWAVE_COMPATCAPS_OUTPUT = $00000001; + {$EXTERNALSYM KSWAVE_COMPATCAPS_OUTPUT} + +type + PKSWaveInputCapabilities = ^TKSWaveInputCapabilities; + KSWAVE_INPUT_CAPABILITIES = record + MaximumChannelsPerConnection : ULONG; + MinimumBitsPerSample : ULONG; + MaximumBitsPerSample : ULONG; + MinimumSampleFrequency : ULONG; + MaximumSampleFrequency : ULONG; + TotalConnections : ULONG; + ActiveConnections : ULONG; + end; + {$EXTERNALSYM KSWAVE_INPUT_CAPABILITIES} + PKSWAVE_INPUT_CAPABILITIES = ^KSWAVE_INPUT_CAPABILITIES; + {$EXTERNALSYM PKSWAVE_INPUT_CAPABILITIES} + TKSWaveInputCapabilities = KSWAVE_INPUT_CAPABILITIES; + + PKSWaveOutputCapabilities = ^TKSWaveOutputCapabilities; + KSWAVE_OUTPUT_CAPABILITIES = record + MaximumChannelsPerConnection : ULONG; + MinimumBitsPerSample : ULONG; + MaximumBitsPerSample : ULONG; + MinimumSampleFrequency : ULONG; + MaximumSampleFrequency : ULONG; + TotalConnections : ULONG; + StaticConnections : ULONG; + StreamingConnections : ULONG; + ActiveConnections : ULONG; + ActiveStaticConnections : ULONG; + ActiveStreamingConnections : ULONG; + Total3DConnections : ULONG; + Static3DConnections : ULONG; + Streaming3DConnections : ULONG; + Active3DConnections : ULONG; + ActiveStatic3DConnections : ULONG; + ActiveStreaming3DConnections : ULONG; + TotalSampleMemory : ULONG; + FreeSampleMemory : ULONG; + LargestFreeContiguousSampleMemory : ULONG; + end; + {$EXTERNALSYM KSWAVE_OUTPUT_CAPABILITIES} + PKSWAVE_OUTPUT_CAPABILITIES = ^KSWAVE_OUTPUT_CAPABILITIES; + {$EXTERNALSYM PKSWAVE_OUTPUT_CAPABILITIES} + TKSWaveOutputCapabilities = KSWAVE_OUTPUT_CAPABILITIES; + + PKSWaveVolume = ^TKSWaveVolume; + KSWAVE_VOLUME = record + LeftAttenuation : longint; + RightAttenuation : longint; + end; + {$EXTERNALSYM KSWAVE_VOLUME} + PKSWAVE_VOLUME = ^KSWAVE_VOLUME; + {$EXTERNALSYM PKSWAVE_VOLUME} + TKSWaveVolume = KSWAVE_VOLUME; + +const + KSWAVE_BUFFER_ATTRIBUTEF_LOOPING = $00000001; + {$EXTERNALSYM KSWAVE_BUFFER_ATTRIBUTEF_LOOPING} + KSWAVE_BUFFER_ATTRIBUTEF_STATIC = $00000002; + {$EXTERNALSYM KSWAVE_BUFFER_ATTRIBUTEF_STATIC} + +type + PKSWaveBuffer = ^TKSWaveBuffer; + KSWAVE_BUFFER = record + Attributes : ULONG; + BufferSize : ULONG; + BufferAddress : Pointer; + end; + {$EXTERNALSYM KSWAVE_BUFFER} + PKSWAVE_BUFFER = ^KSWAVE_BUFFER; + {$EXTERNALSYM PKSWAVE_BUFFER} + TKSWaveBuffer = KSWAVE_BUFFER; + +//=========================================================================== +//=========================================================================== +const + KSMUSIC_TECHNOLOGY_PORT : TGUID = '{86C92E60-62E8-11CF-A5D6-28DB04C10000}'; + {$EXTERNALSYM KSMUSIC_TECHNOLOGY_PORT} + KSMUSIC_TECHNOLOGY_SQSYNTH : TGUID = '{0ECF4380-62E9-11CF-A5D6-28DB04C10000}'; + {$EXTERNALSYM KSMUSIC_TECHNOLOGY_SQSYNTH} + KSMUSIC_TECHNOLOGY_FMSYNTH : TGUID = '{252C5C80-62E9-11CF-A5D6-28DB04C10000}'; + {$EXTERNALSYM KSMUSIC_TECHNOLOGY_FMSYNTH} + KSMUSIC_TECHNOLOGY_WAVETABLE : TGUID = '{394EC7C0-62E9-11CF-A5D6-28DB04C10000}'; + {$EXTERNALSYM KSMUSIC_TECHNOLOGY_WAVETABLE} + KSMUSIC_TECHNOLOGY_SWSYNTH : TGUID = '{37407736-3620-11D1-85D3-0000F8754380}'; + {$EXTERNALSYM KSMUSIC_TECHNOLOGY_SWSYNTH} + KSPROPSETID_WaveTable : TGUID = '{8539E660-62E9-11CF-A5D6-28DB04C10000}'; + {$EXTERNALSYM KSPROPSETID_WaveTable} + +type + KSPROPERTY_WAVETABLE = ( + KSPROPERTY_WAVETABLE_LOAD_SAMPLE, + KSPROPERTY_WAVETABLE_UNLOAD_SAMPLE, + KSPROPERTY_WAVETABLE_MEMORY, + KSPROPERTY_WAVETABLE_VERSION + ); + {$EXTERNALSYM KSPROPERTY_WAVETABLE} + TKSPropertyWaveTable = KSPROPERTY_WAVETABLE; + + PKSDataRangeMusic = ^TKSDataRangeMusic; + KSDATARANGE_MUSIC = record + DataRange : TKSDataRange; + Technology : TGUID; + Channels : ULONG; + Notes : ULONG; + ChannelMask : ULONG; + end; + {$EXTERNALSYM KSDATARANGE_MUSIC} + PKSDATARANGE_MUSIC = ^KSDATARANGE_MUSIC; + {$EXTERNALSYM PKSDATARANGE_MUSIC} + TKSDataRangeMusic = KSDATARANGE_MUSIC; + +//=========================================================================== +const + KSEVENTSETID_Cyclic : TGUID = '{142C1AC0-072A-11D0-A5D6-28DB04C10000}'; + {$EXTERNALSYM KSEVENTSETID_Cyclic} + +type + KSEVENT_CYCLIC_TIME = ( + KSEVENT_CYCLIC_TIME_INTERVAL + ); + {$EXTERNALSYM KSEVENT_CYCLIC_TIME} + TKSEventCyclicTime = KSEVENT_CYCLIC_TIME; + +const + KSPROPSETID_Cyclic: TGUID = '{3FFEAEA0-2BEE-11CF-A5D6-28DB04C10000}'; + {$EXTERNALSYM KSPROPSETID_Cyclic} + +type + KSPROPERTY_CYCLIC = ( + KSPROPERTY_CYCLIC_POSITION + ); + {$EXTERNALSYM KSPROPERTY_CYCLIC} + TKSPropertyCyclic = KSPROPERTY_CYCLIC; + +//=========================================================================== +const + KSEVENTSETID_AudioControlChange: TGUID = '{E85E9698-FA2F-11D1-95BD-00C04FB925D3}'; + {$EXTERNALSYM KSEVENTSETID_AudioControlChange} + +type + KSEVENT_AUDIO_CONTROL_CHANGE = ( + KSEVENT_CONTROL_CHANGE + ); + {$EXTERNALSYM KSEVENT_AUDIO_CONTROL_CHANGE} + TKSEventAudioControlChange = KSEVENT_AUDIO_CONTROL_CHANGE; + +//=========================================================================== +const + KSEVENTSETID_LoopedStreaming : TGUID = '{4682B940-C6EF-11D0-96D8-00AA0051E51D}'; + {$EXTERNALSYM KSEVENTSETID_LoopedStreaming} + +type + KSEVENT_LOOPEDSTREAMING = ( + KSEVENT_LOOPEDSTREAMING_POSITION + ); + {$EXTERNALSYM KSEVENT_LOOPEDSTREAMING} + TKSEventLoopedStreaming = KSEVENT_LOOPEDSTREAMING; + + PLoopedStreamingPositionEventData = ^TLoopedStreamingPositionEventData; + LOOPEDSTREAMING_POSITION_EVENT_DATA = record + KsEventData : TKSEVENTDATA; + Position : int64; + end; + {$EXTERNALSYM LOOPEDSTREAMING_POSITION_EVENT_DATA} + PLOOPEDSTREAMING_POSITION_EVENT_DATA = ^LOOPEDSTREAMING_POSITION_EVENT_DATA; + {$EXTERNALSYM PLOOPEDSTREAMING_POSITION_EVENT_DATA} + TLoopedStreamingPositionEventData = LOOPEDSTREAMING_POSITION_EVENT_DATA; + +const + KSEVENTSETID_Sysaudio : TGUID = '{04800320-4491-11D1-A050-405705C10000}'; + {$EXTERNALSYM KSEVENTSETID_Sysaudio} + +type + KSEVENT_SYSAUDIO = ( + KSEVENT_SYSAUDIO_ADDREMOVE_DEVICE, + KSEVENT_SYSAUDIO_CHANGE_DEVICE + ); + {$EXTERNALSYM KSEVENT_SYSAUDIO} + TKSEventSysAudio = KSEVENT_SYSAUDIO; + +const + KSPROPSETID_Sysaudio : TGUID = '{CBE3FAA0-CC75-11D0-B465-00001A1818E6}'; + {$EXTERNALSYM KSPROPSETID_Sysaudio} + +type + KSPROPERTY_SYSAUDIO = ( + KSPROPERTY_SYSAUDIO_DEVICE_Invalid, + KSPROPERTY_SYSAUDIO_DEVICE_COUNT, + KSPROPERTY_SYSAUDIO_DEVICE_FRIENDLY_NAME, + KSPROPERTY_SYSAUDIO_DEVICE_INSTANCE, + KSPROPERTY_SYSAUDIO_DEVICE_INTERFACE_NAME, + KSPROPERTY_SYSAUDIO_SELECT_GRAPH, + KSPROPERTY_SYSAUDIO_CREATE_VIRTUAL_SOURCE, + KSPROPERTY_SYSAUDIO_DEVICE_DEFAULT, + KSPROPERTY_SYSAUDIO_ALWAYS_CREATE_VIRTUAL_SOURCE, + KSPROPERTY_SYSAUDIO_ADDREMOVE_LOCK, + KSPROPERTY_SYSAUDIO_ADDREMOVE_UNLOCK, + KSPROPERTY_SYSAUDIO_RENDER_PIN_INSTANCES, + KSPROPERTY_SYSAUDIO_RENDER_CONNECTION_INDEX, + KSPROPERTY_SYSAUDIO_CREATE_VIRTUAL_SOURCE_ONLY, + KSPROPERTY_SYSAUDIO_INSTANCE_INFO, + KSPROPERTY_SYSAUDIO_PREFERRED_DEVICE, + KSPROPERTY_SYSAUDIO_COMPONENT_ID, + KSPROPERTY_SYSAUDIO_ADDREMOVE_GFX + ); + {$EXTERNALSYM KSPROPERTY_SYSAUDIO} + TKSPropertySysAudio = KSPROPERTY_SYSAUDIO; + + PSysAudioCreateVirtualSource = ^TSysAudioCreateVirtualSource; + SYSAUDIO_CREATE_VIRTUAL_SOURCE = record + Property_ : KSPROPERTY; + PinCategory : TGUID; + PinName : TGUID; + end; + {$EXTERNALSYM SYSAUDIO_CREATE_VIRTUAL_SOURCE} + PSYSAUDIO_CREATE_VIRTUAL_SOURCE = ^SYSAUDIO_CREATE_VIRTUAL_SOURCE; + {$EXTERNALSYM PSYSAUDIO_CREATE_VIRTUAL_SOURCE} + TSysAudioCreateVirtualSource = SYSAUDIO_CREATE_VIRTUAL_SOURCE; + + PSysAudioSelectGraph = ^TSysAudioSelectGraph; + SYSAUDIO_SELECT_GRAPH = record + Property_ : KSPROPERTY; + PinId : ULONG; + NodeId : ULONG; + Flags : ULONG; + Reserved : ULONG; + end; + {$EXTERNALSYM SYSAUDIO_SELECT_GRAPH} + PSYSAUDIO_SELECT_GRAPH = ^SYSAUDIO_SELECT_GRAPH; + {$EXTERNALSYM PSYSAUDIO_SELECT_GRAPH} + TSysAudioSelectGraph = SYSAUDIO_SELECT_GRAPH; + + PSysAudioInstanceInfo = ^TSysAudioInstanceInfo; + SYSAUDIO_INSTANCE_INFO = record + Property_ : KSPROPERTY; + Flags : ULONG; + DeviceNumber : ULONG; + end; + {$EXTERNALSYM SYSAUDIO_INSTANCE_INFO} + PSYSAUDIO_INSTANCE_INFO = ^SYSAUDIO_INSTANCE_INFO; + {$EXTERNALSYM PSYSAUDIO_INSTANCE_INFO} + TSysAudioInstanceInfo = SYSAUDIO_INSTANCE_INFO; + +const + SYSAUDIO_FLAGS_DONT_COMBINE_PINS = $00000001; + {$EXTERNALSYM SYSAUDIO_FLAGS_DONT_COMBINE_PINS} + +type + SYSAUDIO_PREFERRED_DEVICE = record + Property_ : KSPROPERTY; + Flags : ULONG; + Index : ULONG; // KSPROPERTY_SYSAUDIO_DEFAULT_TYPE + end; + {$EXTERNALSYM SYSAUDIO_PREFERRED_DEVICE} + PSYSAUDIO_PREFERRED_DEVICE = ^SYSAUDIO_PREFERRED_DEVICE; + {$EXTERNALSYM PSYSAUDIO_PREFERRED_DEVICE} + TSysAudioPreferredDevice = SYSAUDIO_PREFERRED_DEVICE; + +const + SYSAUDIO_FLAGS_CLEAR_PREFERRED = $00000002; + {$EXTERNALSYM SYSAUDIO_FLAGS_CLEAR_PREFERRED} + +type + KSPROPERTY_SYSAUDIO_DEFAULT_TYPE = ( // preferred device index + KSPROPERTY_SYSAUDIO_NORMAL_DEFAULT, + KSPROPERTY_SYSAUDIO_PLAYBACK_DEFAULT, + KSPROPERTY_SYSAUDIO_RECORD_DEFAULT, + KSPROPERTY_SYSAUDIO_MIDI_DEFAULT, + KSPROPERTY_SYSAUDIO_MIXER_DEFAULT + ); + {$EXTERNALSYM KSPROPERTY_SYSAUDIO_DEFAULT_TYPE} + TKSPropertySysAudioDefaultType = KSPROPERTY_SYSAUDIO_DEFAULT_TYPE; + +const + KSPROPSETID_Sysaudio_Pin : TGUID = '{A3A53220-C6E4-11D0-B465-00001A1818E6}'; + {$EXTERNALSYM KSPROPSETID_Sysaudio_Pin} + +type + KSPROPERTY_SYSAUDIO_PIN = ( + KSPROPERTY_SYSAUDIO_TOPOLOGY_CONNECTION_INDEX, + KSPROPERTY_SYSAUDIO_ATTACH_VIRTUAL_SOURCE, + KSPROPERTY_SYSAUDIO_PIN_VOLUME_NODE + ); + {$EXTERNALSYM KSPROPERTY_SYSAUDIO_PIN} + TKSPropertySysAudioPin = KSPROPERTY_SYSAUDIO_PIN; + + PSysAudioAttachVirtualSource = ^TSysAudioAttachVirtualSource; + SYSAUDIO_ATTACH_VIRTUAL_SOURCE = record + Property_ : KSPROPERTY; + MixerPinId : ULONG; + Reserved : ULONG; + end; + {$EXTERNALSYM SYSAUDIO_ATTACH_VIRTUAL_SOURCE} + PSYSAUDIO_ATTACH_VIRTUAL_SOURCE = ^SYSAUDIO_ATTACH_VIRTUAL_SOURCE; + {$EXTERNALSYM PSYSAUDIO_ATTACH_VIRTUAL_SOURCE} + TSysAudioAttachVirtualSource = SYSAUDIO_ATTACH_VIRTUAL_SOURCE; + + KSNODEPROPERTY = record + Property_ : KSPROPERTY; + NodeId : ULONG; + Reserved : ULONG; + end; + {$EXTERNALSYM KSNODEPROPERTY} + PKSNODEPROPERTY = ^KSNODEPROPERTY; + {$EXTERNALSYM PKSNODEPROPERTY} + TKSNodeProperty = KSNODEPROPERTY; + + PKSNodePropertyAudioChannel = ^TKSNodePropertyAudioChannel; + KSNODEPROPERTY_AUDIO_CHANNEL = record + NodeProperty : TKSNODEPROPERTY; + Channel : Longint; // value to get or set + Reserved : ULONG; + end; + {$EXTERNALSYM KSNODEPROPERTY_AUDIO_CHANNEL} + PKSNODEPROPERTY_AUDIO_CHANNEL = ^KSNODEPROPERTY_AUDIO_CHANNEL; + {$EXTERNALSYM PKSNODEPROPERTY_AUDIO_CHANNEL} + TKSNodePropertyAudioChannel = KSNODEPROPERTY_AUDIO_CHANNEL; + + PKSNodePropertyAudioDevSpecific = ^TKSNodePropertyAudioDevSpecific; + KSNODEPROPERTY_AUDIO_DEV_SPECIFIC = record + NodeProperty :TKSNODEPROPERTY; + DevSpecificId :ULONG; + DeviceInfo :ULONG; + Length :ULONG; + end; + {$EXTERNALSYM KSNODEPROPERTY_AUDIO_DEV_SPECIFIC} + PKSNODEPROPERTY_AUDIO_DEV_SPECIFIC = ^KSNODEPROPERTY_AUDIO_DEV_SPECIFIC; + {$EXTERNALSYM PKSNODEPROPERTY_AUDIO_DEV_SPECIFIC} + TKSNodePropertyAudioDevSpecific = KSNODEPROPERTY_AUDIO_DEV_SPECIFIC; + + PKSNodePropertyAudio3DListenerp = ^TKSNodePropertyAudio3DListener; + KSNODEPROPERTY_AUDIO_3D_LISTENER = record + NodeProperty : TKSNODEPROPERTY; + ListenerId : pointer; + Reserved : ULONG; + end; + {$EXTERNALSYM KSNODEPROPERTY_AUDIO_3D_LISTENER} + PKSNODEPROPERTY_AUDIO_3D_LISTENER = ^KSNODEPROPERTY_AUDIO_3D_LISTENER; + {$EXTERNALSYM PKSNODEPROPERTY_AUDIO_3D_LISTENER} + TKSNodePropertyAudio3DListener = KSNODEPROPERTY_AUDIO_3D_LISTENER; + + PKSNodePropertyAudioProperty = ^TKSNodePropertyAudioProperty; + KSNODEPROPERTY_AUDIO_PROPERTY = record + NodeProperty : TKSNODEPROPERTY; + AppContext : Pointer; + Length : ULONG; + Reserved : ULONG; + end; + {$EXTERNALSYM KSNODEPROPERTY_AUDIO_PROPERTY} + PKSNODEPROPERTY_AUDIO_PROPERTY = ^KSNODEPROPERTY_AUDIO_PROPERTY; + {$EXTERNALSYM PKSNODEPROPERTY_AUDIO_PROPERTY} + TKSNodePropertyAudioProperty = KSNODEPROPERTY_AUDIO_PROPERTY; + +//=========================================================================== +const + KSPROPSETID_Linear : TGUID = '{5A2FFE80-16B9-11D0-A5D6-28DB04C10000}'; + {$EXTERNALSYM KSPROPSETID_Linear} + +type + KSPROPERTY_LINEAR = ( + KSPROPERTY_LINEAR_POSITION + ); + {$EXTERNALSYM KSPROPERTY_LINEAR} + TKSPropertyLinear = KSPROPERTY_LINEAR; + +//=========================================================================== + +// +// Midi definitions +// + +// +// Formats +// +const + KSDATAFORMAT_TYPE_MUSIC : TGUID = '{E725D360-62CC-11CF-A5D6-28DB04C10000}'; + {$EXTERNALSYM KSDATAFORMAT_TYPE_MUSIC} +// 'mids' == MEDIATYPE_Midi + KSDATAFORMAT_TYPE_MIDI : TGUID = '{7364696D-0000-0010-8000-00aa00389b71}'; + {$EXTERNALSYM KSDATAFORMAT_TYPE_MIDI} + KSDATAFORMAT_SUBTYPE_MIDI : TGUID = '{1D262760-E957-11CF-A5D6-28DB04C10000}'; + {$EXTERNALSYM KSDATAFORMAT_SUBTYPE_MIDI} + KSDATAFORMAT_SUBTYPE_MIDI_BUS : TGUID = '{2CA15FA0-6CFE-11CF-A5D6-28DB04C10000}'; + {$EXTERNALSYM KSDATAFORMAT_SUBTYPE_MIDI_BUS} + KSDATAFORMAT_SUBTYPE_RIFFMIDI : TGUID = '{4995DAF0-9EE6-11D0-A40E-00A0C9223196}'; + {$EXTERNALSYM KSDATAFORMAT_SUBTYPE_RIFFMIDI} + +// +// KSDATAFORMAT_SUBTYPE_DIRECTMUSIC +// see DMusicKS.h +// + +// WARNING! This structure MUST be dword aligned +// regardless of the number of data bytes. +type + KSMUSICFORMAT = record + TimeDeltaMs : ULONG ; // Delta Milliseconds from the previous midiformat + // in the packet. The first midiformat in the packet + // is a delta from the PTS in the KSSTREAM_HEADER. + ByteCount : ULONG ; // Number of bytes of data that follow this struct. + end; + {$EXTERNALSYM KSMUSICFORMAT} + PKSMUSICFORMAT = ^KSMUSICFORMAT; + {$EXTERNALSYM PKSMUSICFORMAT} + TKSMusicFormat = KSMUSICFORMAT; + +// +// This entire set of MPEG Standard/Dialect Guids are obsolete. Do not use them. +// +//==================================================================================================== +//==================================================================================================== +// The following official MPEG Formats, Subtypes and Specifiers are listed as required or optional +// These official MPEG GUIDs are the preferred method of supporting MPEG/AC-3 media types in new code. +// Older MPEG GUIDs should also be supported for compatibilty, but these new modes are still required. +//==================================================================================================== +//==================================================================================================== + +{ +This is a summary of what media types/specifiers will be required for all DVD+DSS+DVB+DTV MPEG decoders. +These media types are what the decoder driver must accept, hardware support for all of these media types +may or may not actually be provided by the decoder natively. These media types are intended to define +the "officially" supported MPEG/AC-3 media types that all WHQL certified decoders must implement. This +specifically includes driver and/or hardware support for all the required standards and dialects. + +All MPEG video decoders must support all of the MPEG video modes shown as [required] below. +All MPEG audio decoders must support all of the MPEG audio modes shown as [required] below. +All AC-3 audio decoders must support all of the AC-3 audio modes shown as [required] below. +The line items shown as [optional] need not be implemented, but are possible formats that might be implemented. + +Note that the input/output pin formats are defined by 2 or 3 GUIDs: TYPE, SUBTYPE, and maybe SPECIFIER. +The specifiers are included if the data format is a "dialect" that needs to be differentiated during decoding. +The decoder MUST be prepared to deal with ALL requests for _required_ "Standard" formats OR _required_ "Dialects". + +STATIC_KSDATAFORMAT_TYPE_STANDARD_ELEMENTARY_STREAM [required] + STATIC_KSDATAFORMAT_SUBTYPE_STANDARD_MPEG1_VIDEO [required] + STATIC_KSDATAFORMAT_SPECIFIER_DIALECT_MPEG1_VIDEO [optional] + STATIC_KSDATAFORMAT_SUBTYPE_STANDARD_MPEG1_AUDIO [required] + STATIC_KSDATAFORMAT_SPECIFIER_DIALECT_MPEG1_AUDIO [optional] + STATIC_KSDATAFORMAT_SUBTYPE_STANDARD_MPEG2_VIDEO [required] + STATIC_KSDATAFORMAT_SPECIFIER_DIALECT_MPEG2_VIDEO [required] + STATIC_KSDATAFORMAT_SUBTYPE_STANDARD_MPEG2_AUDIO [required] + STATIC_KSDATAFORMAT_SPECIFIER_DIALECT_MPEG2_AUDIO [optional] + STATIC_KSDATAFORMAT_SUBTYPE_STANDARD_AC3_AUDIO [required] + STATIC_KSDATAFORMAT_SPECIFIER_DIALECT_AC3_AUDIO [optional] +STATIC_KSDATAFORMAT_TYPE_STANDARD_PES_PACKET [required] + STATIC_KSDATAFORMAT_SUBTYPE_STANDARD_MPEG1_VIDEO [optional] + STATIC_KSDATAFORMAT_SPECIFIER_DIALECT_MPEG1_VIDEO [optional] + STATIC_KSDATAFORMAT_SUBTYPE_STANDARD_MPEG1_AUDIO [optional] + STATIC_KSDATAFORMAT_SPECIFIER_DIALECT_MPEG1_AUDIO [optional] + STATIC_KSDATAFORMAT_SUBTYPE_STANDARD_MPEG2_VIDEO [required] + STATIC_KSDATAFORMAT_SPECIFIER_DIALECT_MPEG2_VIDEO [required] + STATIC_KSDATAFORMAT_SUBTYPE_STANDARD_MPEG2_AUDIO [required] + STATIC_KSDATAFORMAT_SPECIFIER_DIALECT_MPEG2_AUDIO [required] + STATIC_KSDATAFORMAT_SUBTYPE_STANDARD_AC3_AUDIO [required] + STATIC_KSDATAFORMAT_SPECIFIER_DIALECT_AC3_AUDIO [optional] +STATIC_KSDATAFORMAT_TYPE_STANDARD_PACK_HEADER [required] + STATIC_KSDATAFORMAT_SUBTYPE_STANDARD_MPEG2_VIDEO [required] + STATIC_KSDATAFORMAT_SPECIFIER_DIALECT_MPEG2_VIDEO [required] + STATIC_KSDATAFORMAT_SUBTYPE_STANDARD_MPEG2_AUDIO [required] + STATIC_KSDATAFORMAT_SPECIFIER_DIALECT_MPEG2_AUDIO [optional] + STATIC_KSDATAFORMAT_SUBTYPE_STANDARD_AC3_AUDIO [required] + STATIC_KSDATAFORMAT_SPECIFIER_DIALECT_AC3_AUDIO [optional] + +Note that the SPECIFIER GUIDs normally identify particular versions of MPEG such as DSS and DVD. +This approach was taken to minimize the number of DSS/DVB/DVD/DTV etc. media SUBTYPES. +These specifiers are currently required to disambiguate MPEG syntax _parsing_ by the decoder +using alternate parsing routines or downloadable firmware or hardware decode settings. + +In the future these specifiers will be extended to cover new KS MPEG flavors such as DVB and DTV. +Thus, the optional specifiers will be subject to clarification and/or definition as they are needed. + +Important note: Per the ITU MPEG specs, MPEG 2 media may contain pure MPEG 1 syntax and +any "MPEG 2" PES packets may actually contain MPEG 1 payloads and MPEG 1 syntax. Some MPEG +broadcasts can revert from MPEG2 to MPEG1 format data at their discretion, without warning. + +CAUTION: Decoders MUST attempt to process MPEG data AS SOON AS POSSIBLE after reception. +In particular, elementary MPEG or MPEG PES packet streams should not be aggregated into DVD +"pack headers" internally before submission to the codec hardware if AT ALL POSSIBLE. The +reason is that mpeg data may need to be processed immediately but there may be no additional +MPEG data forthcoming to fill up the PES packet OR DVD "pack" in a timely fashion. This is +particularly true of MPEG dialects that utilize "repeat field signally" to reuse the last +decoded MPEG video field. + +} + +///////////////////////////////////////////////////////////////////////// +// The major data type GUIDs that define the data packet encapsulation // +///////////////////////////////////////////////////////////////////////// +const +// STATIC_KSDATAFORMAT_TYPE_STANDARD_ELEMENTARY_STREAM + KSDATAFORMAT_TYPE_STANDARD_ELEMENTARY_STREAM : TGUID = '{36523B11-8EE5-11d1-8CA3-0060B057664A}'; + {$EXTERNALSYM KSDATAFORMAT_TYPE_STANDARD_ELEMENTARY_STREAM} + +// STATIC_KSDATAFORMAT_TYPE_STANDARD_PES_PACKET + KSDATAFORMAT_TYPE_STANDARD_PES_PACKET : TGUID = '{36523B12-8EE5-11d1-8CA3-0060B057664A}'; + {$EXTERNALSYM KSDATAFORMAT_TYPE_STANDARD_PES_PACKET} + +// STATIC_KSDATAFORMAT_TYPE_STANDARD_PACK_HEADER + KSDATAFORMAT_TYPE_STANDARD_PACK_HEADER : TGUID = '{36523B13-8EE5-11d1-8CA3-0060B057664A}'; + {$EXTERNALSYM KSDATAFORMAT_TYPE_STANDARD_PACK_HEADER} + +/////////////////////////////////////////////////////////////////////////////// +// The minor data subtype GUIDs that define the exact class of the data type.// +/////////////////////////////////////////////////////////////////////////////// + +// STATIC_KSDATAFORMAT_SUBTYPE_STANDARD_MPEG1_VIDEO + KSDATAFORMAT_SUBTYPE_STANDARD_MPEG1_VIDEO : TGUID = '{36523B21-8EE5-11d1-8CA3-0060B057664A}'; + {$EXTERNALSYM KSDATAFORMAT_SUBTYPE_STANDARD_MPEG1_VIDEO} + +// STATIC_KSDATAFORMAT_SUBTYPE_STANDARD_MPEG1_AUDIO + KSDATAFORMAT_SUBTYPE_STANDARD_MPEG1_AUDIO : TGUID = '{36523B22-8EE5-11d1-8CA3-0060B057664A}'; + {$EXTERNALSYM KSDATAFORMAT_SUBTYPE_STANDARD_MPEG1_AUDIO} + +// STATIC_KSDATAFORMAT_SUBTYPE_STANDARD_MPEG2_VIDEO + KSDATAFORMAT_SUBTYPE_STANDARD_MPEG2_VIDEO : TGUID = '{36523B23-8EE5-11d1-8CA3-0060B057664A}'; + {$EXTERNALSYM KSDATAFORMAT_SUBTYPE_STANDARD_MPEG2_VIDEO} + +// STATIC_KSDATAFORMAT_SUBTYPE_STANDARD_MPEG2_AUDIO + KSDATAFORMAT_SUBTYPE_STANDARD_MPEG2_AUDIO : TGUID = '{36523B24-8EE5-11d1-8CA3-0060B057664A}'; + {$EXTERNALSYM KSDATAFORMAT_SUBTYPE_STANDARD_MPEG2_AUDIO} + +// STATIC_KSDATAFORMAT_SUBTYPE_STANDARD_AC3_AUDIO + KSDATAFORMAT_SUBTYPE_STANDARD_AC3_AUDIO : TGUID = '{36523B25-8EE5-11d1-8CA3-0060B057664A}'; + {$EXTERNALSYM KSDATAFORMAT_SUBTYPE_STANDARD_AC3_AUDIO} + +/////////////////////////////////////////////////////////////////////////////// +// The low-level specifier GUIDs that define the flavor of the data subtype. // +// Some SUBTYPES, notably MPEG2_VIDEO, MPEG2_AUDIO have different dialects. // +// These specifiers are intended to be accompanied by a specifier structure. // +/////////////////////////////////////////////////////////////////////////////// + +// STATIC_KSDATAFORMAT_SPECIFIER_DIALECT_MPEG1_VIDEO + KSDATAFORMAT_SPECIFIER_DIALECT_MPEG1_VIDEO : TGUID = '{36523B31-8EE5-11d1-8CA3-0060B057664A}'; + {$EXTERNALSYM KSDATAFORMAT_SPECIFIER_DIALECT_MPEG1_VIDEO} + +// STATIC_KSDATAFORMAT_SPECIFIER_DIALECT_MPEG1_AUDIO + KSDATAFORMAT_SPECIFIER_DIALECT_MPEG1_AUDIO : TGUID = '{36523B32-8EE5-11d1-8CA3-0060B057664A}'; + {$EXTERNALSYM KSDATAFORMAT_SPECIFIER_DIALECT_MPEG1_AUDIO} + +// STATIC_KSDATAFORMAT_SPECIFIER_DIALECT_MPEG2_VIDEO Associated with KS_MPEGVIDEOINFO2 defined later + KSDATAFORMAT_SPECIFIER_DIALECT_MPEG2_VIDEO : TGUID = '{36523B33-8EE5-11d1-8CA3-0060B057664A}'; + {$EXTERNALSYM KSDATAFORMAT_SPECIFIER_DIALECT_MPEG2_VIDEO} + +// STATIC_KSDATAFORMAT_SPECIFIER_DIALECT_MPEG2_AUDIO Associated with KS_MPEGAUDIOINFO defined later + KSDATAFORMAT_SPECIFIER_DIALECT_MPEG2_AUDIO : TGUID = '{36523B34-8EE5-11d1-8CA3-0060B057664A}'; + {$EXTERNALSYM KSDATAFORMAT_SPECIFIER_DIALECT_MPEG2_AUDIO} + +// STATIC_KSDATAFORMAT_SPECIFIER_DIALECT_AC3_AUDIO + KSDATAFORMAT_SPECIFIER_DIALECT_AC3_AUDIO : TGUID = '{36523B35-8EE5-11d1-8CA3-0060B057664A}'; + {$EXTERNALSYM KSDATAFORMAT_SPECIFIER_DIALECT_AC3_AUDIO} + +//==================================================================================================== +//==================================================================================================== +// *** COMPATIBILITY WARNING *** +// The *following* older DSS, MPEG, DVD & AC-3 GUID definitions are retained for backward compability. +// These MPEG GUIDs should also be supported for compatibilty, but the above newer modes are still required. +//==================================================================================================== +//==================================================================================================== + +// +// DSS definitions +// + + KSDATAFORMAT_SUBTYPE_DSS_VIDEO : TGUID = '{a0af4f81-e163-11d0-bad9-00609744111a}'; + {$EXTERNALSYM KSDATAFORMAT_SUBTYPE_DSS_VIDEO} + KSDATAFORMAT_SUBTYPE_DSS_AUDIO : TGUID = '{a0af4f82-e163-11d0-bad9-00609744111a}'; + {$EXTERNALSYM KSDATAFORMAT_SUBTYPE_DSS_AUDIO} + +// +// End of obsolete MPEG definitions. +// + +// +// mpeg 1 definitions +// + KSDATAFORMAT_SUBTYPE_MPEG1Packet : TGUID = '{e436eb80-524f-11ce-9F53-0020af0ba770}'; + {$EXTERNALSYM KSDATAFORMAT_SUBTYPE_MPEG1Packet} + KSDATAFORMAT_SUBTYPE_MPEG1Payload : TGUID = '{e436eb81-524f-11ce-9F53-0020af0ba770}'; + {$EXTERNALSYM KSDATAFORMAT_SUBTYPE_MPEG1Payload} + +// MEDIASUBTYPE_MPEG1Video + KSDATAFORMAT_SUBTYPE_MPEG1Video : TGUID = '{e436eb86-524f-11ce-9f53-0020af0ba770}'; + {$EXTERNALSYM KSDATAFORMAT_SUBTYPE_MPEG1Video} + +//FORMAT_MPEGVideo + KSDATAFORMAT_SPECIFIER_MPEG1_VIDEO : TGUID = '{05589f82-c356-11ce-bf01-00aa0055595a}'; + {$EXTERNALSYM KSDATAFORMAT_SPECIFIER_MPEG1_VIDEO} + +// +// mpeg 2 definitions +// + KSDATAFORMAT_TYPE_MPEG2_PES : TGUID = '{e06d8020-db46-11cf-b4d1-00805f6cbbea}'; + {$EXTERNALSYM KSDATAFORMAT_TYPE_MPEG2_PES} + KSDATAFORMAT_TYPE_MPEG2_PROGRAM : TGUID = '{e06d8022-db46-11cf-b4d1-00805f6cbbea}'; + {$EXTERNALSYM KSDATAFORMAT_TYPE_MPEG2_PROGRAM} + KSDATAFORMAT_TYPE_MPEG2_TRANSPORT : TGUID = '{e06d8023-db46-11cf-b4d1-00805f6cbbea}'; + {$EXTERNALSYM KSDATAFORMAT_TYPE_MPEG2_TRANSPORT} + KSDATAFORMAT_SUBTYPE_MPEG2_VIDEO : TGUID = '{e06d8026-db46-11cf-b4d1-00805f6cbbea}'; + {$EXTERNALSYM KSDATAFORMAT_SUBTYPE_MPEG2_VIDEO} + +// use MPEGVIDEOINFO2 (defined below) with KSDATAFORMAT_SPECIFIER_MPEG2_VIDEO + KSDATAFORMAT_SPECIFIER_MPEG2_VIDEO : TGUID = '{e06d80e3-db46-11cf-b4d1-00805f6cbbea}'; + {$EXTERNALSYM KSDATAFORMAT_SPECIFIER_MPEG2_VIDEO} + +// +// Mpeg2 video properties +// + KSPROPSETID_Mpeg2Vid : TGUID = '{C8E11B60-0CC9-11D0-BD69-003505C103A9}'; + {$EXTERNALSYM KSPROPSETID_Mpeg2Vid} + +type + KSPROPERTY_MPEG2VID = ( + KSPROPERTY_MPEG2VID_MODES, // available output modes of decoder + KSPROPERTY_MPEG2VID_CUR_MODE, // current mode of the decoder + KSPROPERTY_MPEG2VID_4_3_RECT, // output coordinates for 4:3 source + KSPROPERTY_MPEG2VID_16_9_RECT, // output coordinates for 16:9 source + KSPROPERTY_MPEG2VID_16_9_PANSCAN // pan and scan vectors + ); + {$EXTERNALSYM KSPROPERTY_MPEG2VID} + TKSPropertyMPEG2Vid = KSPROPERTY_MPEG2VID; + +// +// bit field definitions for MPEG2 VIDEO mode +// +const + KSMPEGVIDMODE_PANSCAN = $0001; + {$EXTERNALSYM KSMPEGVIDMODE_PANSCAN} + KSMPEGVIDMODE_LTRBOX = $0002; + {$EXTERNALSYM KSMPEGVIDMODE_LTRBOX} + KSMPEGVIDMODE_SCALE = $0004; + {$EXTERNALSYM KSMPEGVIDMODE_SCALE} + +// +// rectangle definitions for the 4/3 and 16/9 cropping properties of +// the MPEG2Video decoder +// +type + PKSMPEGVidRect = ^TKSMPEGVidRect; + _KSMPEGVID_RECT = record + StartX : ULONG; + StartY : ULONG; + EndX : ULONG; + EndY : ULONG; + end; + {$EXTERNALSYM _KSMPEGVID_RECT} + KSMPEGVID_RECT = _KSMPEGVID_RECT; + {$EXTERNALSYM KSMPEGVID_RECT} + PKSMPEGVID_RECT = ^KSMPEGVID_RECT; + {$EXTERNALSYM PKSMPEGVID_RECT} + TKSMPEGVidRect = _KSMPEGVID_RECT; + +// +// Params for pan / scan +// + + +// +// MPEG2 Audio definition +// +const + KSDATAFORMAT_SUBTYPE_MPEG2_AUDIO : TGUID = '{e06d802b-db46-11cf-b4d1-00805f6cbbea}'; + {$EXTERNALSYM KSDATAFORMAT_SUBTYPE_MPEG2_AUDIO} + KSDATAFORMAT_SPECIFIER_MPEG2_AUDIO : TGUID = '{e06d80e5-db46-11cf-b4d1-00805f6cbbea}'; + {$EXTERNALSYM KSDATAFORMAT_SPECIFIER_MPEG2_AUDIO} + +// +// DVD LPCM Audio definition +// + + KSDATAFORMAT_SUBTYPE_LPCM_AUDIO : TGUID = '{e06d8032-db46-11cf-b4d1-00805f6cbbea}'; + {$EXTERNALSYM KSDATAFORMAT_SUBTYPE_LPCM_AUDIO} + KSDATAFORMAT_SPECIFIER_LPCM_AUDIO : TGUID = '{e06d80e6-db46-11cf-b4d1-00805f6cbbea}'; + {$EXTERNALSYM KSDATAFORMAT_SPECIFIER_LPCM_AUDIO} + +// +// AC-3 definition +// + + KSDATAFORMAT_SUBTYPE_AC3_AUDIO : TGUID = '{e06d802c-db46-11cf-b4d1-00805f6cbbea}'; + {$EXTERNALSYM KSDATAFORMAT_SUBTYPE_AC3_AUDIO} + KSDATAFORMAT_SPECIFIER_AC3_AUDIO : TGUID = '{e06d80e4-db46-11cf-b4d1-00805f6cbbea}'; + {$EXTERNALSYM KSDATAFORMAT_SPECIFIER_AC3_AUDIO} + KSPROPSETID_AC3 : TGUID = '{BFABE720-6E1F-11D0-BCF2-444553540000}'; + {$EXTERNALSYM KSPROPSETID_AC3} + +type + KSPROPERTY_AC3 = ( + KSPROPERTY_AC3_Invalid, + KSPROPERTY_AC3_ERROR_CONCEALMENT, + KSPROPERTY_AC3_ALTERNATE_AUDIO, + KSPROPERTY_AC3_DOWNMIX, + KSPROPERTY_AC3_BIT_STREAM_MODE, + KSPROPERTY_AC3_DIALOGUE_LEVEL, + KSPROPERTY_AC3_LANGUAGE_CODE, + KSPROPERTY_AC3_ROOM_TYPE + ); + {$EXTERNALSYM KSPROPERTY_AC3} + TKSPropertyAC3 = KSPROPERTY_AC3; + + + PKSAC3ErrorConcealment = ^TKSAC3ErrorConcealment; + KSAC3_ERROR_CONCEALMENT = record + fRepeatPreviousBlock : BOOL; + fErrorInCurrentBlock : BOOL; + end; + {$EXTERNALSYM KSAC3_ERROR_CONCEALMENT} + PKSAC3_ERROR_CONCEALMENT = ^KSAC3_ERROR_CONCEALMENT; + {$EXTERNALSYM PKSAC3_ERROR_CONCEALMENT} + TKSAC3ErrorConcealment = KSAC3_ERROR_CONCEALMENT; + + PKSAC3AlternateAudio = ^TKSAC3AlternateAudio; + KSAC3_ALTERNATE_AUDIO = record + fStereo : BOOL; + DualMode : ULONG; + end; + {$EXTERNALSYM KSAC3_ALTERNATE_AUDIO} + PKSAC3_ALTERNATE_AUDIO = ^KSAC3_ALTERNATE_AUDIO; + {$EXTERNALSYM PKSAC3_ALTERNATE_AUDIO} + TKSAC3AlternateAudio = KSAC3_ALTERNATE_AUDIO; + +const + KSAC3_ALTERNATE_AUDIO_1 = 1; + {$EXTERNALSYM KSAC3_ALTERNATE_AUDIO_1} + KSAC3_ALTERNATE_AUDIO_2 = 2; + {$EXTERNALSYM KSAC3_ALTERNATE_AUDIO_2} + KSAC3_ALTERNATE_AUDIO_BOTH = 3; + {$EXTERNALSYM KSAC3_ALTERNATE_AUDIO_BOTH} + +type + PKSAC3DownMix = ^TKSAC3DownMix; + KSAC3_DOWNMIX = record + fDownMix : BOOL; + fDolbySurround : BOOL; + end; + {$EXTERNALSYM KSAC3_DOWNMIX} + PKSAC3_DOWNMIX = ^KSAC3_DOWNMIX; + {$EXTERNALSYM PKSAC3_DOWNMIX} + TKSAC3DownMix = KSAC3_DOWNMIX; + + PKSAC3BitStreamMode = ^TKSAC3BitStreamMode; + KSAC3_BIT_STREAM_MODE = record + BitStreamMode : Longint; + end; + {$EXTERNALSYM KSAC3_BIT_STREAM_MODE} + PKSAC3_BIT_STREAM_MODE = ^KSAC3_BIT_STREAM_MODE; + {$EXTERNALSYM PKSAC3_BIT_STREAM_MODE} + TKSAC3BitStreamMode = KSAC3_BIT_STREAM_MODE; + +const + KSAC3_SERVICE_MAIN_AUDIO = 0; + {$EXTERNALSYM KSAC3_SERVICE_MAIN_AUDIO} + KSAC3_SERVICE_NO_DIALOG = 1; + {$EXTERNALSYM KSAC3_SERVICE_NO_DIALOG} + KSAC3_SERVICE_VISUALLY_IMPAIRED = 2; + {$EXTERNALSYM KSAC3_SERVICE_VISUALLY_IMPAIRED} + KSAC3_SERVICE_HEARING_IMPAIRED = 3; + {$EXTERNALSYM KSAC3_SERVICE_HEARING_IMPAIRED} + KSAC3_SERVICE_DIALOG_ONLY = 4; + {$EXTERNALSYM KSAC3_SERVICE_DIALOG_ONLY} + KSAC3_SERVICE_COMMENTARY = 5; + {$EXTERNALSYM KSAC3_SERVICE_COMMENTARY} + KSAC3_SERVICE_EMERGENCY_FLASH = 6; + {$EXTERNALSYM KSAC3_SERVICE_EMERGENCY_FLASH} + KSAC3_SERVICE_VOICE_OVER = 7; + {$EXTERNALSYM KSAC3_SERVICE_VOICE_OVER} + +type + PKSAC3DialogueLevel = ^TKSAC3DialogueLevel; + KSAC3_DIALOGUE_LEVEL = record + DialogueLevel : ULONG; + end; + {$EXTERNALSYM KSAC3_DIALOGUE_LEVEL} + PKSAC3_DIALOGUE_LEVEL = ^KSAC3_DIALOGUE_LEVEL; + {$EXTERNALSYM PKSAC3_DIALOGUE_LEVEL} + TKSAC3DialogueLevel = KSAC3_DIALOGUE_LEVEL; + + PKSAC3RoomType = ^TKSAC3RoomType; + KSAC3_ROOM_TYPE = record + fLargeRoom : BOOL; + end; + {$EXTERNALSYM KSAC3_ROOM_TYPE} + PKSAC3_ROOM_TYPE = ^KSAC3_ROOM_TYPE; + {$EXTERNALSYM PKSAC3_ROOM_TYPE} + TKSAC3RoomType = KSAC3_ROOM_TYPE; + +// +// DTS and SDDS definitions (media subtype GUIDs) +// +const + KSDATAFORMAT_SUBTYPE_DTS_AUDIO : TGUID = '{e06d8033-db46-11cf-b4d1-00805f6cbbea}'; + {$EXTERNALSYM KSDATAFORMAT_SUBTYPE_DTS_AUDIO} + KSDATAFORMAT_SUBTYPE_SDDS_AUDIO : TGUID = '{e06d8034-db46-11cf-b4d1-00805f6cbbea}'; + {$EXTERNALSYM KSDATAFORMAT_SUBTYPE_SDDS_AUDIO} + +// +// audio decoder output properties +// + + KSPROPSETID_AudioDecoderOut : TGUID = '{6ca6e020-43bd-11d0-bd6a-003505c103a9}'; + {$EXTERNALSYM KSPROPSETID_AudioDecoderOut} + +type + KSPROPERTY_AUDDECOUT = ( + KSPROPERTY_AUDDECOUT_MODES, // available output modes of decoder + KSPROPERTY_AUDDECOUT_CUR_MODE // current mode of the decoder + ); + {$EXTERNALSYM KSPROPERTY_AUDDECOUT} + TKSPropertyAuddecout = KSPROPERTY_AUDDECOUT; + +const + KSAUDDECOUTMODE_STEREO_ANALOG = $0001; + {$EXTERNALSYM KSAUDDECOUTMODE_STEREO_ANALOG} + KSAUDDECOUTMODE_PCM_51 = $0002; + {$EXTERNALSYM KSAUDDECOUTMODE_PCM_51} + KSAUDDECOUTMODE_SPDIFF = $0004; + {$EXTERNALSYM KSAUDDECOUTMODE_SPDIFF} + +// +// subpicture definition +// + + KSDATAFORMAT_SUBTYPE_SUBPICTURE : TGUID = '{e06d802d-db46-11cf-b4d1-00805f6cbbea}'; + {$EXTERNALSYM KSDATAFORMAT_SUBTYPE_SUBPICTURE} + KSPROPSETID_DvdSubPic : TGUID = '{ac390460-43af-11d0-bd6a-003505c103a9}'; + {$EXTERNALSYM KSPROPSETID_DvdSubPic} + +type + KSPROPERTY_DVDSUBPIC = ( + KSPROPERTY_DVDSUBPIC_PALETTE, + KSPROPERTY_DVDSUBPIC_HLI, + KSPROPERTY_DVDSUBPIC_COMPOSIT_ON // TRUE for subpicture is displayed + ); + {$EXTERNALSYM KSPROPERTY_DVDSUBPIC} + TKSPropertyDVDSubPic = KSPROPERTY_DVDSUBPIC; + + PKSDVDYCrCb = ^TKSDVDYCrCb; + _KS_DVD_YCrCb = record + Reserved : byte; + Y : byte; + Cr : byte; + Cb : byte; + end; + {$EXTERNALSYM _KS_DVD_YCrCb} + KS_DVD_YCrCb = _KS_DVD_YCrCb; + {$EXTERNALSYM KS_DVD_YCrCb} + PKS_DVD_YCrCb = ^KS_DVD_YCrCb; + {$EXTERNALSYM PKS_DVD_YCrCb} + TKSDVDYCrCb = _KS_DVD_YCrCb; + +// The KS_DVD_YUV structure is now superseded by KS_DVD_YCrCb above and is +// here for backward compatibility only + + PKSDVDYUV = ^TKSDVDYUV; + _KS_DVD_YUV = record + Reserved : byte; + Y : byte; + V : byte; + U : byte; + end; + {$EXTERNALSYM _KS_DVD_YUV} + KS_DVD_YUV = _KS_DVD_YUV; + {$EXTERNALSYM KS_DVD_YUV} + PKS_DVD_YUV = ^KS_DVD_YUV; + {$EXTERNALSYM PKS_DVD_YUV} + TKSDVDYUV = _KS_DVD_YUV; + + PKSPropertySPPAL = ^TKSPropertySPPAL; + _KSPROPERTY_SPPAL = record + sppal : array[0..15] of TKSDVDYUV; + end; + {$EXTERNALSYM _KSPROPERTY_SPPAL} + KSPROPERTY_SPPAL = _KSPROPERTY_SPPAL; + {$EXTERNALSYM KSPROPERTY_SPPAL} + PKSPROPERTY_SPPAL = ^KSPROPERTY_SPPAL; + {$EXTERNALSYM PKSPROPERTY_SPPAL} + TKSPropertySPPAL = _KSPROPERTY_SPPAL; + + PKSColCon = ^TKSColCon; + _KS_COLCON = record + emph1col : byte; //:4; + emph2col : byte; //:4; + backcol : byte; //:4; + patcol : byte; //:4; + emph1con : byte; //:4; + emph2con : byte; //:4; + backcon : byte; //:4; + patcon : byte; //:4; + end; + {$EXTERNALSYM _KS_COLCON} + KS_COLCON = _KS_COLCON; + {$EXTERNALSYM KS_COLCON} + PKS_COLCON = ^KS_COLCON; + {$EXTERNALSYM PKS_COLCON} + TKSColCon = _KS_COLCON; + + PKSPropertySPHLI = ^TKSPropertySPHLI; + _KSPROPERTY_SPHLI = record + HLISS : WORD; + Reserved : WORD; + StartPTM : ULONG; // start presentation time in x/90000 + EndPTM : ULONG; // end PTM in x/90000 + StartX : WORD; + StartY : WORD; + StopX : WORD; + StopY : WORD; + ColCon : TKSColCon; // color contrast description (4 bytes as given in HLI) + end; + {$EXTERNALSYM _KSPROPERTY_SPHLI} + KSPROPERTY_SPHLI = _KSPROPERTY_SPHLI; + {$EXTERNALSYM KSPROPERTY_SPHLI} + PKSPROPERTY_SPHLI = ^KSPROPERTY_SPHLI; + {$EXTERNALSYM PKSPROPERTY_SPHLI} + TKSPropertySPHLI = _KSPROPERTY_SPHLI; + + PKSPROPERTY_COMPOSIT_ON = ^KSPROPERTY_COMPOSIT_ON; + {$EXTERNALSYM PKSPROPERTY_COMPOSIT_ON} + KSPROPERTY_COMPOSIT_ON = {$IFDEF TYPE_IDENTITY}type {$ENDIF} BOOL; + {$EXTERNALSYM KSPROPERTY_COMPOSIT_ON} + +const + KSPROPSETID_CopyProt : TGUID = '{0E8A0A40-6AEF-11D0-9ED0-00A024CA19B3}'; + {$EXTERNALSYM KSPROPSETID_CopyProt} + +type + KSPROPERTY_COPYPROT = {$IFDEF TYPE_IDENTITY}type {$ENDIF} LongWord; + {$EXTERNALSYM KSPROPERTY_COPYPROT} + const + KSPROPERTY_DVDCOPY_CHLG_KEY = $01; + {$EXTERNALSYM KSPROPERTY_DVDCOPY_CHLG_KEY} + KSPROPERTY_DVDCOPY_DVD_KEY1 = $02; + {$EXTERNALSYM KSPROPERTY_DVDCOPY_DVD_KEY1} + KSPROPERTY_DVDCOPY_DEC_KEY2 = $03; + {$EXTERNALSYM KSPROPERTY_DVDCOPY_DEC_KEY2} + KSPROPERTY_DVDCOPY_TITLE_KEY = $04; + {$EXTERNALSYM KSPROPERTY_DVDCOPY_TITLE_KEY} + KSPROPERTY_COPY_MACROVISION = $05; + {$EXTERNALSYM KSPROPERTY_COPY_MACROVISION} + KSPROPERTY_DVDCOPY_REGION = $06; + {$EXTERNALSYM KSPROPERTY_DVDCOPY_REGION} + KSPROPERTY_DVDCOPY_SET_COPY_STATE = $07; + {$EXTERNALSYM KSPROPERTY_DVDCOPY_SET_COPY_STATE} + KSPROPERTY_DVDCOPY_DISC_KEY = $80; + {$EXTERNALSYM KSPROPERTY_DVDCOPY_DISC_KEY} + +type + PKSDVDCopyCHLGKey = ^TKSDVDCopyCHLGKey; + _KS_DVDCOPY_CHLGKEY = record + ChlgKey : array[0..9] of BYTE; + Reserved : array[0..1] of BYTE; + end; + {$EXTERNALSYM _KS_DVDCOPY_CHLGKEY} + KS_DVDCOPY_CHLGKEY = _KS_DVDCOPY_CHLGKEY; + {$EXTERNALSYM KS_DVDCOPY_CHLGKEY} + PKS_DVDCOPY_CHLGKEY = ^KS_DVDCOPY_CHLGKEY; + {$EXTERNALSYM PKS_DVDCOPY_CHLGKEY} + TKSDVDCopyCHLGKey = _KS_DVDCOPY_CHLGKEY; + + PKSDVDCopyBusKey = ^TKSDVDCopyBusKey; + _KS_DVDCOPY_BUSKEY = record + BusKey : array[0..4] of BYTE; + Reserved : array[0..0] of BYTE; + end; + {$EXTERNALSYM _KS_DVDCOPY_BUSKEY} + KS_DVDCOPY_BUSKEY = _KS_DVDCOPY_BUSKEY; + {$EXTERNALSYM KS_DVDCOPY_BUSKEY} + PKS_DVDCOPY_BUSKEY = ^KS_DVDCOPY_BUSKEY; + {$EXTERNALSYM PKS_DVDCOPY_BUSKEY} + TKSDVDCopyBusKey = _KS_DVDCOPY_BUSKEY; + + PKSDVDCopyDiscKey = ^TKSDVDCopyDiscKey; + _KS_DVDCOPY_DISCKEY = record + DiscKey : array[0..2047] of BYTE; + end; + {$EXTERNALSYM _KS_DVDCOPY_DISCKEY} + KS_DVDCOPY_DISCKEY = _KS_DVDCOPY_DISCKEY; + {$EXTERNALSYM KS_DVDCOPY_DISCKEY} + PKS_DVDCOPY_DISCKEY = ^KS_DVDCOPY_DISCKEY; + {$EXTERNALSYM PKS_DVDCOPY_DISCKEY} + TKSDVDCopyDiscKey = _KS_DVDCOPY_DISCKEY; + + PKSDVDCopyRegion = ^TKSDVDCopyRegion; + _KS_DVDCOPY_REGION = record + Reserved : UCHAR; + RegionData : UCHAR; + Reserved2 : array[0..1] of UCHAR; + end; + {$EXTERNALSYM _KS_DVDCOPY_REGION} + KS_DVDCOPY_REGION = _KS_DVDCOPY_REGION; + {$EXTERNALSYM KS_DVDCOPY_REGION} + PKS_DVDCOPY_REGION = ^KS_DVDCOPY_REGION; + {$EXTERNALSYM PKS_DVDCOPY_REGION} + TKSDVDCopyRegion = _KS_DVDCOPY_REGION; + + PKSDVDCopyTitleKey = ^TKSDVDCopyTitleKey; + _KS_DVDCOPY_TITLEKEY = record + KeyFlags : ULONG; + ReservedNT : array[0..1] of ULONG; + TitleKey : array[0..5] of UCHAR; + Reserved : array[0..1] of UCHAR; + end; + {$EXTERNALSYM _KS_DVDCOPY_TITLEKEY} + KS_DVDCOPY_TITLEKEY = _KS_DVDCOPY_TITLEKEY; + {$EXTERNALSYM KS_DVDCOPY_TITLEKEY} + PKS_DVDCOPY_TITLEKEY = ^KS_DVDCOPY_TITLEKEY; + {$EXTERNALSYM PKS_DVDCOPY_TITLEKEY} + TKSDVDCopyTitleKey = _KS_DVDCOPY_TITLEKEY; + + PKSCopyMacrovision = ^TKSCopyMacrovision; + _KS_COPY_MACROVISION = record + MACROVISIONLevel : ULONG; + end; + {$EXTERNALSYM _KS_COPY_MACROVISION} + KS_COPY_MACROVISION = _KS_COPY_MACROVISION; + {$EXTERNALSYM KS_COPY_MACROVISION} + PKS_COPY_MACROVISION = ^KS_COPY_MACROVISION; + {$EXTERNALSYM PKS_COPY_MACROVISION} + TKSCopyMacrovision = _KS_COPY_MACROVISION; + + PKSDVDCopySetCopyState = ^TKSDVDCopySetCopyState; + _KS_DVDCOPY_SET_COPY_STATE = record + DVDCopyState : ULONG; + end; + {$EXTERNALSYM _KS_DVDCOPY_SET_COPY_STATE} + KS_DVDCOPY_SET_COPY_STATE = _KS_DVDCOPY_SET_COPY_STATE; + {$EXTERNALSYM KS_DVDCOPY_SET_COPY_STATE} + PKS_DVDCOPY_SET_COPY_STATE = ^KS_DVDCOPY_SET_COPY_STATE; + {$EXTERNALSYM PKS_DVDCOPY_SET_COPY_STATE} + TKSDVDCopySetCopyState = _KS_DVDCOPY_SET_COPY_STATE; + + KS_DVDCOPYSTATE = ( + KS_DVDCOPYSTATE_INITIALIZE, // indicates we are starting a full + // copy protection sequence. + KS_DVDCOPYSTATE_INITIALIZE_TITLE, // indicates we are starting a title + // key copy protection sequence + KS_DVDCOPYSTATE_AUTHENTICATION_NOT_REQUIRED, + KS_DVDCOPYSTATE_AUTHENTICATION_REQUIRED, + KS_DVDCOPYSTATE_DONE + ); + {$EXTERNALSYM KS_DVDCOPYSTATE} + TKSDVDCopyState = KS_DVDCOPYSTATE; + + PKSCopyMacrovisionLevel = ^TKSCopyMacrovisionLevel; + KS_COPY_MACROVISION_LEVEL = ( + KS_MACROVISION_DISABLED, + KS_MACROVISION_LEVEL1, + KS_MACROVISION_LEVEL2, + KS_MACROVISION_LEVEL3 + ); + {$EXTERNALSYM KS_COPY_MACROVISION_LEVEL} + PKS_COPY_MACROVISION_LEVEL = ^KS_COPY_MACROVISION_LEVEL; + {$EXTERNALSYM PKS_COPY_MACROVISION_LEVEL} + TKSCopyMacrovisionLevel = KS_COPY_MACROVISION_LEVEL; + + +// +// CGMS Copy Protection Flags +// +const + KS_DVD_CGMS_RESERVED_MASK = $00000078; + {$EXTERNALSYM KS_DVD_CGMS_RESERVED_MASK} + + KS_DVD_CGMS_COPY_PROTECT_MASK = $00000018; + {$EXTERNALSYM KS_DVD_CGMS_COPY_PROTECT_MASK} + KS_DVD_CGMS_COPY_PERMITTED = $00000000; + {$EXTERNALSYM KS_DVD_CGMS_COPY_PERMITTED} + KS_DVD_CGMS_COPY_ONCE = $00000010; + {$EXTERNALSYM KS_DVD_CGMS_COPY_ONCE} + KS_DVD_CGMS_NO_COPY = $00000018; + {$EXTERNALSYM KS_DVD_CGMS_NO_COPY} + + KS_DVD_COPYRIGHT_MASK = $00000040; + {$EXTERNALSYM KS_DVD_COPYRIGHT_MASK} + KS_DVD_NOT_COPYRIGHTED = $00000000; + {$EXTERNALSYM KS_DVD_NOT_COPYRIGHTED} + KS_DVD_COPYRIGHTED = $00000040; + {$EXTERNALSYM KS_DVD_COPYRIGHTED} + + KS_DVD_SECTOR_PROTECT_MASK = $00000020; + {$EXTERNALSYM KS_DVD_SECTOR_PROTECT_MASK} + KS_DVD_SECTOR_NOT_PROTECTED = $00000000; + {$EXTERNALSYM KS_DVD_SECTOR_NOT_PROTECTED} + KS_DVD_SECTOR_PROTECTED = $00000020; + {$EXTERNALSYM KS_DVD_SECTOR_PROTECTED} + +//=========================================================================== +// The following MUST match the structures in WinGDI.h and AMVideo.h +//=========================================================================== + + KSCATEGORY_TVTUNER : TGUID = '{a799a800-a46d-11d0-a18c-00a02401dcd4}'; + {$EXTERNALSYM KSCATEGORY_TVTUNER} + KSCATEGORY_CROSSBAR : TGUID = '{a799a801-a46d-11d0-a18c-00a02401dcd4}'; + {$EXTERNALSYM KSCATEGORY_CROSSBAR} + KSCATEGORY_TVAUDIO : TGUID = '{a799a802-a46d-11d0-a18c-00a02401dcd4}'; + {$EXTERNALSYM KSCATEGORY_TVAUDIO} + KSCATEGORY_VPMUX : TGUID = '{a799a803-a46d-11d0-a18c-00a02401dcd4}'; + {$EXTERNALSYM KSCATEGORY_VPMUX} + KSCATEGORY_VBICODEC : TGUID = '{07dad660-22f1-11d1-a9f4-00c04fbbde8f}'; + {$EXTERNALSYM KSCATEGORY_VBICODEC} + + // SUBTYPE_VPVideo + KSDATAFORMAT_SUBTYPE_VPVideo : TGUID = '{5a9b6a40-1a22-11d1-bad9-00609744111a}'; + {$EXTERNALSYM KSDATAFORMAT_SUBTYPE_VPVideo} + + // SUBTYPE_VPVBI + KSDATAFORMAT_SUBTYPE_VPVBI : TGUID = '{5a9b6a41-1a22-11d1-bad9-00609744111a}'; + {$EXTERNALSYM KSDATAFORMAT_SUBTYPE_VPVBI} + + // FORMAT_VideoInfo + KSDATAFORMAT_SPECIFIER_VIDEOINFO : TGUID = '{05589f80-c356-11ce-bf01-00aa0055595a}'; + {$EXTERNALSYM KSDATAFORMAT_SPECIFIER_VIDEOINFO} + + // FORMAT_VideoInfo2 + KSDATAFORMAT_SPECIFIER_VIDEOINFO2 : TGUID = '{f72a76A0-eb0a-11d0-ace4-0000c0cc16ba}'; + {$EXTERNALSYM KSDATAFORMAT_SPECIFIER_VIDEOINFO2} + + // MEDIATYPE_AnalogVideo + KSDATAFORMAT_TYPE_ANALOGVIDEO : TGUID = '{0482dde1-7817-11cf-8a03-00aa006ecb65}'; + {$EXTERNALSYM KSDATAFORMAT_TYPE_ANALOGVIDEO} + + // FORMAT_AnalogVideo + KSDATAFORMAT_SPECIFIER_ANALOGVIDEO : TGUID = '{0482dde0-7817-11cf-8a03-00aa006ecb65}'; + {$EXTERNALSYM KSDATAFORMAT_SPECIFIER_ANALOGVIDEO} + + // FORMAT_VBI + KSDATAFORMAT_SPECIFIER_VBI : TGUID = '{f72a76e0-eb0a-11d0-ace4-0000c0cc16ba}'; + {$EXTERNALSYM KSDATAFORMAT_SPECIFIER_VBI} + + // MEDIATYPE_VBI + KSDATAFORMAT_TYPE_VBI : TGUID = '{f72a76e1-eb0a-11d0-ace4-0000c0cc16ba}'; + {$EXTERNALSYM KSDATAFORMAT_TYPE_VBI} + + // SUBTYPE_RAW8 + KSDATAFORMAT_SUBTYPE_RAW8 : TGUID = '{ca20d9a0-3e3e-11d1-9bf9-00c04fbbdebf}'; + {$EXTERNALSYM KSDATAFORMAT_SUBTYPE_RAW8} + + // MEDIASUBTYPE_CC + KSDATAFORMAT_SUBTYPE_CC : TGUID = '{33214CC1-011F-11D2-B4B1-00A0D102CFBE}'; + {$EXTERNALSYM KSDATAFORMAT_SUBTYPE_CC} + + // MEDIASUBTYPE_NABTS + KSDATAFORMAT_SUBTYPE_NABTS : TGUID = '{f72a76e2-eb0a-11d0-ace4-0000c0cc16ba}'; + {$EXTERNALSYM KSDATAFORMAT_SUBTYPE_NABTS} + + // MEDIASUBTYPE_TELETEXT + KSDATAFORMAT_SUBTYPE_TELETEXT : TGUID = '{f72a76e3-eb0a-11d0-ace4-0000c0cc16ba}'; + {$EXTERNALSYM KSDATAFORMAT_SUBTYPE_TELETEXT} + + +// constants for the biCompression field + KS_BI_RGB = 0; + {$EXTERNALSYM KS_BI_RGB} + KS_BI_RLE8 = 1; + {$EXTERNALSYM KS_BI_RLE8} + KS_BI_RLE4 = 2; + {$EXTERNALSYM KS_BI_RLE4} + KS_BI_BITFIELDS = 3; + {$EXTERNALSYM KS_BI_BITFIELDS} + +type + PKSRGBQuad = ^TKSRGBQuad; + tagKS_RGBQUAD = record // rgbq + rgbBlue : BYTE; + rgbGreen : BYTE; + rgbRed : BYTE; + rgbReserved : BYTE; + end; + {$EXTERNALSYM tagKS_RGBQUAD} + KS_RGBQUAD = tagKS_RGBQUAD; + {$EXTERNALSYM KS_RGBQUAD} + PKS_RGBQUAD = ^KS_RGBQUAD; + {$EXTERNALSYM PKS_RGBQUAD} + TKSRGBQuad = tagKS_RGBQUAD; + +// constants for palettes +const + KS_iPALETTE_COLORS = 256; // Maximum colours in palette + {$EXTERNALSYM KS_iPALETTE_COLORS} + KS_iEGA_COLORS = 16; // Number colours in EGA palette + {$EXTERNALSYM KS_iEGA_COLORS} + KS_iMASK_COLORS = 3; // Maximum three components + {$EXTERNALSYM KS_iMASK_COLORS} + KS_iTRUECOLOR = 16; // Minimum true colour device + {$EXTERNALSYM KS_iTRUECOLOR} + KS_iRED = 0; // Index position for RED mask + {$EXTERNALSYM KS_iRED} + KS_iGREEN = 1; // Index position for GREEN mask + {$EXTERNALSYM KS_iGREEN} + KS_iBLUE = 2; // Index position for BLUE mask + {$EXTERNALSYM KS_iBLUE} + KS_iPALETTE = 8; // Maximum colour depth using a palette + {$EXTERNALSYM KS_iPALETTE} + KS_iMAXBITS = 8; // Maximum bits per colour component + {$EXTERNALSYM KS_iMAXBITS} + KS_SIZE_EGA_PALETTE = (KS_iEGA_COLORS * sizeof(TKSRGBQUAD)); + {$EXTERNALSYM KS_SIZE_EGA_PALETTE} + KS_SIZE_PALETTE = (KS_iPALETTE_COLORS * sizeof(TKSRGBQUAD)); + {$EXTERNALSYM KS_SIZE_PALETTE} + +type + PKSBitmapInfoHeader = ^TKSBitmapInfoHeader; + tagKS_BITMAPINFOHEADER = record + biSize : DWORD; + biWidth : longint; + biHeight : longint; + biPlanes : WORD; + biBitCount : WORD; + biCompression : DWORD; + biSizeImage : DWORD; + biXPelsPerMeter : longint; + biYPelsPerMeter : longint; + biClrUsed : DWORD; + biClrImportant : DWORD; + end; + {$EXTERNALSYM tagKS_BITMAPINFOHEADER} + KS_BITMAPINFOHEADER = tagKS_BITMAPINFOHEADER; + {$EXTERNALSYM KS_BITMAPINFOHEADER} + PKS_BITMAPINFOHEADER = ^KS_BITMAPINFOHEADER; + {$EXTERNALSYM PKS_BITMAPINFOHEADER} + TKSBitmapInfoHeader = tagKS_BITMAPINFOHEADER; + +// Used for true colour images that also have a palette + + PKSTrueColorInfo = ^TKSTrueColorInfo; + tag_KS_TRUECOLORINFO = record + dwBitMasks : array[0..KS_iMASK_COLORS-1] of DWORD; + bmiColors : array[0..KS_iPALETTE_COLORS-1] of TKSRGBQUAD; + end; + {$EXTERNALSYM tag_KS_TRUECOLORINFO} + KS_TRUECOLORINFO = tag_KS_TRUECOLORINFO; + {$EXTERNALSYM KS_TRUECOLORINFO} + PKS_TRUECOLORINFO = ^KS_TRUECOLORINFO; + {$EXTERNALSYM PKS_TRUECOLORINFO} + TKSTrueColorInfo = tag_KS_TRUECOLORINFO; + +// KS_WIDTHBYTES(bits) ((DWORD)(((bits)+31) & (~31)) / 8) +// KS_DIBWIDTHBYTES(bi) (DWORD)KS_WIDTHBYTES((DWORD)(bi).biWidth * (DWORD)(bi).biBitCount) +// KS__DIBSIZE(bi) (KS_DIBWIDTHBYTES(bi) * (DWORD)(bi).biHeight) +// KS_DIBSIZE(bi) ((bi).biHeight < 0 ? (-1)*(KS__DIBSIZE(bi)) : KS__DIBSIZE(bi)) + +// typedef REFERENCE_TIME: int64; + +// The BITMAPINFOHEADER contains all the details about the video stream such +// as the actual image dimensions and their pixel depth. A source filter may +// also request that the sink take only a section of the video by providing a +// clipping rectangle in rcSource. In the worst case where the sink filter +// forgets to check this on connection it will simply render the whole thing +// which isn't a disaster. Ideally a sink filter will check the rcSource and +// if it doesn't support image extraction and the rectangle is not empty then +// it will reject the connection. A filter should use SetRectEmpty to reset a +// rectangle to all zeroes (and IsRectEmpty to later check the rectangle). +// The rcTarget specifies the destination rectangle for the video, for most +// source filters they will set this to all zeroes, a downstream filter may +// request that the video be placed in a particular area of the buffers it +// supplies in which case it will call QueryAccept with a non empty target + + PKSVideoInfoHeader = ^TKSVideoInfoHeader; + tagKS_VIDEOINFOHEADER = record + rcSource : TRECT; // The bit we really want to use + rcTarget : TRECT; // Where the video should go + dwBitRate : DWORD; // Approximate bit data rate + dwBitErrorRate : DWORD; // Bit error rate for this stream + AvgTimePerFrame : TReferenceTime; // Average time per frame (100ns units) + bmiHeader : TKSBitmapInfoHeader; + end; + {$EXTERNALSYM tagKS_VIDEOINFOHEADER} + KS_VIDEOINFOHEADER = tagKS_VIDEOINFOHEADER; + {$EXTERNALSYM KS_VIDEOINFOHEADER} + PKS_VIDEOINFOHEADER = ^KS_VIDEOINFOHEADER; + {$EXTERNALSYM PKS_VIDEOINFOHEADER} + TKSVideoInfoHeader = tagKS_VIDEOINFOHEADER; + +// !!! WARNING !!! +// DO NOT use the following structure unless you are sure that the BITMAPINFOHEADER +// has a normal biSize == sizeof(BITMAPINFOHEADER) ! +// !!! WARNING !!! + + PKSVideoInfo = ^TKSVideoInfo; + tagKS_VIDEOINFO = record + rcSource : TRECT; // The bit we really want to use + rcTarget : TRECT; // Where the video should go + dwBitRate : DWORD; // Approximate bit data rate + dwBitErrorRate : DWORD; // Bit error rate for this stream + AvgTimePerFrame : TReferenceTime; // Average time per frame (100ns units) + bmiHeader : TKSBitmapInfoHeader; + case integer of + 0: (bmiColors : array[0..KS_iPALETTE_COLORS-1] of TKSRGBQUAD); // Colour palette + 1: (dwBitMasks : array[0..KS_iMASK_COLORS-1] of DWORD); // True colour masks + 2: (TrueColorInfo : TKSTrueColorInfo); // Both of the above + end; + {$EXTERNALSYM tagKS_VIDEOINFO} + KS_VIDEOINFO = tagKS_VIDEOINFO; + {$EXTERNALSYM KS_VIDEOINFO} + PKS_VIDEOINFO = ^KS_VIDEOINFO; + {$EXTERNALSYM PKS_VIDEOINFO} + TKSVideoInfo = tagKS_VIDEOINFO; + +const + KS_SIZE_MASKS = (KS_iMASK_COLORS * sizeof(DWORD)); + {$EXTERNALSYM KS_SIZE_MASKS} +// KS_SIZE_PREHEADER = (FIELD_OFFSET(KS_VIDEOINFOHEADER,bmiHeader)) + +// For normal size +// #define KS_SIZE_VIDEOHEADER (sizeof(KS_BITMAPINFOHEADER) + KS_SIZE_PREHEADER) +// !!! for abnormal biSizes +//#define KS_SIZE_VIDEOHEADER(pbmi) ((pbmi)->bmiHeader.biSize + KS_SIZE_PREHEADER) + +// VBI +// Used for NABTS, CC, Intercast, +type + PKSVBIInfoHeader = ^TKSVBIInfoHeader; + tagKS_VBIINFOHEADER = record + StartLine : ULONG; // inclusive + EndLine : ULONG; // inclusive + SamplingFrequency : ULONG; // Hz. + MinLineStartTime : ULONG; // microSec * 100 from HSync LE + MaxLineStartTime : ULONG; // microSec * 100 from HSync LE + ActualLineStartTime : ULONG; // microSec * 100 from HSync LE + ActualLineEndTime : ULONG; // microSec * 100 from HSync LE + VideoStandard : ULONG; // KS_AnalogVideoStandard* + SamplesPerLine : ULONG; + StrideInBytes : ULONG; // May be > SamplesPerLine + BufferSize : ULONG; // Bytes + end; + {$EXTERNALSYM tagKS_VBIINFOHEADER} + KS_VBIINFOHEADER = tagKS_VBIINFOHEADER; + {$EXTERNALSYM KS_VBIINFOHEADER} + PKS_VBIINFOHEADER = ^KS_VBIINFOHEADER; + {$EXTERNALSYM PKS_VBIINFOHEADER} + TKSVBIInfoHeader = tagKS_VBIINFOHEADER; + +// VBI Sampling Rates +const + KS_VBIDATARATE_NABTS = 5727272; + {$EXTERNALSYM KS_VBIDATARATE_NABTS} + KS_VBIDATARATE_CC = 503493; // ~= 1/1.986125e-6 + {$EXTERNALSYM KS_VBIDATARATE_CC} + KS_VBISAMPLINGRATE_4X_NABTS = longint(4*KS_VBIDATARATE_NABTS); + {$EXTERNALSYM KS_VBISAMPLINGRATE_4X_NABTS} + KS_VBISAMPLINGRATE_47X_NABTS = longint(27000000); + {$EXTERNALSYM KS_VBISAMPLINGRATE_47X_NABTS} + KS_VBISAMPLINGRATE_5X_NABTS = longint(5*KS_VBIDATARATE_NABTS); + {$EXTERNALSYM KS_VBISAMPLINGRATE_5X_NABTS} + + KS_47NABTS_SCALER = KS_VBISAMPLINGRATE_47X_NABTS/KS_VBIDATARATE_NABTS; + {$EXTERNALSYM KS_47NABTS_SCALER} + +// Analog video variant - Use this when the format is FORMAT_AnalogVideo +// +// rcSource defines the portion of the active video signal to use +// rcTarget defines the destination rectangle +// both of the above are relative to the dwActiveWidth and dwActiveHeight fields +// dwActiveWidth is currently set to 720 for all formats (but could change for HDTV) +// dwActiveHeight is 483 for NTSC and 575 for PAL/SECAM (but could change for HDTV) +type + PKSAnalogVideoInfo = ^TKSAnalogVideoInfo; + tagKS_AnalogVideoInfo = record + rcSource : TRECT; // Width max is 720, height varies w/ TransmissionStd + rcTarget : TRECT; // Where the video should go + dwActiveWidth : DWORD; // Always 720 (CCIR-601 active samples per line) + dwActiveHeight : DWORD; // 483 for NTSC, 575 for PAL/SECAM + AvgTimePerFrame : TReferenceTime; // Normal ActiveMovie units (100 nS) + end; + {$EXTERNALSYM tagKS_AnalogVideoInfo} + KS_AnalogVideoInfo = tagKS_AnalogVideoInfo; + {$EXTERNALSYM KS_ANALOGVIDEOINFO} + PKS_ANALOGVIDEOINFO = ^KS_ANALOGVIDEOINFO; + {$EXTERNALSYM PKS_ANALOGVIDEOINFO} + TKSAnalogVideoInfo = tagKS_AnalogVideoInfo; + +//=========================================================================== +// Data packet passed on Analog video stream channel change +//=========================================================================== +const + KS_TVTUNER_CHANGE_BEGIN_TUNE = $0001; // Starting a tuning operation + {$EXTERNALSYM KS_TVTUNER_CHANGE_BEGIN_TUNE} + KS_TVTUNER_CHANGE_END_TUNE = $0002; // Ending a tuning operation + {$EXTERNALSYM KS_TVTUNER_CHANGE_END_TUNE} + +type + PKSTVTunerChangeInfo = ^TKSTVTunerChangeInfo; + tagKS_TVTUNER_CHANGE_INFO = record + dwFlags : DWORD; // KS_TVTUNER_CHANGE_* + dwCountryCode : DWORD; + dwAnalogVideoStandard : DWORD; // KS_AnalogVideoStandard + dwChannel : DWORD; + end; + {$EXTERNALSYM tagKS_TVTUNER_CHANGE_INFO} + KS_TVTUNER_CHANGE_INFO = tagKS_TVTUNER_CHANGE_INFO; + {$EXTERNALSYM KS_TVTUNER_CHANGE_INFO} + PKS_TVTUNER_CHANGE_INFO = ^KS_TVTUNER_CHANGE_INFO; + {$EXTERNALSYM PKS_TVTUNER_CHANGE_INFO} + TKSTVTunerChangeInfo = tagKS_TVTUNER_CHANGE_INFO; + +//=========================================================================== +// Video format blocks +//=========================================================================== + + KS_MPEG2Level = ( + KS_MPEG2Level_Low, + KS_MPEG2Level_Main, + KS_MPEG2Level_High1440, + KS_MPEG2Level_High + ); + {$EXTERNALSYM KS_MPEG2Level} + TKSMPEG2Level = KS_MPEG2Level; + + KS_MPEG2Profile = ( + KS_MPEG2Profile_Simple, + KS_MPEG2Profile_Main, + KS_MPEG2Profile_SNRScalable, + KS_MPEG2Profile_SpatiallyScalable, + KS_MPEG2Profile_High + ); + {$EXTERNALSYM KS_MPEG2Profile} + TKSMPEG2Profile = KS_MPEG2Profile; + +const + KS_INTERLACE_IsInterlaced = $00000001; // if 0, other interlace bits are irrelevent + {$EXTERNALSYM KS_INTERLACE_IsInterlaced} + KS_INTERLACE_1FieldPerSample = $00000002; // else 2 fields per media sample + {$EXTERNALSYM KS_INTERLACE_1FieldPerSample} + KS_INTERLACE_Field1First = $00000004; // else Field 2 is first; top field in PAL is field 1, top field in NTSC is field 2? + {$EXTERNALSYM KS_INTERLACE_Field1First} + KS_INTERLACE_UNUSED = $00000008; // + {$EXTERNALSYM KS_INTERLACE_UNUSED} + KS_INTERLACE_FieldPatternMask = $00000030; // use this mask with AMINTERLACE_FieldPat* + {$EXTERNALSYM KS_INTERLACE_FieldPatternMask} + KS_INTERLACE_FieldPatField1Only = $00000000; // Data never contains a Field2 + {$EXTERNALSYM KS_INTERLACE_FieldPatField1Only} + KS_INTERLACE_FieldPatField2Only = $00000010; // Data never contains a Field1 + {$EXTERNALSYM KS_INTERLACE_FieldPatField2Only} + KS_INTERLACE_FieldPatBothRegular = $00000020; // There will be a Field2 for every Field1 (required for Weave?) + {$EXTERNALSYM KS_INTERLACE_FieldPatBothRegular} + KS_INTERLACE_FieldPatBothIrregular = $00000030; // Random pattern of Field1s and Field2s + {$EXTERNALSYM KS_INTERLACE_FieldPatBothIrregular} + KS_INTERLACE_DisplayModeMask = $000000c0; + {$EXTERNALSYM KS_INTERLACE_DisplayModeMask} + KS_INTERLACE_DisplayModeBobOnly = $00000000; + {$EXTERNALSYM KS_INTERLACE_DisplayModeBobOnly} + KS_INTERLACE_DisplayModeWeaveOnly = $00000040; + {$EXTERNALSYM KS_INTERLACE_DisplayModeWeaveOnly} + KS_INTERLACE_DisplayModeBobOrWeave = $00000080; + {$EXTERNALSYM KS_INTERLACE_DisplayModeBobOrWeave} + + + + KS_MPEG2_DoPanScan = $00000001; //if set, the MPEG-2 video decoder should crop output image + {$EXTERNALSYM KS_MPEG2_DoPanScan} // based on pan-scan vectors in picture_display_extension + // and change the picture aspect ratio accordingly. + KS_MPEG2_DVDLine21Field1 = $00000002; //if set, the MPEG-2 decoder must be able to produce an output + {$EXTERNALSYM KS_MPEG2_DVDLine21Field1} // pin for DVD style closed caption data found in GOP layer of field 1 + KS_MPEG2_DVDLine21Field2 = $00000004; //if set, the MPEG-2 decoder must be able to produce an output + {$EXTERNALSYM KS_MPEG2_DVDLine21Field2} // pin for DVD style closed caption data found in GOP layer of field 2 + KS_MPEG2_SourceIsLetterboxed = $00000008; //if set, indicates that black bars have been encoded in the top + {$EXTERNALSYM KS_MPEG2_SourceIsLetterboxed} // and bottom of the video. + KS_MPEG2_FilmCameraMode = $00000010; //if set, indicates "film mode" used for 625/50 content. If cleared, + {$EXTERNALSYM KS_MPEG2_FilmCameraMode} // indicates that "camera mode" was used. + KS_MPEG2_LetterboxAnalogOut = $00000020; //if set and this stream is sent to an analog output, it should + {$EXTERNALSYM KS_MPEG2_LetterboxAnalogOut} + // be letterboxed. Streams sent to VGA should be letterboxed only by renderers. + KS_MPEG2_DSS_UserData = $00000040; //if set, the MPEG-2 decoder must process DSS style user data + {$EXTERNALSYM KS_MPEG2_DSS_UserData} + KS_MPEG2_DVB_UserData = $00000080; //if set, the MPEG-2 decoder must process DVB style user data + {$EXTERNALSYM KS_MPEG2_DVB_UserData} + KS_MPEG2_27MhzTimebase = $00000100; //if set, the PTS,DTS timestamps advance at 27MHz rather than 90KHz + {$EXTERNALSYM KS_MPEG2_27MhzTimebase} + +type + PKSVideoInfoHeader2 = ^TKSVideoInfoHeader2; + tagKS_VIDEOINFOHEADER2 = record + rcSource : TRECT; + rcTarget : TRECT; + dwBitRate : DWORD; + dwBitErrorRate : DWORD; + AvgTimePerFrame : TReferenceTime; + dwInterlaceFlags : DWORD; // use AMINTERLACE_* defines. Reject connection if undefined bits are not 0 + dwCopyProtectFlags : DWORD; // use AMCOPYPROTECT_* defines. Reject connection if undefined bits are not 0 + dwPictAspectRatioX : DWORD; // X dimension of picture aspect ratio, e.g. 16 for 16x9 display + dwPictAspectRatioY : DWORD; // Y dimension of picture aspect ratio, e.g. 9 for 16x9 display + dwReserved1 : DWORD; // must be 0; reject connection otherwise + dwReserved2 : DWORD; // must be 0; reject connection otherwise + bmiHeader : TKSBitmapInfoHeader; + end; + {$EXTERNALSYM tagKS_VIDEOINFOHEADER2} + KS_VIDEOINFOHEADER2 = tagKS_VIDEOINFOHEADER2; + {$EXTERNALSYM KS_VIDEOINFOHEADER2} + PKS_VIDEOINFOHEADER2 = ^KS_VIDEOINFOHEADER2; + {$EXTERNALSYM PKS_VIDEOINFOHEADER2} + TKSVideoInfoHeader2 = tagKS_VIDEOINFOHEADER2; + + PKSMPEG1VideoInfo = ^TKSMPEG1VideoInfo; + tagKS_MPEG1VIDEOINFO = record + hdr : TKSVideoInfoHeader ; // Compatible with VIDEOINFO + dwStartTimeCode : DWORD ; // 25-bit Group of pictures time code at start of data + cbSequenceHeader : DWORD ; // Length in bytes of bSequenceHeader + bSequenceHeader : array[0..0] of BYTE; // Sequence header including quantization matrices if any + end; + {$EXTERNALSYM tagKS_MPEG1VIDEOINFO} + KS_MPEG1VIDEOINFO = tagKS_MPEG1VIDEOINFO; + {$EXTERNALSYM KS_MPEG1VIDEOINFO} + PKS_MPEG1VIDEOINFO = ^KS_MPEG1VIDEOINFO; + {$EXTERNALSYM PKS_MPEG1VIDEOINFO} + TKSMPEG1VideoInfo = tagKS_MPEG1VIDEOINFO; + +const + KS_MAX_SIZE_MPEG1_SEQUENCE_INFO = 140; + {$EXTERNALSYM KS_MAX_SIZE_MPEG1_SEQUENCE_INFO} +// KS_SIZE_MPEG1VIDEOINFO(pv) (FIELD_OFFSET(KS_MPEG1VIDEOINFO, bSequenceHeader[0]) + (pv)->cbSequenceHeader) +// KS_MPEG1_SEQUENCE_INFO(pv) ((const BYTE *)(pv)->bSequenceHeader) + +type + PKSMPEGVideoInfo2 = ^TKSMPEGVideoInfo2; + tagKS_MPEGVIDEOINFO2 = record + hdr : TKSVideoInfoHeader2; + dwStartTimeCode : DWORD; // ?? not used for DVD ?? + cbSequenceHeader : DWORD; // is 0 for DVD (no sequence header) + dwProfile : DWORD; // use enum MPEG2Profile + dwLevel : DWORD; // use enum MPEG2Level + dwFlags : DWORD; // use AMMPEG2_* defines. Reject connection if undefined bits are not 0 + bSequenceHeader : array[0..0] of DWORD; // DWORD instead of Byte for alignment purposes + // For MPEG-2, if a sequence_header is included, the sequence_extension + // should also be included + end; + {$EXTERNALSYM tagKS_MPEGVIDEOINFO2} + KS_MPEGVIDEOINFO2 = tagKS_MPEGVIDEOINFO2; + {$EXTERNALSYM KS_MPEGVIDEOINFO2} + PKS_MPEGVIDEOINFO2 = ^KS_MPEGVIDEOINFO2; + {$EXTERNALSYM PKS_MPEGVIDEOINFO2} + TKSMPEGVideoInfo2 = tagKS_MPEGVIDEOINFO2; + +const +// KS_SIZE_MPEGVIDEOINFO2(pv) (FIELD_OFFSET(KS_MPEGVIDEOINFO2, bSequenceHeader[0]) + (pv)->cbSequenceHeader) +// KS_MPEG1_SEQUENCE_INFO(pv) ((const BYTE *)(pv)->bSequenceHeader) + +//=========================================================================== +// Audio format blocks +//=========================================================================== + +//if set, the PTS,DTS timestamps advance at 27MHz rather than 90KHz + KS_MPEGAUDIOINFO_27MhzTimebase = $00000001; + {$EXTERNALSYM KS_MPEGAUDIOINFO_27MhzTimebase} + +type + PKSMPEGAudioInfo = ^TKSMPEGAudioInfo; + tagKS_MPEAUDIOINFO = record + dwFlags : DWORD; // use KS_MPEGAUDIOINFO_* defines. Reject connection if undefined bits are not 0 + dwReserved1 : DWORD; // must be 0; reject connection otherwise + dwReserved2 : DWORD; // must be 0; reject connection otherwise + dwReserved3 : DWORD; // must be 0; reject connection otherwise + end; + {$EXTERNALSYM tagKS_MPEAUDIOINFO} + KS_MPEGAUDIOINFO = tagKS_MPEAUDIOINFO; + {$EXTERNALSYM KS_MPEGAUDIOINFO} + PKS_MPEGAUDIOINFO = ^KS_MPEGAUDIOINFO; + {$EXTERNALSYM PKS_MPEGAUDIOINFO} + TKSMPEGAudioInfo = tagKS_MPEAUDIOINFO; + +//=========================================================================== +// Video DATAFORMATs +//=========================================================================== + + PKSDataFormatVideoInfoHeader = ^TKSDataFormatVideoInfoHeader; + tagKS_DATAFORMAT_VIDEOINFOHEADER = record + DataFormat : TKSDataFormat; + VideoInfoHeader : TKSVideoInfoHeader; + end; + {$EXTERNALSYM tagKS_DATAFORMAT_VIDEOINFOHEADER} + KS_DATAFORMAT_VIDEOINFOHEADER = tagKS_DATAFORMAT_VIDEOINFOHEADER; + {$EXTERNALSYM KS_DATAFORMAT_VIDEOINFOHEADER} + PKS_DATAFORMAT_VIDEOINFOHEADER = ^KS_DATAFORMAT_VIDEOINFOHEADER; + {$EXTERNALSYM PKS_DATAFORMAT_VIDEOINFOHEADER} + TKSDataFormatVideoInfoHeader = tagKS_DATAFORMAT_VIDEOINFOHEADER; + + PKSDataFormatVideoInfoHeader2 = ^TKSDataFormatVideoInfoHeader2; + tagKS_DATAFORMAT_VIDEOINFOHEADER2 = record + DataFormat : TKSDataFormat; + VideoInfoHeader2 : TKSVideoInfoHeader2; + end; + {$EXTERNALSYM tagKS_DATAFORMAT_VIDEOINFOHEADER2} + KS_DATAFORMAT_VIDEOINFOHEADER2 = tagKS_DATAFORMAT_VIDEOINFOHEADER2; + {$EXTERNALSYM KS_DATAFORMAT_VIDEOINFOHEADER2} + PKS_DATAFORMAT_VIDEOINFOHEADER2 = ^KS_DATAFORMAT_VIDEOINFOHEADER2; + {$EXTERNALSYM PKS_DATAFORMAT_VIDEOINFOHEADER2} + TKSDataFormatVideoInfoHeader2 = tagKS_DATAFORMAT_VIDEOINFOHEADER2; + + PKSDataFormatVideoinfoPalette = ^TKSDataFormatVideoinfoPalette; + tagKS_DATAFORMAT_VIDEOINFO_PALETTE = record + DataFormat : TKSDataFormat; + VideoInfo : TKSVideoInfo; + end; + {$EXTERNALSYM tagKS_DATAFORMAT_VIDEOINFO_PALETTE} + KS_DATAFORMAT_VIDEOINFO_PALETTE = tagKS_DATAFORMAT_VIDEOINFO_PALETTE; + {$EXTERNALSYM KS_DATAFORMAT_VIDEOINFO_PALETTE} + PKS_DATAFORMAT_VIDEOINFO_PALETTE = ^KS_DATAFORMAT_VIDEOINFO_PALETTE; + {$EXTERNALSYM PKS_DATAFORMAT_VIDEOINFO_PALETTE} + TKSDataFormatVideoinfoPalette = tagKS_DATAFORMAT_VIDEOINFO_PALETTE; + + PKSDataFormatVBIInfoHeader = ^TKSDataFormatVBIInfoHeader; + tagKS_DATAFORMAT_VBIINFOHEADER = record + DataFormat : TKSDATAFORMAT; + VBIInfoHeader : TKSVBIInfoHeader; + end; + {$EXTERNALSYM tagKS_DATAFORMAT_VBIINFOHEADER} + KS_DATAFORMAT_VBIINFOHEADER = tagKS_DATAFORMAT_VBIINFOHEADER; + {$EXTERNALSYM KS_DATAFORMAT_VBIINFOHEADER} + PKS_DATAFORMAT_VBIINFOHEADER = ^KS_DATAFORMAT_VBIINFOHEADER; + {$EXTERNALSYM PKS_DATAFORMAT_VBIINFOHEADER} + TKSDataFormatVBIInfoHeader = tagKS_DATAFORMAT_VBIINFOHEADER; + + PKSVideoStreamConfigCaps = ^TKSVideoStreamConfigCaps; + _KS_VIDEO_STREAM_CONFIG_CAPS = record + guid : TGUID; // will be MEDIATYPE_Video + VideoStandard : ULONG; // logical OR of all AnalogVideoStandards + // supported + InputSize : TSIZE; // the inherent size of the incoming signal + // (every pixel unique) + MinCroppingSize : TSIZE; // smallest rcSrc cropping rect allowed + MaxCroppingSize : TSIZE; // largest rcSrc cropping rect allowed + CropGranularityX : integer; // granularity of cropping size + CropGranularityY : integer; + CropAlignX : integer; // alignment of cropping rect + CropAlignY : integer; + MinOutputSize : TSIZE; // smallest bitmap stream can produce + MaxOutputSize : TSIZE; // largest bitmap stream can produce + OutputGranularityX : integer; // granularity of output bitmap size + OutputGranularityY : integer; + StretchTapsX : integer; // 0, no stretch, 1 pix dup, 2 interp, ... + StretchTapsY : integer; // Describes quality of hardware scaler + ShrinkTapsX : integer; // + ShrinkTapsY : integer; // + MinFrameInterval : int64; // 100 nS units + MaxFrameInterval : int64; + MinBitsPerSecond : longint; + MaxBitsPerSecond : longint; + end; + {$EXTERNALSYM _KS_VIDEO_STREAM_CONFIG_CAPS} + KS_VIDEO_STREAM_CONFIG_CAPS = _KS_VIDEO_STREAM_CONFIG_CAPS; + {$EXTERNALSYM KS_VIDEO_STREAM_CONFIG_CAPS} + PKS_VIDEO_STREAM_CONFIG_CAPS = ^KS_VIDEO_STREAM_CONFIG_CAPS; + {$EXTERNALSYM PKS_VIDEO_STREAM_CONFIG_CAPS} + TKSVideoStreamConfigCaps = _KS_VIDEO_STREAM_CONFIG_CAPS; + +//=========================================================================== +// Video DATARANGEs +//=========================================================================== + + PKSDataRangeVideo = ^TKSDataRangeVideo; + tagKS_DATARANGE_VIDEO = record + DataRange : TKSDataRange; + bFixedSizeSamples : BOOL; // all samples same size? + bTemporalCompression : BOOL; // all I frames? + StreamDescriptionFlags : DWORD; // KS_VIDEO_DESC_* + MemoryAllocationFlags : DWORD; // KS_VIDEO_ALLOC_* + ConfigCaps : TKSVideoStreamConfigCaps; + VideoInfoHeader : TKSVideoInfoHeader; // default format + end; + {$EXTERNALSYM tagKS_DATARANGE_VIDEO} + KS_DATARANGE_VIDEO = tagKS_DATARANGE_VIDEO; + {$EXTERNALSYM KS_DATARANGE_VIDEO} + PKS_DATARANGE_VIDEO = ^KS_DATARANGE_VIDEO; + {$EXTERNALSYM PKS_DATARANGE_VIDEO} + TKSDataRangeVideo = tagKS_DATARANGE_VIDEO; + + PKSDataRangeVideo2 = ^TKSDataRangeVideo2; + tagKS_DATARANGE_VIDEO2 = record + DataRange : TKSDataRange; + bFixedSizeSamples : BOOL; // all samples same size? + bTemporalCompression : BOOL; // all I frames? + StreamDescriptionFlags : DWORD; // KS_VIDEO_DESC_* + MemoryAllocationFlags : DWORD; // KS_VIDEO_ALLOC_* + ConfigCaps : TKSVideoStreamConfigCaps; + VideoInfoHeader : TKSVideoInfoHeader2; // default format + end; + {$EXTERNALSYM tagKS_DATARANGE_VIDEO2} + KS_DATARANGE_VIDEO2 = tagKS_DATARANGE_VIDEO2; + {$EXTERNALSYM KS_DATARANGE_VIDEO2} + PKS_DATARANGE_VIDEO2 = ^KS_DATARANGE_VIDEO2; + {$EXTERNALSYM PKS_DATARANGE_VIDEO2} + TKSDataRangeVideo2 = tagKS_DATARANGE_VIDEO2; + + PKSDataRangeMPEG1Video = ^TKSDataRangeMPEG1Video; + tagKS_DATARANGE_MPEG1_VIDEO = record + DataRange : TKSDataRange ; + bFixedSizeSamples : BOOL ; // all samples same size? + bTemporalCompression : BOOL ; // all I frames? + StreamDescriptionFlags : DWORD ; // KS_VIDEO_DESC_* + MemoryAllocationFlags : DWORD ; // KS_VIDEO_ALLOC_* + ConfigCaps : TKSVideoStreamConfigCaps ; + VideoInfoHeader : TKSMPEG1VideoInfo ; // default format + end; + {$EXTERNALSYM tagKS_DATARANGE_MPEG1_VIDEO} + KS_DATARANGE_MPEG1_VIDEO = tagKS_DATARANGE_MPEG1_VIDEO; + {$EXTERNALSYM KS_DATARANGE_MPEG1_VIDEO} + PKS_DATARANGE_MPEG1_VIDEO = ^KS_DATARANGE_MPEG1_VIDEO; + {$EXTERNALSYM PKS_DATARANGE_MPEG1_VIDEO} + TKSDataRangeMPEG1Video = tagKS_DATARANGE_MPEG1_VIDEO; + + PKSDataRangeMPEG2Video = ^TKSDataRangeMPEG2Video; + tagKS_DATARANGE_MPEG2_VIDEO = record + DataRange : TKSDataRange; + bFixedSizeSamples : BOOL; // all samples same size? + bTemporalCompression : BOOL; // all I frames? + StreamDescriptionFlags : DWORD; // KS_VIDEO_DESC_* + MemoryAllocationFlags : DWORD; // KS_VIDEO_ALLOC_* + ConfigCaps : TKSVideoStreamConfigCaps; + VideoInfoHeader : TKSMPEGVideoInfo2; // default format + end; + {$EXTERNALSYM tagKS_DATARANGE_MPEG2_VIDEO} + KS_DATARANGE_MPEG2_VIDEO = tagKS_DATARANGE_MPEG2_VIDEO; + {$EXTERNALSYM KS_DATARANGE_MPEG2_VIDEO} + PKS_DATARANGE_MPEG2_VIDEO = ^KS_DATARANGE_MPEG2_VIDEO; + {$EXTERNALSYM PKS_DATARANGE_MPEG2_VIDEO} + TKSDataRangeMPEG2Video = tagKS_DATARANGE_MPEG2_VIDEO; + + PKSDataRangeVideoPalette = ^TKSDataRangeVideoPalette; + tagKS_DATARANGE_VIDEO_PALETTE = record + DataRange : TKSDataRange; + bFixedSizeSamples : BOOL; // all samples same size? + bTemporalCompression : BOOL; // all I frames? + StreamDescriptionFlags : DWORD; // KS_VIDEO_DESC_* + MemoryAllocationFlags : DWORD; // KS_VIDEO_ALLOC_* + ConfigCaps : TKSVideoStreamConfigCaps; + VideoInfo : TKSVideoInfo; // default format + end; + {$EXTERNALSYM tagKS_DATARANGE_VIDEO_PALETTE} + KS_DATARANGE_VIDEO_PALETTE = tagKS_DATARANGE_VIDEO_PALETTE; + {$EXTERNALSYM KS_DATARANGE_VIDEO_PALETTE} + PKS_DATARANGE_VIDEO_PALETTE = ^KS_DATARANGE_VIDEO_PALETTE; + {$EXTERNALSYM PKS_DATARANGE_VIDEO_PALETTE} + TKSDataRangeVideoPalette = tagKS_DATARANGE_VIDEO_PALETTE; + + PKSDataRangeVideoVBI = ^TKSDataRangeVideoVBI; + tagKS_DATARANGE_VIDEO_VBI = record + DataRange : TKSDataRange; + bFixedSizeSamples : BOOL; // all samples same size? + bTemporalCompression : BOOL; // all I frames? + StreamDescriptionFlags : DWORD; // KS_VIDEO_DESC_* + MemoryAllocationFlags : DWORD; // KS_VIDEO_ALLOC_* + ConfigCaps : TKSVideoStreamConfigCaps; + VBIInfoHeader : TKSVBIInfoHeader; // default format + end; + {$EXTERNALSYM tagKS_DATARANGE_VIDEO_VBI} + KS_DATARANGE_VIDEO_VBI = tagKS_DATARANGE_VIDEO_VBI; + {$EXTERNALSYM KS_DATARANGE_VIDEO_VBI} + PKS_DATARANGE_VIDEO_VBI = ^KS_DATARANGE_VIDEO_VBI; + {$EXTERNALSYM PKS_DATARANGE_VIDEO_VBI} + TKSDataRangeVideoVBI = tagKS_DATARANGE_VIDEO_VBI; + + PKSDataRangeAnalogVideo = ^TKSDataRangeAnalogVideo; + tagKS_DATARANGE_ANALOGVIDEO = record + DataRange : TKSDataRange; + AnalogVideoInfo : TKSAnalogVideoInfo; + end; + {$EXTERNALSYM tagKS_DATARANGE_ANALOGVIDEO} + KS_DATARANGE_ANALOGVIDEO = tagKS_DATARANGE_ANALOGVIDEO; + {$EXTERNALSYM KS_DATARANGE_ANALOGVIDEO} + PKS_DATARANGE_ANALOGVIDEO = ^KS_DATARANGE_ANALOGVIDEO; + {$EXTERNALSYM PKS_DATARANGE_ANALOGVIDEO} + TKSDataRangeAnalogVideo = tagKS_DATARANGE_ANALOGVIDEO; + +//=========================================================================== +// StreamDescriptionFlags +// +// These define the "purpose" of each video stream +//=========================================================================== +const + KS_VIDEOSTREAM_PREVIEW = $0001; // Preview stream + {$EXTERNALSYM KS_VIDEOSTREAM_PREVIEW} + KS_VIDEOSTREAM_CAPTURE = $0002; // Capture stream + {$EXTERNALSYM KS_VIDEOSTREAM_CAPTURE} + KS_VIDEOSTREAM_VBI = $0010; // Field1 VBI + {$EXTERNALSYM KS_VIDEOSTREAM_VBI} + KS_VIDEOSTREAM_NABTS = $0020; // Field1 NABTS + {$EXTERNALSYM KS_VIDEOSTREAM_NABTS} + KS_VIDEOSTREAM_CC = $0100; // Closed Captioning + {$EXTERNALSYM KS_VIDEOSTREAM_CC} + KS_VIDEOSTREAM_EDS = $0200; // Extended Data Services + {$EXTERNALSYM KS_VIDEOSTREAM_EDS} + KS_VIDEOSTREAM_TELETEXT = $0400; // Field1 Teletext only + {$EXTERNALSYM KS_VIDEOSTREAM_TELETEXT} + KS_VIDEOSTREAM_STILL = $1000; // Still image input + {$EXTERNALSYM KS_VIDEOSTREAM_STILL} + KS_VIDEOSTREAM_IS_VPE = $8000; // Is a VPE based stream? + {$EXTERNALSYM KS_VIDEOSTREAM_IS_VPE} + +// MemoryAllocationFlags + KS_VIDEO_ALLOC_VPE_SYSTEM = $0001; // VPE surface in system memory + {$EXTERNALSYM KS_VIDEO_ALLOC_VPE_SYSTEM} + KS_VIDEO_ALLOC_VPE_DISPLAY = $0002; // VPE surface in display memory + {$EXTERNALSYM KS_VIDEO_ALLOC_VPE_DISPLAY} + KS_VIDEO_ALLOC_VPE_AGP = $0004; // VPE surface in AGP memory + {$EXTERNALSYM KS_VIDEO_ALLOC_VPE_AGP} + +////////////////////////////////////////////////////////////// +// Capture driver VBI property sets +////////////////////////////////////////////////////////////// + +// {F162C607-7B35-496f-AD7F-2DCA3B46B718} + KSPROPSETID_VBICAP_PROPERTIES : TGUID = '{F162C607-7B35-496f-AD7F-2DCA3B46B718}'; + {$EXTERNALSYM KSPROPSETID_VBICAP_PROPERTIES} + +type + KSPROPERTY_VBICAP = ( + {$IFNDEF COMPILER6_UP} + KSPROPERTY_VBICAP_PROPERTIES_INVALID_0, + KSPROPERTY_VBICAP_PROPERTIES_PROTECTION + {$ELSE} + KSPROPERTY_VBICAP_PROPERTIES_PROTECTION = 1 + {$ENDIF} + ); + {$EXTERNALSYM KSPROPERTY_VBICAP} + TKSPropertyVBICap = KSPROPERTY_VBICAP; + + PVBICapPropertiesProtectionS = ^TVBICapPropertiesProtectionS; + _VBICAP_PROPERTIES_PROTECTION_S = record + Property_ : KSPROPERTY; + StreamIndex : ULONG; // Index of stream + Status : ULONG; + end; + {$EXTERNALSYM _VBICAP_PROPERTIES_PROTECTION_S} + VBICAP_PROPERTIES_PROTECTION_S = _VBICAP_PROPERTIES_PROTECTION_S; + {$EXTERNALSYM VBICAP_PROPERTIES_PROTECTION_S} + PVBICAP_PROPERTIES_PROTECTION_S = ^VBICAP_PROPERTIES_PROTECTION_S; + {$EXTERNALSYM PVBICAP_PROPERTIES_PROTECTION_S} + TVBICapPropertiesProtectionS = _VBICAP_PROPERTIES_PROTECTION_S; + +const + KS_VBICAP_PROTECTION_MV_PRESENT = $0001; + {$EXTERNALSYM KS_VBICAP_PROTECTION_MV_PRESENT} + KS_VBICAP_PROTECTION_MV_HARDWARE = $0002; + {$EXTERNALSYM KS_VBICAP_PROTECTION_MV_HARDWARE} + KS_VBICAP_PROTECTION_MV_DETECTED = $0004; + {$EXTERNALSYM KS_VBICAP_PROTECTION_MV_DETECTED} + + +//***************************************************************************/ +//* VBI Related GUIDs, structs and properties for codecs(generic, cc, nabts)*/ +//***************************************************************************/ + +/////////////////////////////////////////////////////////////////////////////////////// +// IP/NABTS Protocol Reserved Group IDs - Overall Range 0x800-0x8FF [Decimal 2048-2079] +// Intervening values(0-F) are used if there are multiple providers at a particular tier +/////////////////////////////////////////////////////////////////////////////////////// + +// Used by individual content creators in show footage/data + KS_NABTS_GROUPID_ORIGINAL_CONTENT_BASE = $800; + {$EXTERNALSYM KS_NABTS_GROUPID_ORIGINAL_CONTENT_BASE} + KS_NABTS_GROUPID_ORIGINAL_CONTENT_ADVERTISER_BASE = $810; + {$EXTERNALSYM KS_NABTS_GROUPID_ORIGINAL_CONTENT_ADVERTISER_BASE} + +// Used by production company in finished show data + KS_NABTS_GROUPID_PRODUCTION_COMPANY_CONTENT_BASE = $820; + {$EXTERNALSYM KS_NABTS_GROUPID_PRODUCTION_COMPANY_CONTENT_BASE} + KS_NABTS_GROUPID_PRODUCTION_COMPANY_ADVERTISER_BASE = $830; + {$EXTERNALSYM KS_NABTS_GROUPID_PRODUCTION_COMPANY_ADVERTISER_BASE} + +// Used by broadcast syndicates in syndicated show data + KS_NABTS_GROUPID_SYNDICATED_SHOW_CONTENT_BASE = $840; + {$EXTERNALSYM KS_NABTS_GROUPID_SYNDICATED_SHOW_CONTENT_BASE} + KS_NABTS_GROUPID_SYNDICATED_SHOW_ADVERTISER_BASE = $850; + {$EXTERNALSYM KS_NABTS_GROUPID_SYNDICATED_SHOW_ADVERTISER_BASE} + +// Used by tv networks in network television data + KS_NABTS_GROUPID_NETWORK_WIDE_CONTENT_BASE = $860; + {$EXTERNALSYM KS_NABTS_GROUPID_NETWORK_WIDE_CONTENT_BASE} + KS_NABTS_GROUPID_NETWORK_WIDE_ADVERTISER_BASE = $870; + {$EXTERNALSYM KS_NABTS_GROUPID_NETWORK_WIDE_ADVERTISER_BASE} + +// Used by telvision stations in local programming data + KS_NABTS_GROUPID_TELEVISION_STATION_CONTENT_BASE = $880; + {$EXTERNALSYM KS_NABTS_GROUPID_TELEVISION_STATION_CONTENT_BASE} + KS_NABTS_GROUPID_TELEVISION_STATION_ADVERTISER_BASE = $890; + {$EXTERNALSYM KS_NABTS_GROUPID_TELEVISION_STATION_ADVERTISER_BASE} + +// Used by cable system in cable head-end originated data + KS_NABTS_GROUPID_LOCAL_CABLE_SYSTEM_CONTENT_BASE = $8A0; + {$EXTERNALSYM KS_NABTS_GROUPID_LOCAL_CABLE_SYSTEM_CONTENT_BASE} + KS_NABTS_GROUPID_LOCAL_CABLE_SYSTEM_ADVERTISER_BASE = $8B0; + {$EXTERNALSYM KS_NABTS_GROUPID_LOCAL_CABLE_SYSTEM_ADVERTISER_BASE} + +// The values between 0x8C0 - 0x8EF are reserved for future expansion + +// Used by Microsoft for Testing purposes (0x8F0 - 0x8FF) + KS_NABTS_GROUPID_MICROSOFT_RESERVED_TEST_DATA_BASE = $8F0; + {$EXTERNALSYM KS_NABTS_GROUPID_MICROSOFT_RESERVED_TEST_DATA_BASE} + +////////////////////////////////////////////////////////////// +// Stream Format FEC-corrected NABTS bundles +////////////////////////////////////////////////////////////// + + KSDATAFORMAT_TYPE_NABTS : TGUID = '{E757BCA0-39AC-11d1-A9F5-00C04FBBDE8F}'; + {$EXTERNALSYM KSDATAFORMAT_TYPE_NABTS} + KSDATAFORMAT_SUBTYPE_NABTS_FEC : TGUID = '{E757BCA1-39AC-11d1-A9F5-00C04FBBDE8F}'; + {$EXTERNALSYM KSDATAFORMAT_SUBTYPE_NABTS_FEC} + + +////////////////////////////////////////////////////////////// +// NABTS Bundle data structure definition +////////////////////////////////////////////////////////////// + + MAX_NABTS_VBI_LINES_PER_FIELD = 11; + {$EXTERNALSYM MAX_NABTS_VBI_LINES_PER_FIELD} + NABTS_LINES_PER_BUNDLE = 16; + {$EXTERNALSYM NABTS_LINES_PER_BUNDLE} + NABTS_PAYLOAD_PER_LINE = 28; + {$EXTERNALSYM NABTS_PAYLOAD_PER_LINE} + NABTS_BYTES_PER_LINE = 36; + {$EXTERNALSYM NABTS_BYTES_PER_LINE} + +type + PNABTSFecBuffer = ^TNABTSFecBuffer; + _NABTSFEC_BUFFER = record + dataSize : ULONG; + groupID : word; + Reserved : word; + data : array[0..(NABTS_LINES_PER_BUNDLE * NABTS_PAYLOAD_PER_LINE)-1] of UCHAR; + end; + {$EXTERNALSYM _NABTSFEC_BUFFER} + NABTSFEC_BUFFER = _NABTSFEC_BUFFER; + {$EXTERNALSYM NABTSFEC_BUFFER} + PNABTSFEC_BUFFER = ^NABTSFEC_BUFFER; + {$EXTERNALSYM PNABTSFEC_BUFFER} + TNABTSFecBuffer = _NABTSFEC_BUFFER; + +////////////////////////////////////////////////////////////// +// vbi codec filtering pin properties +////////////////////////////////////////////////////////////// +const + KSPROPSETID_VBICodecFiltering : TGUID = '{cafeb0ca-8715-11d0-bd6a-0035c0edbabe}'; + {$EXTERNALSYM KSPROPSETID_VBICodecFiltering} + +type + KSPROPERTY_VBICODECFILTERING = ( + {$IFNDEF COMPILER6_UP} + KSPROPERTY_VBICODECFILTERING_INVALID_0, + KSPROPERTY_VBICODECFILTERING_SCANLINES_REQUESTED_BIT_ARRAY, + {$ELSE} + KSPROPERTY_VBICODECFILTERING_SCANLINES_REQUESTED_BIT_ARRAY = 1, + {$ENDIF} + KSPROPERTY_VBICODECFILTERING_SCANLINES_DISCOVERED_BIT_ARRAY, + KSPROPERTY_VBICODECFILTERING_SUBSTREAMS_REQUESTED_BIT_ARRAY, + KSPROPERTY_VBICODECFILTERING_SUBSTREAMS_DISCOVERED_BIT_ARRAY, + KSPROPERTY_VBICODECFILTERING_STATISTICS + ); + {$EXTERNALSYM KSPROPERTY_VBICODECFILTERING} + TKSPropertyVBICodecFiltering = KSPROPERTY_VBICODECFILTERING; + + PVBICodecFilteringScanlines = ^TVBICodecFilteringScanlines; + _VBICODECFILTERING_SCANLINES = record + DwordBitArray : array[0..31] of DWORD; // An array of scanline bits 0..1024(32*32) + end; + {$EXTERNALSYM _VBICODECFILTERING_SCANLINES} + VBICODECFILTERING_SCANLINES = _VBICODECFILTERING_SCANLINES; + {$EXTERNALSYM VBICODECFILTERING_SCANLINES} + PVBICODECFILTERING_SCANLINES = ^VBICODECFILTERING_SCANLINES; + {$EXTERNALSYM PVBICODECFILTERING_SCANLINES} + TVBICodecFilteringScanlines = _VBICODECFILTERING_SCANLINES; + + PVBICodecFilteringNABTSSubStreams = ^TVBICodecFilteringNABTSSubStreams; + _VBICODECFILTERING_NABTS_SUBSTREAMS = record + SubstreamMask : array[0..127] of DWORD; // An array of 4096 bits (one for each NABTS GroupID) + end; + {$EXTERNALSYM _VBICODECFILTERING_NABTS_SUBSTREAMS} + VBICODECFILTERING_NABTS_SUBSTREAMS = _VBICODECFILTERING_NABTS_SUBSTREAMS; + {$EXTERNALSYM VBICODECFILTERING_NABTS_SUBSTREAMS} + PVBICODECFILTERING_NABTS_SUBSTREAMS = ^VBICODECFILTERING_NABTS_SUBSTREAMS; + {$EXTERNALSYM PVBICODECFILTERING_NABTS_SUBSTREAMS} + TVBICodecFilteringNABTSSubStreams = _VBICODECFILTERING_NABTS_SUBSTREAMS; + + PVBICodecFilteringCCSubStreams = ^TVBICodecFilteringCCSubStreams; + _VBICODECFILTERING_CC_SUBSTREAMS = record + SubstreamMask : DWORD; // An array of 32 bits (see KS_CC_SUBSTREAM *) + end; + {$EXTERNALSYM _VBICODECFILTERING_CC_SUBSTREAMS} + VBICODECFILTERING_CC_SUBSTREAMS = _VBICODECFILTERING_CC_SUBSTREAMS; + {$EXTERNALSYM VBICODECFILTERING_CC_SUBSTREAMS} + PVBICODECFILTERING_CC_SUBSTREAMS = ^VBICODECFILTERING_CC_SUBSTREAMS; + {$EXTERNALSYM PVBICODECFILTERING_CC_SUBSTREAMS} + TVBICodecFilteringCCSubStreams = _VBICODECFILTERING_CC_SUBSTREAMS; + +const + KS_CC_SUBSTREAM_ODD = $0001; + {$EXTERNALSYM KS_CC_SUBSTREAM_ODD} + KS_CC_SUBSTREAM_EVEN = $0002; + {$EXTERNALSYM KS_CC_SUBSTREAM_EVEN} + KS_CC_SUBSTREAM_SERVICE_MASK_DC1 = $00F0; // DataChannel1: CC1,CC3,T1,T3 + {$EXTERNALSYM KS_CC_SUBSTREAM_SERVICE_MASK_DC1} + KS_CC_SUBSTREAM_SERVICE_CC1 = $0010; + {$EXTERNALSYM KS_CC_SUBSTREAM_SERVICE_CC1} + KS_CC_SUBSTREAM_SERVICE_CC3 = $0020; + {$EXTERNALSYM KS_CC_SUBSTREAM_SERVICE_CC3} + KS_CC_SUBSTREAM_SERVICE_T1 = $0040; + {$EXTERNALSYM KS_CC_SUBSTREAM_SERVICE_T1} + KS_CC_SUBSTREAM_SERVICE_T3 = $0080; + {$EXTERNALSYM KS_CC_SUBSTREAM_SERVICE_T3} + KS_CC_SUBSTREAM_SERVICE_MASK_DC2 = $0F00; // DataChannel2: CC2,CC4,T2,T4 + {$EXTERNALSYM KS_CC_SUBSTREAM_SERVICE_MASK_DC2} + KS_CC_SUBSTREAM_SERVICE_CC2 = $0100; + {$EXTERNALSYM KS_CC_SUBSTREAM_SERVICE_CC2} + KS_CC_SUBSTREAM_SERVICE_CC4 = $0200; + {$EXTERNALSYM KS_CC_SUBSTREAM_SERVICE_CC4} + KS_CC_SUBSTREAM_SERVICE_T2 = $0400; + {$EXTERNALSYM KS_CC_SUBSTREAM_SERVICE_T2} + KS_CC_SUBSTREAM_SERVICE_T4 = $0800; + {$EXTERNALSYM KS_CC_SUBSTREAM_SERVICE_T4} + KS_CC_SUBSTREAM_SERVICE_XDS = $1000; + {$EXTERNALSYM KS_CC_SUBSTREAM_SERVICE_XDS} + +/////////////////////////////////////////////////////////////////// +// Hardware decoded CC stream format +/////////////////////////////////////////////////////////////////// + + CC_MAX_HW_DECODE_LINES = 12; + {$EXTERNALSYM CC_MAX_HW_DECODE_LINES} + +type + PCCBytePair = ^TCCBytePair; + _CC_BYTE_PAIR = record + Decoded : array[0..1] of BYTE; + Reserved : word; + end; + {$EXTERNALSYM _CC_BYTE_PAIR} + CC_BYTE_PAIR = _CC_BYTE_PAIR; + {$EXTERNALSYM CC_BYTE_PAIR} + PCC_BYTE_PAIR = ^CC_BYTE_PAIR; + {$EXTERNALSYM PCC_BYTE_PAIR} + TCCBytePair = _CC_BYTE_PAIR; + + PCCHWField = ^TCCHWField; + _CC_HW_FIELD = record + ScanlinesRequested : TVBICodecFilteringScanlines; + fieldFlags : ULONG; // KS_VBI_FLAG_FIELD1,2 + PictureNumber : int64; + Lines : array[0..CC_MAX_HW_DECODE_LINES-1] of TCCBytePair; + end; + {$EXTERNALSYM _CC_HW_FIELD} + CC_HW_FIELD = _CC_HW_FIELD; + {$EXTERNALSYM CC_HW_FIELD} + PCC_HW_FIELD = ^CC_HW_FIELD; + {$EXTERNALSYM PCC_HW_FIELD} + TCCHWField = _CC_HW_FIELD; + +/////////////////////////////////////////////////////////////////// +// Raw NABTS stream format (TYPE_NABTS, SUBTYPE_NABTS) +/////////////////////////////////////////////////////////////////// + +// These low-level structures are byte packed( -Zp1 ) + + PNABTSBufferLine = ^TNABTSBufferLine; + _NABTS_BUFFER_LINE = record + Confidence : BYTE; + Bytes : array[0..NABTS_BYTES_PER_LINE-1] of BYTE; + end; + {$EXTERNALSYM _NABTS_BUFFER_LINE} + NABTS_BUFFER_LINE = _NABTS_BUFFER_LINE; + {$EXTERNALSYM NABTS_BUFFER_LINE} + PNABTS_BUFFER_LINE = ^NABTS_BUFFER_LINE; + {$EXTERNALSYM PNABTS_BUFFER_LINE} + TNABTSBufferLine = _NABTS_BUFFER_LINE; + +const + NABTS_BUFFER_PICTURENUMBER_SUPPORT = 1; + {$EXTERNALSYM NABTS_BUFFER_PICTURENUMBER_SUPPORT} + +type + PNABTSBuffer = ^TNABTSBuffer; + _NABTS_BUFFER = record + ScanlinesRequested : TVBICodecFilteringScanlines; + PictureNumber : int64; + NabtsLines : array[0..MAX_NABTS_VBI_LINES_PER_FIELD-1] of TNABTSBufferLine; + end; + {$EXTERNALSYM _NABTS_BUFFER} + NABTS_BUFFER = _NABTS_BUFFER; + {$EXTERNALSYM NABTS_BUFFER} + PNABTS_BUFFER = ^NABTS_BUFFER; + {$EXTERNALSYM PNABTS_BUFFER} + TNABTSBuffer = _NABTS_BUFFER; + +////////////////////////////////////////////////////////////// +// WST Codec Teletext Media Sample Format +////////////////////////////////////////////////////////////// +const + WST_TVTUNER_CHANGE_BEGIN_TUNE = $1000; // Starting a tuning operation + {$EXTERNALSYM WST_TVTUNER_CHANGE_BEGIN_TUNE} + WST_TVTUNER_CHANGE_END_TUNE = $2000; // Ending a tuning operation + {$EXTERNALSYM WST_TVTUNER_CHANGE_END_TUNE} + + MAX_WST_VBI_LINES_PER_FIELD = 17; + {$EXTERNALSYM MAX_WST_VBI_LINES_PER_FIELD} + WST_BYTES_PER_LINE = 42; + {$EXTERNALSYM WST_BYTES_PER_LINE} + +type + PWSTBufferLine = ^TWSTBufferLine; + _WST_BUFFER_LINE = record + Confidence: BYTE; + Bytes : array[0..WST_BYTES_PER_LINE-1] of BYTE; + end; + {$EXTERNALSYM _WST_BUFFER_LINE} + WST_BUFFER_LINE = _WST_BUFFER_LINE; + {$EXTERNALSYM WST_BUFFER_LINE} + PWST_BUFFER_LINE = ^WST_BUFFER_LINE; + {$EXTERNALSYM PWST_BUFFER_LINE} + TWSTBufferLine = _WST_BUFFER_LINE; + + PWSTBuffer = ^TWSTBuffer; + _WST_BUFFER = record + ScanlinesRequested: TVBICodecFilteringScanlines; + WstLines: array[0..MAX_WST_VBI_LINES_PER_FIELD-1] of TWSTBufferLine; + end; + {$EXTERNALSYM _WST_BUFFER} + WST_BUFFER = _WST_BUFFER; + {$EXTERNALSYM WST_BUFFER} + PWST_BUFFER = ^WST_BUFFER; + {$EXTERNALSYM PWST_BUFFER} + TWSTBuffer = _WST_BUFFER; +// +// Common codec statistics +// + + PVBICodecFilteringStatisticsCommon = ^TVBICodecFilteringStatisticsCommon; + _VBICODECFILTERING_STATISTICS_COMMON = record + InputSRBsProcessed : DWORD; // upstream SRBs received + OutputSRBsProcessed : DWORD; // downstream SRBs sent + SRBsIgnored : DWORD; // SRBs ignored due to no requests + InputSRBsMissing : DWORD; // SRBs dropped upstream + OutputSRBsMissing : DWORD; // Output dropped because no SRB pending + OutputFailures : DWORD; // dropped because of other failure + InternalErrors : DWORD; // could not process due to int. failure + ExternalErrors : DWORD; // could not process due to ext. failure + InputDiscontinuities : DWORD; // discontinuities received + DSPFailures : DWORD; // DSP confidence failure + TvTunerChanges : DWORD; // number of received KS_TVTUNER_CHANGE_BEGIN_TUNE and KS_TVTUNER_CHANGE_END_TUNE pairs. + VBIHeaderChanges : DWORD; // number of received KS_VBI_FLAG_VBIINFOHEADER_CHANGE + LineConfidenceAvg : DWORD; // Average of all DSP confidence results + BytesOutput : DWORD; // Bytes sent downstream + end; + {$EXTERNALSYM _VBICODECFILTERING_STATISTICS_COMMON} + VBICODECFILTERING_STATISTICS_COMMON = _VBICODECFILTERING_STATISTICS_COMMON; + {$EXTERNALSYM VBICODECFILTERING_STATISTICS_COMMON} + PVBICODECFILTERING_STATISTICS_COMMON = ^VBICODECFILTERING_STATISTICS_COMMON; + {$EXTERNALSYM PVBICODECFILTERING_STATISTICS_COMMON} + TVBICodecFilteringStatisticsCommon = _VBICODECFILTERING_STATISTICS_COMMON; + + PVBICodecFilteringStatisticsCommonPin = ^TVBICodecFilteringStatisticsCommonPin; + _VBICODECFILTERING_STATISTICS_COMMON_PIN = record + SRBsProcessed : DWORD; // SRBs sent/received + SRBsIgnored : DWORD; // SRBs ignored due to filtering + SRBsMissing : DWORD; // SRBs not sent/received + InternalErrors : DWORD; // could not send/receive due to int. failure + ExternalErrors : DWORD; // could not send/receive due to ext. failure + Discontinuities : DWORD; // discontinuities received/sent + LineConfidenceAvg : DWORD; // Average of all DSP confidence results for this pin + BytesOutput : DWORD; // Bytes sent downstream + end; + {$EXTERNALSYM _VBICODECFILTERING_STATISTICS_COMMON_PIN} + VBICODECFILTERING_STATISTICS_COMMON_PIN = _VBICODECFILTERING_STATISTICS_COMMON_PIN; + {$EXTERNALSYM VBICODECFILTERING_STATISTICS_COMMON_PIN} + PVBICODECFILTERING_STATISTICS_COMMON_PIN = ^VBICODECFILTERING_STATISTICS_COMMON_PIN; + {$EXTERNALSYM PVBICODECFILTERING_STATISTICS_COMMON_PIN} + TVBICodecFilteringStatisticsCommonPin = _VBICODECFILTERING_STATISTICS_COMMON_PIN; + +// +// Codec-specific statistics - NABTS +// + + PVBICodecFilteringStatisticsNABTS = ^TVBICodecFilteringStatisticsNABTS; + _VBICODECFILTERING_STATISTICS_NABTS = record + Common : TVBICodecFilteringStatisticsCommon ; // Generic VBI statistics + FECBundleBadLines : DWORD; // Un-FEC-correctable lines + FECQueueOverflows : DWORD; // Number of times FEC queue overflowed + FECCorrectedLines : DWORD; // Lines CSUM corrected by FEC + FECUncorrectableLines : DWORD; // FEC input lines not CSUM correctable + BundlesProcessed : DWORD; // Bundles received from FEC + BundlesSent2IP : DWORD; // Bundles sent to IP driver + FilteredLines : DWORD; // Lines processed and then dropped + // because no one was interested + end; + {$EXTERNALSYM _VBICODECFILTERING_STATISTICS_NABTS} + VBICODECFILTERING_STATISTICS_NABTS = _VBICODECFILTERING_STATISTICS_NABTS; + {$EXTERNALSYM VBICODECFILTERING_STATISTICS_NABTS} + PVBICODECFILTERING_STATISTICS_NABTS = ^VBICODECFILTERING_STATISTICS_NABTS; + {$EXTERNALSYM PVBICODECFILTERING_STATISTICS_NABTS} + TVBICodecFilteringStatisticsNABTS = _VBICODECFILTERING_STATISTICS_NABTS; + + PVBICodecFilteringStatisticsNABTSPin = ^TVBICodecFilteringStatisticsNABTSPin; + _VBICODECFILTERING_STATISTICS_NABTS_PIN = record + Common : TVBICodecFilteringStatisticsCommonPin; // Generic VBI pin statistics + end; + {$EXTERNALSYM _VBICODECFILTERING_STATISTICS_NABTS_PIN} + VBICODECFILTERING_STATISTICS_NABTS_PIN = _VBICODECFILTERING_STATISTICS_NABTS_PIN; + {$EXTERNALSYM VBICODECFILTERING_STATISTICS_NABTS_PIN} + PVBICODECFILTERING_STATISTICS_NABTS_PIN = ^VBICODECFILTERING_STATISTICS_NABTS_PIN; + {$EXTERNALSYM PVBICODECFILTERING_STATISTICS_NABTS_PIN} + TVBICodecFilteringStatisticsNABTSPin = _VBICODECFILTERING_STATISTICS_NABTS_PIN; + +// +// Codec-specific statistics - Closed Caption +// + + PVBICodecFilteringStatisticsCC = ^TVBICodecFilteringStatisticsCC; + _VBICODECFILTERING_STATISTICS_CC = record + Common : TVBICodecFilteringStatisticsCommon; // Generic VBI statistics + end; + {$EXTERNALSYM _VBICODECFILTERING_STATISTICS_CC} + VBICODECFILTERING_STATISTICS_CC = _VBICODECFILTERING_STATISTICS_CC; + {$EXTERNALSYM VBICODECFILTERING_STATISTICS_CC} + PVBICODECFILTERING_STATISTICS_CC = ^VBICODECFILTERING_STATISTICS_CC; + {$EXTERNALSYM PVBICODECFILTERING_STATISTICS_CC} + TVBICodecFilteringStatisticsCC = _VBICODECFILTERING_STATISTICS_CC; + + PVBICodecFilteringStatisticsCCPin = ^TVBICodecFilteringStatisticsCCPin; + _VBICODECFILTERING_STATISTICS_CC_PIN = record + Common : TVBICodecFilteringStatisticsCommonPin; // Generic VBI pin statistics + end; + {$EXTERNALSYM _VBICODECFILTERING_STATISTICS_CC_PIN} + VBICODECFILTERING_STATISTICS_CC_PIN = _VBICODECFILTERING_STATISTICS_CC_PIN; + {$EXTERNALSYM VBICODECFILTERING_STATISTICS_CC_PIN} + PVBICODECFILTERING_STATISTICS_CC_PIN = ^VBICODECFILTERING_STATISTICS_CC_PIN; + {$EXTERNALSYM PVBICODECFILTERING_STATISTICS_CC_PIN} + TVBICodecFilteringStatisticsCCPin = _VBICODECFILTERING_STATISTICS_CC_PIN; + +// +// Codec-specific statistics - Closed Caption +// + + PVBICodecFilteringStatisticsTeletext = ^TVBICodecFilteringStatisticsTeletext; + _VBICODECFILTERING_STATISTICS_TELETEXT = record + Common: TVBICodecFilteringStatisticsCommon ; // Generic VBI statistics + end; + {$EXTERNALSYM _VBICODECFILTERING_STATISTICS_TELETEXT} + VBICODECFILTERING_STATISTICS_TELETEXT = _VBICODECFILTERING_STATISTICS_TELETEXT; + {$EXTERNALSYM VBICODECFILTERING_STATISTICS_TELETEXT} + PVBICODECFILTERING_STATISTICS_TELETEXT = ^VBICODECFILTERING_STATISTICS_TELETEXT; + {$EXTERNALSYM PVBICODECFILTERING_STATISTICS_TELETEXT} + TVBICodecFilteringStatisticsTeletext = _VBICODECFILTERING_STATISTICS_TELETEXT; + + PVBICodecFilteringStatisticsTeletextPin = ^TVBICodecFilteringStatisticsTeletextPin; + _VBICODECFILTERING_STATISTICS_TELETEXT_PIN = record + Common: TVBICodecFilteringStatisticsCommonPin ;// Generic VBI pin statistics + end; + {$EXTERNALSYM _VBICODECFILTERING_STATISTICS_TELETEXT_PIN} + VBICODECFILTERING_STATISTICS_TELETEXT_PIN = _VBICODECFILTERING_STATISTICS_TELETEXT_PIN; + {$EXTERNALSYM VBICODECFILTERING_STATISTICS_TELETEXT_PIN} + PVBICODECFILTERING_STATISTICS_TELETEXT_PIN = ^VBICODECFILTERING_STATISTICS_TELETEXT_PIN; + {$EXTERNALSYM PVBICODECFILTERING_STATISTICS_TELETEXT_PIN} + TVBICodecFilteringStatisticsTeletextPin = _VBICODECFILTERING_STATISTICS_TELETEXT_PIN; + +//////////////////////////////////////////////////////////////////////////// +// VBI codec property structures(based on KSPROPERTY_VBICODECFILTERING enum) +//////////////////////////////////////////////////////////////////////////// + +// *** Most codecs support this property +// KSPROPERTY_VBICODECFILTERING_SCANLINES_REQUESTED_BIT_ARRAY +// KSPROPERTY_VBICODECFILTERING_SCANLINES_DISCOVERED_BIT_ARRAY, + PKSPropertyVBICodecFilteringScanlinesS = ^TKSPropertyVBICodecFilteringScanlinesS; + KSPROPERTY_VBICODECFILTERING_SCANLINES_S = record + Property_ : KSPROPERTY; + Scanlines : TVBICodecFilteringScanlines; + end; + {$EXTERNALSYM KSPROPERTY_VBICODECFILTERING_SCANLINES_S} + PKSPROPERTY_VBICODECFILTERING_SCANLINES_S = ^KSPROPERTY_VBICODECFILTERING_SCANLINES_S; + {$EXTERNALSYM PKSPROPERTY_VBICODECFILTERING_SCANLINES_S} + TKSPropertyVBICodecFilteringScanlinesS = KSPROPERTY_VBICODECFILTERING_SCANLINES_S; + +// *** NABTS codecs support this property +// KSPROPERTY_VBICODECFILTERING_SUBSTREAMS_REQUESTED_BIT_ARRAY, +// KSPROPERTY_VBICODECFILTERING_SUBSTREAMS_DISCOVERED_BIT_ARRAY, + PKSPropertyVBICodecFilteringNABTSSubstreamsS = ^TKSPropertyVBICodecFilteringNABTSSubstreamsS; + KSPROPERTY_VBICODECFILTERING_NABTS_SUBSTREAMS_S = record + Property_ : KSPROPERTY; + Substreams : TVBICodecFilteringNABTSSubStreams; + end; + {$EXTERNALSYM KSPROPERTY_VBICODECFILTERING_NABTS_SUBSTREAMS_S} + PKSPROPERTY_VBICODECFILTERING_NABTS_SUBSTREAMS_S = ^KSPROPERTY_VBICODECFILTERING_NABTS_SUBSTREAMS_S; + {$EXTERNALSYM PKSPROPERTY_VBICODECFILTERING_NABTS_SUBSTREAMS_S} + TKSPropertyVBICodecFilteringNABTSSubstreamsS = KSPROPERTY_VBICODECFILTERING_NABTS_SUBSTREAMS_S; + +// *** Closed captioning codecs support this property +// KSPROPERTY_VBICODECFILTERING_SUBSTREAMS_REQUESTED_BIT_ARRAY, +// KSPROPERTY_VBICODECFILTERING_SUBSTREAMS_DISCOVERED_BIT_ARRAY, + PKSPropertyVBICodecFilteringCCSubstreamsS = ^TKSPropertyVBICodecFilteringCCSubstreamsS; + KSPROPERTY_VBICODECFILTERING_CC_SUBSTREAMS_S = record + Property_ : KSPROPERTY; + Substreams : TVBICodecFilteringCCSubStreams; + end; + {$EXTERNALSYM KSPROPERTY_VBICODECFILTERING_CC_SUBSTREAMS_S} + PKSPROPERTY_VBICODECFILTERING_CC_SUBSTREAMS_S = ^KSPROPERTY_VBICODECFILTERING_CC_SUBSTREAMS_S; + {$EXTERNALSYM PKSPROPERTY_VBICODECFILTERING_CC_SUBSTREAMS_S} + TKSPropertyVBICodecFilteringCCSubstreamsS = KSPROPERTY_VBICODECFILTERING_CC_SUBSTREAMS_S; + +// *** Most codecs support these versions of the global and pin properties +// KSPROPERTY_VBICODECFILTERING_STATISTICS + PKSPropertyVBICodecFilteringStatisticsCommonS = ^TKSPropertyVBICodecFilteringStatisticsCommonS; + KSPROPERTY_VBICODECFILTERING_STATISTICS_COMMON_S = record + Property_ : KSPROPERTY; + Statistics : TVBICodecFilteringStatisticsCommon; + end; + {$EXTERNALSYM KSPROPERTY_VBICODECFILTERING_STATISTICS_COMMON_S} + PKSPROPERTY_VBICODECFILTERING_STATISTICS_COMMON_S = ^KSPROPERTY_VBICODECFILTERING_STATISTICS_COMMON_S; + {$EXTERNALSYM PKSPROPERTY_VBICODECFILTERING_STATISTICS_COMMON_S} + TKSPropertyVBICodecFilteringStatisticsCommonS = KSPROPERTY_VBICODECFILTERING_STATISTICS_COMMON_S; + + PKSPropertyVBICodecFilteringStatisticsCommonPinS = ^TKSPropertyVBICodecFilteringStatisticsCommonPinS; + KSPROPERTY_VBICODECFILTERING_STATISTICS_COMMON_PIN_S = record + Property_ : KSPROPERTY; + Statistics : TVBICodecFilteringStatisticsCommonPin; + end; + {$EXTERNALSYM KSPROPERTY_VBICODECFILTERING_STATISTICS_COMMON_PIN_S} + PKSPROPERTY_VBICODECFILTERING_STATISTICS_COMMON_PIN_S = ^KSPROPERTY_VBICODECFILTERING_STATISTICS_COMMON_PIN_S; + {$EXTERNALSYM PKSPROPERTY_VBICODECFILTERING_STATISTICS_COMMON_PIN_S} + TKSPropertyVBICodecFilteringStatisticsCommonPinS = KSPROPERTY_VBICODECFILTERING_STATISTICS_COMMON_PIN_S; + +// *** NABTS codecs support this version of the global and pin properties +// KSPROPERTY_VBICODECFILTERING_STATISTICS + PKSPropertyVBICodecFilteringStatisticsNABTSS = ^TKSPropertyVBICodecFilteringStatisticsNABTSS; + KSPROPERTY_VBICODECFILTERING_STATISTICS_NABTS_S = record + Property_ : KSPROPERTY; + Statistics : TVBICodecFilteringStatisticsNABTS; + end; + {$EXTERNALSYM KSPROPERTY_VBICODECFILTERING_STATISTICS_NABTS_S} + PKSPROPERTY_VBICODECFILTERING_STATISTICS_NABTS_S = ^KSPROPERTY_VBICODECFILTERING_STATISTICS_NABTS_S; + {$EXTERNALSYM PKSPROPERTY_VBICODECFILTERING_STATISTICS_NABTS_S} + TKSPropertyVBICodecFilteringStatisticsNABTSS = KSPROPERTY_VBICODECFILTERING_STATISTICS_NABTS_S; + + PKSPropertyVBICodecFilteringStatisticsNABTSPinS = ^TKSPropertyVBICodecFilteringStatisticsNABTSPinS; + KSPROPERTY_VBICODECFILTERING_STATISTICS_NABTS_PIN_S = record + Property_ : KSPROPERTY; + Statistics : TVBICodecFilteringStatisticsNABTSPin; + end; + {$EXTERNALSYM KSPROPERTY_VBICODECFILTERING_STATISTICS_NABTS_PIN_S} + PKSPROPERTY_VBICODECFILTERING_STATISTICS_NABTS_PIN_S = ^KSPROPERTY_VBICODECFILTERING_STATISTICS_NABTS_PIN_S; + {$EXTERNALSYM PKSPROPERTY_VBICODECFILTERING_STATISTICS_NABTS_PIN_S} + TKSPropertyVBICodecFilteringStatisticsNABTSPinS = KSPROPERTY_VBICODECFILTERING_STATISTICS_NABTS_PIN_S; + +// *** Closed captioning codecs support this version of the global and pin properties +// KSPROPERTY_VBICODECFILTERING_STATISTICS + + PKSPropertyVBICodecFilteringStatisticsCCS = ^TKSPropertyVBICodecFilteringStatisticsCCS; + KSPROPERTY_VBICODECFILTERING_STATISTICS_CC_S = record + Property_ : KSPROPERTY; + Statistics : TVBICodecFilteringStatisticsCC; + end; + {$EXTERNALSYM KSPROPERTY_VBICODECFILTERING_STATISTICS_CC_S} + PKSPROPERTY_VBICODECFILTERING_STATISTICS_CC_S = ^KSPROPERTY_VBICODECFILTERING_STATISTICS_CC_S; + {$EXTERNALSYM PKSPROPERTY_VBICODECFILTERING_STATISTICS_CC_S} + TKSPropertyVBICodecFilteringStatisticsCCS = KSPROPERTY_VBICODECFILTERING_STATISTICS_CC_S; + + PKSPropertyVBICodecFilteringStatisticsCCPinS = ^TKSPropertyVBICodecFilteringStatisticsCCPinS; + KSPROPERTY_VBICODECFILTERING_STATISTICS_CC_PIN_S = record + Property_ : KSPROPERTY; + Statistics : TVBICodecFilteringStatisticsCCPin; + end; + {$EXTERNALSYM KSPROPERTY_VBICODECFILTERING_STATISTICS_CC_PIN_S} + PKSPROPERTY_VBICODECFILTERING_STATISTICS_CC_PIN_S = ^KSPROPERTY_VBICODECFILTERING_STATISTICS_CC_PIN_S; + {$EXTERNALSYM PKSPROPERTY_VBICODECFILTERING_STATISTICS_CC_PIN_S} + TKSPropertyVBICodecFilteringStatisticsCCPinS = KSPROPERTY_VBICODECFILTERING_STATISTICS_CC_PIN_S; + +// Standard Pin Names for the video capture filter +//=========================================================================== +const + PINNAME_VIDEO_CAPTURE : TGUID = '{FB6C4281-0353-11d1-905F-0000C0CC16BA}'; + {$EXTERNALSYM PINNAME_VIDEO_CAPTURE} + PINNAME_VIDEO_CC_CAPTURE : TGUID = '{1AAD8061-012D-11d2-B4B1-00A0D102CFBE}'; + {$EXTERNALSYM PINNAME_VIDEO_CC_CAPTURE} + PINNAME_VIDEO_NABTS_CAPTURE : TGUID = '{29703660-498A-11d2-B4B1-00A0D102CFBE}'; + {$EXTERNALSYM PINNAME_VIDEO_NABTS_CAPTURE} + PINNAME_VIDEO_PREVIEW : TGUID = '{FB6C4282-0353-11d1-905F-0000C0CC16BA}'; + {$EXTERNALSYM PINNAME_VIDEO_PREVIEW} + PINNAME_VIDEO_ANALOGVIDEOIN : TGUID = '{FB6C4283-0353-11d1-905F-0000C0CC16BA}'; + {$EXTERNALSYM PINNAME_VIDEO_ANALOGVIDEOIN} + PINNAME_VIDEO_VBI : TGUID = '{FB6C4284-0353-11d1-905F-0000C0CC16BA}'; + {$EXTERNALSYM PINNAME_VIDEO_VBI} + PINNAME_VIDEO_VIDEOPORT : TGUID = '{FB6C4285-0353-11d1-905F-0000C0CC16BA}'; + {$EXTERNALSYM PINNAME_VIDEO_VIDEOPORT} + PINNAME_VIDEO_NABTS : TGUID = '{FB6C4286-0353-11d1-905F-0000C0CC16BA}'; + {$EXTERNALSYM PINNAME_VIDEO_NABTS} + PINNAME_VIDEO_EDS : TGUID = '{FB6C4287-0353-11d1-905F-0000C0CC16BA}'; + {$EXTERNALSYM PINNAME_VIDEO_EDS} + PINNAME_VIDEO_TELETEXT : TGUID = '{FB6C4288-0353-11d1-905F-0000C0CC16BA}'; + {$EXTERNALSYM PINNAME_VIDEO_TELETEXT} + PINNAME_VIDEO_CC : TGUID = '{FB6C4289-0353-11d1-905F-0000C0CC16BA}'; + {$EXTERNALSYM PINNAME_VIDEO_CC} + PINNAME_VIDEO_STILL : TGUID = '{FB6C428A-0353-11d1-905F-0000C0CC16BA}'; + {$EXTERNALSYM PINNAME_VIDEO_STILL} + PINNAME_VIDEO_TIMECODE : TGUID = '{FB6C428B-0353-11d1-905F-0000C0CC16BA}'; + {$EXTERNALSYM PINNAME_VIDEO_TIMECODE} + PINNAME_VIDEO_VIDEOPORT_VBI : TGUID = '{FB6C428C-0353-11d1-905F-0000C0CC16BA}'; + {$EXTERNALSYM PINNAME_VIDEO_VIDEOPORT_VBI} + +//=========================================================================== +// KSSTREAM_HEADER extensions for digital video +//=========================================================================== + + KS_VIDEO_FLAG_FRAME = $0000; // Frame or Field (default is frame) + {$EXTERNALSYM KS_VIDEO_FLAG_FRAME} + KS_VIDEO_FLAG_FIELD1 = $0001; + {$EXTERNALSYM KS_VIDEO_FLAG_FIELD1} + KS_VIDEO_FLAG_FIELD2 = $0002; + {$EXTERNALSYM KS_VIDEO_FLAG_FIELD2} + + KS_VIDEO_FLAG_I_FRAME = $0000; // I, B, or P (default is I) + {$EXTERNALSYM KS_VIDEO_FLAG_I_FRAME} + KS_VIDEO_FLAG_P_FRAME = $0010; + {$EXTERNALSYM KS_VIDEO_FLAG_P_FRAME} + KS_VIDEO_FLAG_B_FRAME = $0020; + {$EXTERNALSYM KS_VIDEO_FLAG_B_FRAME} + +type + PKSFrameInfo = ^TKSFrameInfo; + tagKS_FRAME_INFO = record + ExtendedHeaderSize : ULONG; // Size of this extended header + dwFrameFlags : DWORD; // Field1, Field2, or Frame + PictureNumber : int64; + DropCount : int64; + + // The following are only set when using OverlayMixer + hDirectDraw : THandle; // user mode DDraw handle + hSurfaceHandle : THandle; // user mode surface handle + DirectDrawRect : TRECT; // portion of surface locked + // Reserved fields, never reference these + Reserved1 : DWORD; + Reserved2 : DWORD; + Reserved3 : DWORD; + Reserved4 : DWORD; + end; + {$EXTERNALSYM tagKS_FRAME_INFO} + KS_FRAME_INFO = tagKS_FRAME_INFO; + {$EXTERNALSYM KS_FRAME_INFO} + PKS_FRAME_INFO = ^KS_FRAME_INFO; + {$EXTERNALSYM PKS_FRAME_INFO} + TKSFrameInfo = tagKS_FRAME_INFO; + +//=========================================================================== +// KSSTREAM_HEADER extensions for VBI +//=========================================================================== +const + KS_VBI_FLAG_FIELD1 = $0001; + {$EXTERNALSYM KS_VBI_FLAG_FIELD1} + KS_VBI_FLAG_FIELD2 = $0002; + {$EXTERNALSYM KS_VBI_FLAG_FIELD2} + + KS_VBI_FLAG_MV_PRESENT = $0100; + {$EXTERNALSYM KS_VBI_FLAG_MV_PRESENT} + KS_VBI_FLAG_MV_HARDWARE = $0200; + {$EXTERNALSYM KS_VBI_FLAG_MV_HARDWARE} + KS_VBI_FLAG_MV_DETECTED = $0400; + {$EXTERNALSYM KS_VBI_FLAG_MV_DETECTED} + + KS_VBI_FLAG_TVTUNER_CHANGE = $0010; // TvTunerChangeInfo is valid + {$EXTERNALSYM KS_VBI_FLAG_TVTUNER_CHANGE} + KS_VBI_FLAG_VBIINFOHEADER_CHANGE = $0020; // VBIInfoHeader is valid + {$EXTERNALSYM KS_VBI_FLAG_VBIINFOHEADER_CHANGE} + +type + PKSVBIFrameInfo = ^TKSVBIFrameInfo; + tagKS_VBI_FRAME_INFO = record + ExtendedHeaderSize : ULONG; // Size of this extended header + dwFrameFlags : DWORD; // Field1, Field2, or Frame; & etc + PictureNumber : int64; // Test only? + DropCount : int64; // Test only? + dwSamplingFrequency : DWORD; + TvTunerChangeInfo : TKSTVTunerChangeInfo; + VBIInfoHeader : TKSVBIInfoHeader; + end; + {$EXTERNALSYM tagKS_VBI_FRAME_INFO} + KS_VBI_FRAME_INFO = tagKS_VBI_FRAME_INFO; + {$EXTERNALSYM KS_VBI_FRAME_INFO} + PKS_VBI_FRAME_INFO = ^KS_VBI_FRAME_INFO; + {$EXTERNALSYM PKS_VBI_FRAME_INFO} + TKSVBIFrameInfo = tagKS_VBI_FRAME_INFO; + + +//=========================================================================== +// Analog video formats, used with: +// Analog Video Decoders +// TVTuners +// Analog Video Encoders +// +// XXX_STANDARDS_SUPPORTED returns a bitmask +//=========================================================================== +const + KS_AnalogVideo_None = $00000000; // This is a digital sensor + {$EXTERNALSYM KS_AnalogVideo_None} + KS_AnalogVideo_NTSC_M = $00000001; // 75 IRE Setup + {$EXTERNALSYM KS_AnalogVideo_NTSC_M} + KS_AnalogVideo_NTSC_M_J = $00000002; // Japan, 0 IRE Setup + {$EXTERNALSYM KS_AnalogVideo_NTSC_M_J} + KS_AnalogVideo_NTSC_433 = $00000004; + {$EXTERNALSYM KS_AnalogVideo_NTSC_433} + KS_AnalogVideo_PAL_B = $00000010; + {$EXTERNALSYM KS_AnalogVideo_PAL_B} + KS_AnalogVideo_PAL_D = $00000020; + {$EXTERNALSYM KS_AnalogVideo_PAL_D} + KS_AnalogVideo_PAL_G = $00000040; + {$EXTERNALSYM KS_AnalogVideo_PAL_G} + KS_AnalogVideo_PAL_H = $00000080; + {$EXTERNALSYM KS_AnalogVideo_PAL_H} + KS_AnalogVideo_PAL_I = $00000100; + {$EXTERNALSYM KS_AnalogVideo_PAL_I} + KS_AnalogVideo_PAL_M = $00000200; + {$EXTERNALSYM KS_AnalogVideo_PAL_M} + KS_AnalogVideo_PAL_N = $00000400; + {$EXTERNALSYM KS_AnalogVideo_PAL_N} + KS_AnalogVideo_PAL_60 = $00000800; + {$EXTERNALSYM KS_AnalogVideo_PAL_60} + KS_AnalogVideo_SECAM_B = $00001000; + {$EXTERNALSYM KS_AnalogVideo_SECAM_B} + KS_AnalogVideo_SECAM_D = $00002000; + {$EXTERNALSYM KS_AnalogVideo_SECAM_D} + KS_AnalogVideo_SECAM_G = $00004000; + {$EXTERNALSYM KS_AnalogVideo_SECAM_G} + KS_AnalogVideo_SECAM_H = $00008000; + {$EXTERNALSYM KS_AnalogVideo_SECAM_H} + KS_AnalogVideo_SECAM_K = $00010000; + {$EXTERNALSYM KS_AnalogVideo_SECAM_K} + KS_AnalogVideo_SECAM_K1 = $00020000; + {$EXTERNALSYM KS_AnalogVideo_SECAM_K1} + KS_AnalogVideo_SECAM_L = $00040000; + {$EXTERNALSYM KS_AnalogVideo_SECAM_L} + KS_AnalogVideo_SECAM_L1 = $00080000; + {$EXTERNALSYM KS_AnalogVideo_SECAM_L1} + KS_AnalogVideo_PAL_N_COMBO = $00100000; + {$EXTERNALSYM KS_AnalogVideo_PAL_N_COMBO} + + + KS_AnalogVideo_NTSC_Mask = $00000007; + {$EXTERNALSYM KS_AnalogVideo_NTSC_Mask} + KS_AnalogVideo_PAL_Mask = $00100FF0; + {$EXTERNALSYM KS_AnalogVideo_PAL_Mask} + KS_AnalogVideo_SECAM_Mask = $000FF000; + {$EXTERNALSYM KS_AnalogVideo_SECAM_Mask} + +//=========================================================================== +// Property set definitions +// The comments show whether a given property is: +// R : READ only +// w : WRITE only +// RW : READ / WRITE +// O : Optional (return E_UNSUPPORTED if you don't handle this) +//=========================================================================== + + PROPSETID_ALLOCATOR_CONTROL : TGUID = '{53171960-148E-11d2-9979-0000C0CC16BA}'; + {$EXTERNALSYM PROPSETID_ALLOCATOR_CONTROL} + +type + KSPROPERTY_ALLOCATOR_CONTROL = ( + KSPROPERTY_ALLOCATOR_CONTROL_HONOR_COUNT, // R O (will allocate exactly this number of buffers) + KSPROPERTY_ALLOCATOR_CONTROL_SURFACE_SIZE // R O (return 2 DWORDs specifying surface size) + ); + {$EXTERNALSYM KSPROPERTY_ALLOCATOR_CONTROL} + TKSPropertyAllocatorControl = KSPROPERTY_ALLOCATOR_CONTROL; + +//=========================================================================== + +const + PROPSETID_VIDCAP_VIDEOPROCAMP : TGUID = '{C6E13360-30AC-11d0-A18C-00A0C9118956}'; + {$EXTERNALSYM PROPSETID_VIDCAP_VIDEOPROCAMP} + +type + KSPROPERTY_VIDCAP_VIDEOPROCAMP = ( + KSPROPERTY_VIDEOPROCAMP_BRIGHTNESS, // RW O + KSPROPERTY_VIDEOPROCAMP_CONTRAST, // RW O + KSPROPERTY_VIDEOPROCAMP_HUE, // RW O + KSPROPERTY_VIDEOPROCAMP_SATURATION, // RW O + KSPROPERTY_VIDEOPROCAMP_SHARPNESS, // RW O + KSPROPERTY_VIDEOPROCAMP_GAMMA, // RW O + KSPROPERTY_VIDEOPROCAMP_COLORENABLE, // RW O + KSPROPERTY_VIDEOPROCAMP_WHITEBALANCE, // RW O + KSPROPERTY_VIDEOPROCAMP_BACKLIGHT_COMPENSATION, // RW O + KSPROPERTY_VIDEOPROCAMP_GAIN, // RW O + KSPROPERTY_VIDEOPROCAMP_DIGITAL_MULTIPLIER, // RW O + KSPROPERTY_VIDEOPROCAMP_DIGITAL_MULTIPLIER_LIMIT,// RW O + KSPROPERTY_VIDEOPROCAMP_WHITEBALANCE_COMPONENT, // RW O + KSPROPERTY_VIDEOPROCAMP_POWERLINE_FREQUENCY // RW O + ); + {$EXTERNALSYM KSPROPERTY_VIDCAP_VIDEOPROCAMP} + TKSPropertyVidcapVideoProcAmp = KSPROPERTY_VIDCAP_VIDEOPROCAMP; + + PKSPropertyVideoProcAmpS = ^TKSPropertyVideoProcAmpS; + KSPROPERTY_VIDEOPROCAMP_S = record + Property_ : KSPROPERTY; + Value : longint; // Value to set or get + Flags : ULONG; // KSPROPERTY_VIDEOPROCAMP_FLAGS_* + Capabilities : ULONG; // KSPROPERTY_VIDEOPROCAMP_FLAGS_* + end; + {$EXTERNALSYM KSPROPERTY_VIDEOPROCAMP_S} + PKSPROPERTY_VIDEOPROCAMP_S = ^KSPROPERTY_VIDEOPROCAMP_S; + {$EXTERNALSYM PKSPROPERTY_VIDEOPROCAMP_S} + TKSPropertyVideoProcAmpS = KSPROPERTY_VIDEOPROCAMP_S; + + PKSPropertyVideoProcAmpNodeS = ^TKSPropertyVideoProcAmpNodeS; + KSPROPERTY_VIDEOPROCAMP_NODE_S = packed record + NodeProperty: KSP_NODE; + Value: Integer; // Value to set or get + Flags: ULONG; // KSPROPERTY_VIDEOPROCAMP_FLAGS_* + Capabilities: ULONG; // KSPROPERTY_VIDEOPROCAMP_FLAGS_* + end; + {$EXTERNALSYM KSPROPERTY_VIDEOPROCAMP_NODE_S} + PKSPROPERTY_VIDEOPROCAMP_NODE_S = ^KSPROPERTY_VIDEOPROCAMP_NODE_S; + {$EXTERNALSYM PKSPROPERTY_VIDEOPROCAMP_NODE_S} + TKSPropertyVideoProcAmpNodeS = KSPROPERTY_VIDEOPROCAMP_NODE_S; + + PKSPropertyVideoProcAmpS2 = ^TKSPropertyVideoProcAmpS2; + KSPROPERTY_VIDEOPROCAMP_S2 = packed record + Property_: KSPROPERTY; + Value1: Integer; + Flags: ULONG; + Capabilities: ULONG; + Value2: Integer; + end; + {$EXTERNALSYM KSPROPERTY_VIDEOPROCAMP_S2} + PKSPROPERTY_VIDEOPROCAMP_S2 = ^KSPROPERTY_VIDEOPROCAMP_S2; + {$EXTERNALSYM PKSPROPERTY_VIDEOPROCAMP_S2} + TKSPropertyVideoProcAmpS2 = KSPROPERTY_VIDEOPROCAMP_S2; + + PKSPropertyVideoProcAmpNodeS2 = ^TKSPropertyVideoProcAmpNodeS2; + KSPROPERTY_VIDEOPROCAMP_NODE_S2 = packed record + NodeProperty: KSP_NODE; + Value1: Integer; + Flags: ULONG; + Capabilities: ULONG; + Value2: Integer; + end; + {$EXTERNALSYM KSPROPERTY_VIDEOPROCAMP_NODE_S2} + PKSPROPERTY_VIDEOPROCAMP_NODE_S2 = ^KSPROPERTY_VIDEOPROCAMP_NODE_S2; + {$EXTERNALSYM PKSPROPERTY_VIDEOPROCAMP_NODE_S2} + TKSPropertyVideoProcAmpNodeS2 = KSPROPERTY_VIDEOPROCAMP_NODE_S2; + +const + KSPROPERTY_VIDEOPROCAMP_FLAGS_AUTO = $0001; + {$EXTERNALSYM KSPROPERTY_VIDEOPROCAMP_FLAGS_AUTO} + KSPROPERTY_VIDEOPROCAMP_FLAGS_MANUAL = $0002; + {$EXTERNALSYM KSPROPERTY_VIDEOPROCAMP_FLAGS_MANUAL} + +//=========================================================================== + + PROPSETID_VIDCAP_SELECTOR : TGUID = '{1ABDAECA-68B6-4F83-9371-B413907C7B9F}'; + {$EXTERNALSYM PROPSETID_VIDCAP_SELECTOR} + +type + PKSPropertyVidCapSelector = ^TKSPropertyVidCapSelector; + KSPROPERTY_VIDCAP_SELECTOR = ( + KSPROPERTY_SELECTOR_SOURCE_NODE_ID, // RW + KSPROPERTY_SELECTOR_NUM_SOURCES // R + ); + {$EXTERNALSYM KSPROPERTY_VIDCAP_SELECTOR} + PKSPROPERTY_VIDCAP_SELECTOR = ^KSPROPERTY_VIDCAP_SELECTOR; + {$EXTERNALSYM PKSPROPERTY_VIDCAP_SELECTOR} + TKSPropertyVidCapSelector = KSPROPERTY_VIDCAP_SELECTOR; + + PKSPropertySelectorS = ^TKSPropertySelectorS; + KSPROPERTY_SELECTOR_S = packed record + Property_: KSPROPERTY; + Value: Integer; // Value to set or get + Flags: ULONG; + Capabilities: ULONG; + end; + {$EXTERNALSYM KSPROPERTY_SELECTOR_S} + PKSPROPERTY_SELECTOR_S = ^KSPROPERTY_SELECTOR_S; + {$EXTERNALSYM PKSPROPERTY_SELECTOR_S} + TKSPropertySelectorS = KSPROPERTY_SELECTOR_S; + + PKSPropertySelectorNodeS = ^TKSPropertySelectorNodeS; + KSPROPERTY_SELECTOR_NODE_S = packed record + NodeProperty: KSP_NODE; + Value: Integer; // Value to set or get + Flags: ULONG; + Capabilities: ULONG; + end; + {$EXTERNALSYM KSPROPERTY_SELECTOR_NODE_S} + PKSPROPERTY_SELECTOR_NODE_S = ^KSPROPERTY_SELECTOR_NODE_S; + {$EXTERNALSYM PKSPROPERTY_SELECTOR_NODE_S} + TKSPropertySelectorNodeS = KSPROPERTY_SELECTOR_NODE_S; + +//=========================================================================== + +const + PROPSETID_TUNER : TGUID = '{6a2e0605-28e4-11d0-a18c-00a0c9118956}'; + {$EXTERNALSYM PROPSETID_TUNER} + +type + KSPROPERTY_TUNER = ( + KSPROPERTY_TUNER_CAPS, // R -overall device capabilities + KSPROPERTY_TUNER_MODE_CAPS, // R -capabilities in this mode + KSPROPERTY_TUNER_MODE, // RW -set a mode (TV, FM, AM, DSS) + KSPROPERTY_TUNER_STANDARD, // R -get TV standard (only if TV mode) + KSPROPERTY_TUNER_FREQUENCY, // RW -set/get frequency + KSPROPERTY_TUNER_INPUT, // RW -select an input + KSPROPERTY_TUNER_STATUS, // R -tuning status + KSPROPERTY_TUNER_IF_MEDIUM // R O-Medium for IF or Transport Pin + ); + {$EXTERNALSYM KSPROPERTY_TUNER} + TKSPropertyTuner = KSPROPERTY_TUNER; + + KSPROPERTY_TUNER_MODES = {$IFDEF TYPE_IDENTITY}type {$ENDIF} LongWord; + {$EXTERNALSYM KSPROPERTY_TUNER_MODES} + const + KSPROPERTY_TUNER_MODE_TV = $0001; + {$EXTERNALSYM KSPROPERTY_TUNER_MODE_TV} + KSPROPERTY_TUNER_MODE_FM_RADIO = $0002; + {$EXTERNALSYM KSPROPERTY_TUNER_MODE_FM_RADIO} + KSPROPERTY_TUNER_MODE_AM_RADIO = $0004; + {$EXTERNALSYM KSPROPERTY_TUNER_MODE_AM_RADIO} + KSPROPERTY_TUNER_MODE_DSS = $0008; + {$EXTERNALSYM KSPROPERTY_TUNER_MODE_DSS} + KSPROPERTY_TUNER_MODE_ATSC = $0010; // also used for DVB-T, DVB-C + {$EXTERNALSYM KSPROPERTY_TUNER_MODE_ATSC} + +// Describes how the device tunes. Only one of these flags may be set +// in KSPROPERTY_TUNER_MODE_CAPS_S.Strategy + +// Describe how the driver should attempt to tune: +// EXACT: just go to the frequency specified (no fine tuning) +// FINE: (slow) do an exhaustive search for the best signal +// COARSE: (fast) use larger frequency jumps to just determine if any signal + +type + KS_TUNER_TUNING_FLAGS = ( + {$IFNDEF COMPILER6_UP} + KS_TUNER_TUNING_INVALID_0, + KS_TUNER_TUNING_EXACT, // No fine tuning + {$ELSE} + KS_TUNER_TUNING_EXACT = 1, + {$ENDIF} + KS_TUNER_TUNING_FINE, // Fine grained search + KS_TUNER_TUNING_COARSE // Coarse search + ); + {$EXTERNALSYM KS_TUNER_TUNING_FLAGS} + + KS_TUNER_STRATEGY = {$IFDEF TYPE_IDENTITY}type {$ENDIF} LongWord; + {$EXTERNALSYM KS_TUNER_STRATEGY} + const + KS_TUNER_STRATEGY_PLL = $01; // Tune by PLL offset + {$EXTERNALSYM KS_TUNER_STRATEGY_PLL} + KS_TUNER_STRATEGY_SIGNAL_STRENGTH = $02; // Tune by signal strength + {$EXTERNALSYM KS_TUNER_STRATEGY_SIGNAL_STRENGTH} + KS_TUNER_STRATEGY_DRIVER_TUNES = $04; // Driver does fine tuning + {$EXTERNALSYM KS_TUNER_STRATEGY_DRIVER_TUNES} + +type + PKSPropertyTunerCapsS = ^TKSPropertyTunerCapsS; + KSPROPERTY_TUNER_CAPS_S = record + Property_ : KSPROPERTY ; + ModesSupported : ULONG ; // KS_PROPERTY_TUNER_MODES_* + VideoMedium : TKSPinMedium ; // GUID_NULL (no pin), or GUID + TVAudioMedium : TKSPinMedium ; // GUID_NULL (no pin), or GUID + RadioAudioMedium : TKSPinMedium ; // GUID_NULL (no pin), or GUID + end; + {$EXTERNALSYM KSPROPERTY_TUNER_CAPS_S} + PKSPROPERTY_TUNER_CAPS_S = ^KSPROPERTY_TUNER_CAPS_S; + {$EXTERNALSYM PKSPROPERTY_TUNER_CAPS_S} + TKSPropertyTunerCapsS = KSPROPERTY_TUNER_CAPS_S; + + PKSPropertyTunerIfMediumS = ^TKSPropertyTunerIfMediumS; + KSPROPERTY_TUNER_IF_MEDIUM_S = record + Property_ : KSPROPERTY; + IFMedium : TKSPinMedium; // GUID_NULL (no pin), or GUID + end; + {$EXTERNALSYM KSPROPERTY_TUNER_IF_MEDIUM_S} + PKSPROPERTY_TUNER_IF_MEDIUM_S = ^KSPROPERTY_TUNER_IF_MEDIUM_S; + {$EXTERNALSYM PKSPROPERTY_TUNER_IF_MEDIUM_S} + TKSPropertyTunerIfMediumS = KSPROPERTY_TUNER_IF_MEDIUM_S; + + PKSPropertyTunerModeCapsS = ^TKSPropertyTunerModeCapsS; + KSPROPERTY_TUNER_MODE_CAPS_S = record + Property_ : KSPROPERTY; + Mode : ULONG; // IN: KSPROPERTY_TUNER_MODE + StandardsSupported : ULONG; // KS_AnalogVideo_* (if TV or DSS) + MinFrequency : ULONG; // Hz + MaxFrequency : ULONG; // Hz + TuningGranularity : ULONG; // Hz + NumberOfInputs : ULONG; // count of inputs + SettlingTime : ULONG; // milliSeconds + Strategy : ULONG; // KS_TUNER_STRATEGY + end; + {$EXTERNALSYM KSPROPERTY_TUNER_MODE_CAPS_S} + PKSPROPERTY_TUNER_MODE_CAPS_S = ^KSPROPERTY_TUNER_MODE_CAPS_S; + {$EXTERNALSYM PKSPROPERTY_TUNER_MODE_CAPS_S} + TKSPropertyTunerModeCapsS = KSPROPERTY_TUNER_MODE_CAPS_S; + + PKSPropertyTunerModeS = ^TKSPropertyTunerModeS; + KSPROPERTY_TUNER_MODE_S = record + Property_ : KSPROPERTY; + Mode : ULONG; // IN: KSPROPERTY_TUNER_MODE + end; + {$EXTERNALSYM KSPROPERTY_TUNER_MODE_S} + PKSPROPERTY_TUNER_MODE_S = ^KSPROPERTY_TUNER_MODE_S; + {$EXTERNALSYM PKSPROPERTY_TUNER_MODE_S} + TKSPropertyTunerModeS = KSPROPERTY_TUNER_MODE_S; + + PKSPropertyTunerFrequencyS = ^TKSPropertyTunerFrequencyS; + KSPROPERTY_TUNER_FREQUENCY_S = record + Property_ : KSPROPERTY; + Frequency : ULONG; // Hz + LastFrequency : ULONG; // Hz (last known good) + TuningFlags : ULONG; // KS_TUNER_TUNING_FLAGS + VideoSubChannel : ULONG; // DSS + AudioSubChannel : ULONG; // DSS + Channel : ULONG; // VBI decoders + Country : ULONG; // VBI decoders + end; + {$EXTERNALSYM KSPROPERTY_TUNER_FREQUENCY_S} + PKSPROPERTY_TUNER_FREQUENCY_S = ^KSPROPERTY_TUNER_FREQUENCY_S; + {$EXTERNALSYM PKSPROPERTY_TUNER_FREQUENCY_S} + TKSPropertyTunerFrequencyS = KSPROPERTY_TUNER_FREQUENCY_S; + + PKSPropertyTunerStandardS = ^TKSPropertyTunerStandardS; + KSPROPERTY_TUNER_STANDARD_S = record + Property_ : KSPROPERTY; + Standard : ULONG; // KS_AnalogVideo_* + end; + {$EXTERNALSYM KSPROPERTY_TUNER_STANDARD_S} + PKSPROPERTY_TUNER_STANDARD_S = ^KSPROPERTY_TUNER_STANDARD_S; + {$EXTERNALSYM PKSPROPERTY_TUNER_STANDARD_S} + TKSPropertyTunerStandardS = KSPROPERTY_TUNER_STANDARD_S; + + PKSPropertyTunerInputS = ^TKSPropertyTunerInputS; + KSPROPERTY_TUNER_INPUT_S = record + Property_ : KSPROPERTY; + InputIndex : ULONG; // 0 to (n-1) inputs + end; + {$EXTERNALSYM KSPROPERTY_TUNER_INPUT_S} + PKSPROPERTY_TUNER_INPUT_S = ^KSPROPERTY_TUNER_INPUT_S; + {$EXTERNALSYM PKSPROPERTY_TUNER_INPUT_S} + TKSPropertyTunerInputS = KSPROPERTY_TUNER_INPUT_S; + + PKSPropertyTunerStatusS = ^TKSPropertyTunerStatusS; + KSPROPERTY_TUNER_STATUS_S = record + Property_ : KSPROPERTY; + CurrentFrequency : ULONG; // Hz + PLLOffset : ULONG; // if Strategy.KS_TUNER_STRATEGY_PLL + SignalStrength : ULONG; // if Stretegy.KS_TUNER_STRATEGY_SIGNAL_STRENGTH + Busy : ULONG; // TRUE if in the process of tuning + end; + {$EXTERNALSYM KSPROPERTY_TUNER_STATUS_S} + PKSPROPERTY_TUNER_STATUS_S = ^KSPROPERTY_TUNER_STATUS_S; + {$EXTERNALSYM PKSPROPERTY_TUNER_STATUS_S} + TKSPropertyTunerStatusS = KSPROPERTY_TUNER_STATUS_S; + +const + EVENTSETID_TUNER : TGUID = '{6a2e0606-28e4-11d0-a18c-00a0c9118956}'; + {$EXTERNALSYM EVENTSETID_TUNER} + +type + KSEVENT_TUNER = ( + KSEVENT_TUNER_CHANGED + ); + {$EXTERNALSYM KSEVENT_TUNER} + TKSEventTuner = KSEVENT_TUNER; + +//=========================================================================== + +// USB Video Class Definitions +const + KSNODETYPE_VIDEO_STREAMING : TGUID = '{DFF229E1-F70F-11D0-B917-00A0C9223196}'; + {$EXTERNALSYM KSNODETYPE_VIDEO_STREAMING} + KSNODETYPE_VIDEO_INPUT_TERMINAL : TGUID = '{DFF229E2-F70F-11D0-B917-00A0C9223196}'; + {$EXTERNALSYM KSNODETYPE_VIDEO_INPUT_TERMINAL} + KSNODETYPE_VIDEO_OUTPUT_TERMINAL : TGUID = '{DFF229E3-F70F-11D0-B917-00A0C9223196}'; + {$EXTERNALSYM KSNODETYPE_VIDEO_OUTPUT_TERMINAL} + KSNODETYPE_VIDEO_SELECTOR : TGUID = '{DFF229E4-F70F-11D0-B917-00A0C9223196}'; + {$EXTERNALSYM KSNODETYPE_VIDEO_SELECTOR} + KSNODETYPE_VIDEO_PROCESSING : TGUID = '{DFF229E5-F70F-11D0-B917-00A0C9223196}'; + {$EXTERNALSYM KSNODETYPE_VIDEO_PROCESSING} + KSNODETYPE_VIDEO_CAMERA_TERMINAL : TGUID = '{DFF229E6-F70F-11D0-B917-00A0C9223196}'; + {$EXTERNALSYM KSNODETYPE_VIDEO_CAMERA_TERMINAL} + KSNODETYPE_VIDEO_INPUT_MTT : TGUID = '{DFF229E7-F70F-11D0-B917-00A0C9223196}'; + {$EXTERNALSYM KSNODETYPE_VIDEO_INPUT_MTT} + KSNODETYPE_VIDEO_OUTPUT_MTT : TGUID = '{DFF229E8-F70F-11D0-B917-00A0C9223196}'; + {$EXTERNALSYM KSNODETYPE_VIDEO_OUTPUT_MTT} + +//=========================================================================== + +const + PROPSETID_VIDCAP_VIDEOENCODER : TGUID = '{6a2e0610-28e4-11d0-a18c-00a0c9118956}'; + {$EXTERNALSYM PROPSETID_VIDCAP_VIDEOENCODER} + +type + KSPROPERTY_VIDCAP_VIDEOENCODER = ( + KSPROPERTY_VIDEOENCODER_CAPS, // R + KSPROPERTY_VIDEOENCODER_STANDARD, // RW + KSPROPERTY_VIDEOENCODER_COPYPROTECTION, // RW O + KSPROPERTY_VIDEOENCODER_CC_ENABLE // RW O + ); + {$EXTERNALSYM KSPROPERTY_VIDCAP_VIDEOENCODER} + TKSPropertyVidCapVideoEncoder = KSPROPERTY_VIDCAP_VIDEOENCODER; + + PKSPropertyVideoEncoderS = ^TKSPropertyVideoEncoderS; + KSPROPERTY_VIDEOENCODER_S = record + Property_ : KSPROPERTY; + Value : longint; // value to get or set + Flags : ULONG; // + Capabilities : ULONG; // + end; + {$EXTERNALSYM KSPROPERTY_VIDEOENCODER_S} + PKSPROPERTY_VIDEOENCODER_S = ^KSPROPERTY_VIDEOENCODER_S; + {$EXTERNALSYM PKSPROPERTY_VIDEOENCODER_S} + TKSPropertyVideoEncoderS = KSPROPERTY_VIDEOENCODER_S; + +//=========================================================================== +const + PROPSETID_VIDCAP_VIDEODECODER : TGUID = '{C6E13350-30AC-11d0-A18C-00A0C9118956}'; + {$EXTERNALSYM PROPSETID_VIDCAP_VIDEODECODER} + +type + KSPROPERTY_VIDCAP_VIDEODECODER = ( + KSPROPERTY_VIDEODECODER_CAPS, // R + KSPROPERTY_VIDEODECODER_STANDARD, // RW + KSPROPERTY_VIDEODECODER_STATUS, // R + KSPROPERTY_VIDEODECODER_OUTPUT_ENABLE, // Rw O + KSPROPERTY_VIDEODECODER_VCR_TIMING // RW O + ); + {$EXTERNALSYM KSPROPERTY_VIDCAP_VIDEODECODER} + TKSPropertyVidCapVideoDecoder = KSPROPERTY_VIDCAP_VIDEODECODER; + + KS_VIDEODECODER_FLAGS = {$IFDEF TYPE_IDENTITY}type {$ENDIF} LongWord; + {$EXTERNALSYM KS_VIDEODECODER_FLAGS} + const + KS_VIDEODECODER_FLAGS_CAN_DISABLE_OUTPUT = $0001; // VP Output can tri-stae + {$EXTERNALSYM KS_VIDEODECODER_FLAGS_CAN_DISABLE_OUTPUT} + KS_VIDEODECODER_FLAGS_CAN_USE_VCR_LOCKING = $0002; // VCR PLL timings + {$EXTERNALSYM KS_VIDEODECODER_FLAGS_CAN_USE_VCR_LOCKING} + KS_VIDEODECODER_FLAGS_CAN_INDICATE_LOCKED = $0004; // Can indicate valid signal + {$EXTERNALSYM KS_VIDEODECODER_FLAGS_CAN_INDICATE_LOCKED} + +type + PKSPropertyVideoDecoderCapsS = ^TKSPropertyVideoDecoderCapsS; + KSPROPERTY_VIDEODECODER_CAPS_S = record + Property_ : KSPROPERTY; + StandardsSupported : ULONG; // KS_AnalogVideo_* + Capabilities : ULONG; // KS_VIDEODECODER_FLAGS_* + SettlingTime : ULONG; // milliseconds + HSyncPerVSync : ULONG; // Number of HSync Pulses per VSync + end; + {$EXTERNALSYM KSPROPERTY_VIDEODECODER_CAPS_S} + PKSPROPERTY_VIDEODECODER_CAPS_S = ^KSPROPERTY_VIDEODECODER_CAPS_S; + {$EXTERNALSYM PKSPROPERTY_VIDEODECODER_CAPS_S} + TKSPropertyVideoDecoderCapsS = KSPROPERTY_VIDEODECODER_CAPS_S; + + PKSPropertyVideoDecoderStatusS = ^TKSPropertyVideoDecoderStatusS; + KSPROPERTY_VIDEODECODER_STATUS_S = record + Property_ : KSPROPERTY; + NumberOfLines : ULONG; // 525 or 625 lines detected + SignalLocked : ULONG; // TRUE if signal is locked + end; + {$EXTERNALSYM KSPROPERTY_VIDEODECODER_STATUS_S} + PKSPROPERTY_VIDEODECODER_STATUS_S = ^KSPROPERTY_VIDEODECODER_STATUS_S; + {$EXTERNALSYM PKSPROPERTY_VIDEODECODER_STATUS_S} + TKSPropertyVideoDecoderStatusS = KSPROPERTY_VIDEODECODER_STATUS_S; + + PKSPropertyVideoDecoderS = ^TKSPropertyVideoDecoderS; + KSPROPERTY_VIDEODECODER_S = record + Property_ : KSPROPERTY; + Value : ULONG; // Get or set a value + end; + {$EXTERNALSYM KSPROPERTY_VIDEODECODER_S} + PKSPROPERTY_VIDEODECODER_S = ^KSPROPERTY_VIDEODECODER_S; + {$EXTERNALSYM PKSPROPERTY_VIDEODECODER_S} + TKSPropertyVideoDecoderS = KSPROPERTY_VIDEODECODER_S; + +const + EVENTSETID_VIDEODECODER : TGUID = '{6a2e0621-28e4-11d0-a18c-00a0c9118956}'; + {$EXTERNALSYM EVENTSETID_VIDEODECODER} + +type + KSEVENT_VIDEODECODER = ( + KSEVENT_VIDEODECODER_CHANGED + ); + {$EXTERNALSYM KSEVENT_VIDEODECODER} + TKSEventVideoDecoder = KSEVENT_VIDEODECODER; + +//=========================================================================== +const + PROPSETID_VIDCAP_CAMERACONTROL : TGUID = '{C6E13370-30AC-11d0-A18C-00A0C9118956}'; + {$EXTERNALSYM PROPSETID_VIDCAP_CAMERACONTROL} + +type + KSPROPERTY_VIDCAP_CAMERACONTROL = ( + KSPROPERTY_CAMERACONTROL_PAN, // RW O + KSPROPERTY_CAMERACONTROL_TILT, // RW O + KSPROPERTY_CAMERACONTROL_ROLL, // RW O + KSPROPERTY_CAMERACONTROL_ZOOM, // RW O + KSPROPERTY_CAMERACONTROL_EXPOSURE, // RW O + KSPROPERTY_CAMERACONTROL_IRIS, // RW O + KSPROPERTY_CAMERACONTROL_FOCUS, // RW O + KSPROPERTY_CAMERACONTROL_SCANMODE, // RW O + KSPROPERTY_CAMERACONTROL_PRIVACY, // RW O + KSPROPERTY_CAMERACONTROL_PANTILT, // RW O + KSPROPERTY_CAMERACONTROL_PAN_RELATIVE, // RW O + KSPROPERTY_CAMERACONTROL_TILT_RELATIVE, // RW O + KSPROPERTY_CAMERACONTROL_ROLL_RELATIVE, // RW O + KSPROPERTY_CAMERACONTROL_ZOOM_RELATIVE, // RW O + KSPROPERTY_CAMERACONTROL_EXPOSURE_RELATIVE, // RW O + KSPROPERTY_CAMERACONTROL_IRIS_RELATIVE, // RW O + KSPROPERTY_CAMERACONTROL_FOCUS_RELATIVE, // RW O + KSPROPERTY_CAMERACONTROL_PANTILT_RELATIVE, // RW O + KSPROPERTY_CAMERACONTROL_FOCAL_LENGTH + ); + {$EXTERNALSYM KSPROPERTY_VIDCAP_CAMERACONTROL} + TKSPropertyVidCapCameraControl = KSPROPERTY_VIDCAP_CAMERACONTROL; + + PKSPropertyCameraControlS = ^TKSPropertyCameraControlS; + KSPROPERTY_CAMERACONTROL_S = record + Property_ : KSPROPERTY; + Value : longint; // value to get or set + Flags : ULONG; // KSPROPERTY_CAMERACONTROL_FLAGS_* + Capabilities : ULONG; // KSPROPERTY_CAMERACONTROL_FLAGS_* + end; + {$EXTERNALSYM KSPROPERTY_CAMERACONTROL_S} + PKSPROPERTY_CAMERACONTROL_S = ^KSPROPERTY_CAMERACONTROL_S; + {$EXTERNALSYM PKSPROPERTY_CAMERACONTROL_S} + TKSPropertyCameraControlS = KSPROPERTY_CAMERACONTROL_S; + + PKSPropertyCameraControlNodeS = ^TKSPropertyCameraControlNodeS; + KSPROPERTY_CAMERACONTROL_NODE_S = packed record + NodeProperty: KSP_NODE; + Value: Integer; // value to get or set + Flags: ULONG; // KSPROPERTY_CAMERACONTROL_FLAGS_* + Capabilities: ULONG; // KSPROPERTY_CAMERACONTROL_FLAGS_* + end; + {$EXTERNALSYM KSPROPERTY_CAMERACONTROL_NODE_S} + PKSPROPERTY_CAMERACONTROL_NODE_S = ^KSPROPERTY_CAMERACONTROL_NODE_S; + {$EXTERNALSYM PKSPROPERTY_CAMERACONTROL_NODE_S} + TKSPropertyCameraControlNodeS = KSPROPERTY_CAMERACONTROL_NODE_S; + + PKSPropertyCameraControlS2 = ^TKSPropertyCameraControlS2; + KSPROPERTY_CAMERACONTROL_S2 = packed record + Property_: KSPROPERTY; + Value1: Integer; + Flags: ULONG; + Capabilities: ULONG; + Value2: Integer; + end; + {$EXTERNALSYM KSPROPERTY_CAMERACONTROL_S2} + PKSPROPERTY_CAMERACONTROL_S2 = ^KSPROPERTY_CAMERACONTROL_S2; + {$EXTERNALSYM PKSPROPERTY_CAMERACONTROL_S2} + TKSPropertyCameraControlS2 = KSPROPERTY_CAMERACONTROL_S2; + + PKSPropertyCameraControlNodeS2 = ^TKSPropertyCameraControlNodeS2; + KSPROPERTY_CAMERACONTROL_NODE_S2 = packed record + NodeProperty: KSP_NODE ; + Value1: Integer; + Flags: ULONG; + Capabilities: ULONG; + Value2: Integer; + end; + {$EXTERNALSYM KSPROPERTY_CAMERACONTROL_NODE_S2} + PKSPROPERTY_CAMERACONTROL_NODE_S2 = ^KSPROPERTY_CAMERACONTROL_NODE_S2; + {$EXTERNALSYM PKSPROPERTY_CAMERACONTROL_NODE_S2} + TKSPropertyCameraControlNodeS2 = KSPROPERTY_CAMERACONTROL_NODE_S2; + + PKSPropertyCameraControlFocalLengthS = ^TKSPropertyCameraControlFocalLengthS; + KSPROPERTY_CAMERACONTROL_FOCAL_LENGTH_S = packed record + Property_: KSPROPERTY; + lOcularFocalLength: Integer; + lObjectiveFocalLengthMin: Integer; + lObjectiveFocalLengthMax: Integer; + end; + {$EXTERNALSYM KSPROPERTY_CAMERACONTROL_FOCAL_LENGTH_S} + PKSPROPERTY_CAMERACONTROL_FOCAL_LENGTH_S = ^KSPROPERTY_CAMERACONTROL_FOCAL_LENGTH_S; + {$EXTERNALSYM PKSPROPERTY_CAMERACONTROL_FOCAL_LENGTH_S} + TKSPropertyCameraControlFocalLengthS = KSPROPERTY_CAMERACONTROL_FOCAL_LENGTH_S; + + KSPROPERTY_CAMERACONTROL_NODE_FOCAL_LENGTH_S = packed record + NodeProperty: KSNODEPROPERTY; + lOcularFocalLength: Integer; + lObjectiveFocalLengthMin: Integer; + lObjectiveFocalLengthMax: Integer; + end; + {$EXTERNALSYM KSPROPERTY_CAMERACONTROL_NODE_FOCAL_LENGTH_S} + TKSPropertyCameraControlNodeFocalLengthS = KSPROPERTY_CAMERACONTROL_NODE_FOCAL_LENGTH_S; + +const + KSPROPERTY_CAMERACONTROL_FLAGS_AUTO = $0001; + {$EXTERNALSYM KSPROPERTY_CAMERACONTROL_FLAGS_AUTO} + KSPROPERTY_CAMERACONTROL_FLAGS_MANUAL = $0002; + {$EXTERNALSYM KSPROPERTY_CAMERACONTROL_FLAGS_MANUAL} + + KSPROPERTY_CAMERACONTROL_FLAGS_ABSOLUTE = $0000; + {$EXTERNALSYM KSPROPERTY_CAMERACONTROL_FLAGS_ABSOLUTE} + KSPROPERTY_CAMERACONTROL_FLAGS_RELATIVE = $0010; + {$EXTERNALSYM KSPROPERTY_CAMERACONTROL_FLAGS_RELATIVE} + +//=========================================================================== + + PROPSETID_VIDCAP_CROSSBAR : TGUID = '{6a2e0640-28e4-11d0-a18c-00a0c9118956}'; + {$EXTERNALSYM PROPSETID_VIDCAP_CROSSBAR} + +type + KSPROPERTY_VIDCAP_CROSSBAR = ( + KSPROPERTY_CROSSBAR_CAPS, // R + KSPROPERTY_CROSSBAR_PININFO, // R + KSPROPERTY_CROSSBAR_CAN_ROUTE, // R + KSPROPERTY_CROSSBAR_ROUTE // RW + ); + {$EXTERNALSYM KSPROPERTY_VIDCAP_CROSSBAR} + TKSPropertyVidCapCrossbar = KSPROPERTY_VIDCAP_CROSSBAR; + + PKSPropertyCrossbarCapsS = ^TKSPropertyCrossbarCapsS; + KSPROPERTY_CROSSBAR_CAPS_S = record + Property_ : KSPROPERTY; + NumberOfInputs : ULONG; // the number of audio and video input pins + NumberOfOutputs : ULONG; // the number of audio and video output pins + end; + {$EXTERNALSYM KSPROPERTY_CROSSBAR_CAPS_S} + PKSPROPERTY_CROSSBAR_CAPS_S = ^KSPROPERTY_CROSSBAR_CAPS_S; + {$EXTERNALSYM PKSPROPERTY_CROSSBAR_CAPS_S} + TKSPropertyCrossbarCapsS = KSPROPERTY_CROSSBAR_CAPS_S; + + PKSPropertyCrossbarPinInfoS = ^TKSPropertyCrossbarPinInfoS; + KSPROPERTY_CROSSBAR_PININFO_S = record + Property_ : KSPROPERTY; + Direction : TKSPinDataFlow; // KSPIN_DATAFLOW_IN or KSPIN_DATAFLOW_OUT? + Index : ULONG; // Which pin to return data for? + PinType : ULONG; // KS_PhysConn_Video_* or KS_PhysConn_Audio_* + RelatedPinIndex : ULONG; // For video pins, this is the related audio pin + Medium : TKSPinMedium; // Identifies the hardware connection + end; + {$EXTERNALSYM KSPROPERTY_CROSSBAR_PININFO_S} + PKSPROPERTY_CROSSBAR_PININFO_S = ^KSPROPERTY_CROSSBAR_PININFO_S; + {$EXTERNALSYM PKSPROPERTY_CROSSBAR_PININFO_S} + TKSPropertyCrossbarPinInfoS = KSPROPERTY_CROSSBAR_PININFO_S; + + PKSPropertyCrossbarRouteS = ^TKSPropertyCrossbarRouteS; + KSPROPERTY_CROSSBAR_ROUTE_S = record + Property_ : KSPROPERTY; + IndexInputPin : ULONG; // Zero based index of the input pin + IndexOutputPin : ULONG; // Zero based index of the output pin + CanRoute : ULONG; // returns non-zero on CAN_ROUTE if routing is possible + end; + {$EXTERNALSYM KSPROPERTY_CROSSBAR_ROUTE_S} + PKSPROPERTY_CROSSBAR_ROUTE_S = ^KSPROPERTY_CROSSBAR_ROUTE_S; + {$EXTERNALSYM PKSPROPERTY_CROSSBAR_ROUTE_S} + TKSPropertyCrossbarRouteS = KSPROPERTY_CROSSBAR_ROUTE_S; + +const + EVENTSETID_CROSSBAR : TGUID = '{6a2e0641-28e4-11d0-a18c-00a0c9118956}'; + {$EXTERNALSYM EVENTSETID_CROSSBAR} + +type + KSEVENT_CROSSBAR = ( + KSEVENT_CROSSBAR_CHANGED + ); + {$EXTERNALSYM KSEVENT_CROSSBAR} + TKSEventCrossbar = KSEVENT_CROSSBAR; + +// The following IDs should match the AM equivalents + KS_PhysicalConnectorType = {$IFDEF TYPE_IDENTITY}type {$ENDIF} LongWord; + {$EXTERNALSYM KS_PhysicalConnectorType} + const + KS_PhysConn_Video_Tuner = 1; + {$EXTERNALSYM KS_PhysConn_Video_Tuner} + KS_PhysConn_Video_Composite = 2; + {$EXTERNALSYM KS_PhysConn_Video_Composite} + KS_PhysConn_Video_SVideo = 3; + {$EXTERNALSYM KS_PhysConn_Video_SVideo} + KS_PhysConn_Video_RGB = 4; + {$EXTERNALSYM KS_PhysConn_Video_RGB} + KS_PhysConn_Video_YRYBY = 5; + {$EXTERNALSYM KS_PhysConn_Video_YRYBY} + KS_PhysConn_Video_SerialDigital = 6; + {$EXTERNALSYM KS_PhysConn_Video_SerialDigital} + KS_PhysConn_Video_ParallelDigital = 7; + {$EXTERNALSYM KS_PhysConn_Video_ParallelDigital} + KS_PhysConn_Video_SCSI = 8; + {$EXTERNALSYM KS_PhysConn_Video_SCSI} + KS_PhysConn_Video_AUX = 9; + {$EXTERNALSYM KS_PhysConn_Video_AUX} + KS_PhysConn_Video_1394 = 10; + {$EXTERNALSYM KS_PhysConn_Video_1394} + KS_PhysConn_Video_USB = 11; + {$EXTERNALSYM KS_PhysConn_Video_USB} + KS_PhysConn_Video_VideoDecoder = 12; + {$EXTERNALSYM KS_PhysConn_Video_VideoDecoder} + KS_PhysConn_Video_VideoEncoder = 13; + {$EXTERNALSYM KS_PhysConn_Video_VideoEncoder} + KS_PhysConn_Video_SCART = 14; + {$EXTERNALSYM KS_PhysConn_Video_SCART} + KS_PhysConn_Audio_Tuner = 4096; + {$EXTERNALSYM KS_PhysConn_Audio_Tuner} + KS_PhysConn_Audio_Line = 4097; + {$EXTERNALSYM KS_PhysConn_Audio_Line} + KS_PhysConn_Audio_Mic = 4098; + {$EXTERNALSYM KS_PhysConn_Audio_Mic} + KS_PhysConn_Audio_AESDigital = 4099; + {$EXTERNALSYM KS_PhysConn_Audio_AESDigital} + KS_PhysConn_Audio_SPDIFDigital = 4100; + {$EXTERNALSYM KS_PhysConn_Audio_SPDIFDigital} + KS_PhysConn_Audio_SCSI = 4101; + {$EXTERNALSYM KS_PhysConn_Audio_SCSI} + KS_PhysConn_Audio_AUX = 4102; + {$EXTERNALSYM KS_PhysConn_Audio_AUX} + KS_PhysConn_Audio_1394 = 4103; + {$EXTERNALSYM KS_PhysConn_Audio_1394} + KS_PhysConn_Audio_USB = 4104; + {$EXTERNALSYM KS_PhysConn_Audio_USB} + KS_PhysConn_Audio_AudioDecoder = 4105; + {$EXTERNALSYM KS_PhysConn_Audio_AudioDecoder} + +//=========================================================================== + + PROPSETID_VIDCAP_TVAUDIO : TGUID = '{6a2e0650-28e4-11d0-a18c-00a0c9118956}'; + {$EXTERNALSYM PROPSETID_VIDCAP_TVAUDIO} + +type + KSPROPERTY_VIDCAP_TVAUDIO = ( + KSPROPERTY_TVAUDIO_CAPS, // R + KSPROPERTY_TVAUDIO_MODE, // RW + KSPROPERTY_TVAUDIO_CURRENTLY_AVAILABLE_MODES // R + ); + {$EXTERNALSYM KSPROPERTY_VIDCAP_TVAUDIO} + TKSPropertyVidCapTVAudio = KSPROPERTY_VIDCAP_TVAUDIO; + +const + KS_TVAUDIO_MODE_MONO = $0001; // Mono + {$EXTERNALSYM KS_TVAUDIO_MODE_MONO} + KS_TVAUDIO_MODE_STEREO = $0002; // Stereo + {$EXTERNALSYM KS_TVAUDIO_MODE_STEREO} + KS_TVAUDIO_MODE_LANG_A = $0010; // Primary language + {$EXTERNALSYM KS_TVAUDIO_MODE_LANG_A} + KS_TVAUDIO_MODE_LANG_B = $0020; // 2nd avail language + {$EXTERNALSYM KS_TVAUDIO_MODE_LANG_B} + KS_TVAUDIO_MODE_LANG_C = $0040; // 3rd avail language + {$EXTERNALSYM KS_TVAUDIO_MODE_LANG_C} + +type + PKSPropertyTVAudioCapsS = ^TKSPropertyTVAudioCapsS; + KSPROPERTY_TVAUDIO_CAPS_S = record + Property_ : KSPROPERTY; + Capabilities : ULONG; // Bitmask of KS_TVAUDIO_MODE_* + InputMedium : TKSPinMedium; + OutputMedium : TKSPinMedium; + end; + {$EXTERNALSYM KSPROPERTY_TVAUDIO_CAPS_S} + PKSPROPERTY_TVAUDIO_CAPS_S = ^KSPROPERTY_TVAUDIO_CAPS_S; + {$EXTERNALSYM PKSPROPERTY_TVAUDIO_CAPS_S} + TKSPropertyTVAudioCapsS = KSPROPERTY_TVAUDIO_CAPS_S; + + PKSPropertyTVAudioS = ^TKSPropertyTVAudioS; + KSPROPERTY_TVAUDIO_S = record + Property_ : KSPROPERTY; + Mode : ULONG; // KS_TVAUDIO_MODE_* + end; + {$EXTERNALSYM KSPROPERTY_TVAUDIO_S} + PKSPROPERTY_TVAUDIO_S = ^KSPROPERTY_TVAUDIO_S; + {$EXTERNALSYM PKSPROPERTY_TVAUDIO_S} + TKSPropertyTVAudioS = KSPROPERTY_TVAUDIO_S; + +const + KSEVENTSETID_VIDCAP_TVAUDIO : TGUID = '{6a2e0651-28e4-11d0-a18c-00a0c9118956}'; + {$EXTERNALSYM KSEVENTSETID_VIDCAP_TVAUDIO} + +type + KSEVENT_TVAUDIO = ( + KSEVENT_TVAUDIO_CHANGED + ); + {$EXTERNALSYM KSEVENT_TVAUDIO} + TKSEventTVAudio = KSEVENT_TVAUDIO; + +//=========================================================================== +const + PROPSETID_VIDCAP_VIDEOCOMPRESSION : TGUID = '{C6E13343-30AC-11d0-A18C-00A0C9118956}'; + {$EXTERNALSYM PROPSETID_VIDCAP_VIDEOCOMPRESSION} + +type + KSPROPERTY_VIDCAP_VIDEOCOMPRESSION = ( + KSPROPERTY_VIDEOCOMPRESSION_GETINFO, // R + KSPROPERTY_VIDEOCOMPRESSION_KEYFRAME_RATE, // RW + KSPROPERTY_VIDEOCOMPRESSION_PFRAMES_PER_KEYFRAME, // RW + KSPROPERTY_VIDEOCOMPRESSION_QUALITY, // RW + KSPROPERTY_VIDEOCOMPRESSION_OVERRIDE_KEYFRAME, // W + KSPROPERTY_VIDEOCOMPRESSION_OVERRIDE_FRAME_SIZE, // W + KSPROPERTY_VIDEOCOMPRESSION_WINDOWSIZE // RW + ); + {$EXTERNALSYM KSPROPERTY_VIDCAP_VIDEOCOMPRESSION} + TKSPRopertyVidCapVideoCompression = KSPROPERTY_VIDCAP_VIDEOCOMPRESSION; + + KS_CompressionCaps = {$IFDEF TYPE_IDENTITY}type {$ENDIF} LongWord; + {$EXTERNALSYM KS_CompressionCaps} + const + KS_CompressionCaps_CanQuality = 1; + {$EXTERNALSYM KS_CompressionCaps_CanQuality} + KS_CompressionCaps_CanCrunch = 2; + {$EXTERNALSYM KS_CompressionCaps_CanCrunch} + KS_CompressionCaps_CanKeyFrame = 4; + {$EXTERNALSYM KS_CompressionCaps_CanKeyFrame} + KS_CompressionCaps_CanBFrame = 8; + {$EXTERNALSYM KS_CompressionCaps_CanBFrame} + KS_CompressionCaps_CanWindow = $10; + {$EXTERNALSYM KS_CompressionCaps_CanWindow} + +type + PKSPropertyVideoCompressionGetInfoS = ^TKSPropertyVideoCompressionGetInfoS; + KSPROPERTY_VIDEOCOMPRESSION_GETINFO_S = record + Property_ : KSPROPERTY; + // Note, no VersionString! + // Note, no DescriptionString! + StreamIndex : ULONG; // zero based index of stream + DefaultKeyFrameRate : longint; // Key frame rate + DefaultPFrameRate : longint; // Predeicted frames per Key frame + DefaultQuality : longint; // 0 to 10000 + NumberOfQualitySettings : longint; // How many discreet quality settings? + Capabilities : longint; // KS_CompressionCaps_* + end; + {$EXTERNALSYM KSPROPERTY_VIDEOCOMPRESSION_GETINFO_S} + PKSPROPERTY_VIDEOCOMPRESSION_GETINFO_S = ^KSPROPERTY_VIDEOCOMPRESSION_GETINFO_S; + {$EXTERNALSYM PKSPROPERTY_VIDEOCOMPRESSION_GETINFO_S} + TKSPropertyVideoCompressionGetInfoS = KSPROPERTY_VIDEOCOMPRESSION_GETINFO_S; + + PKSPropertyVideoCompressionS = ^TKSPropertyVideoCompressionS; + KSPROPERTY_VIDEOCOMPRESSION_S = record + Property_ : KSPROPERTY; + StreamIndex : ULONG; // zero based index of stream + Value : longint; // value to get or set + end; + {$EXTERNALSYM KSPROPERTY_VIDEOCOMPRESSION_S} + PKSPROPERTY_VIDEOCOMPRESSION_S = ^KSPROPERTY_VIDEOCOMPRESSION_S; + {$EXTERNALSYM PKSPROPERTY_VIDEOCOMPRESSION_S} + TKSPropertyVideoCompressionS = KSPROPERTY_VIDEOCOMPRESSION_S; + +//=========================================================================== +// MEDIASUBTYPE_Overlay +const + KSDATAFORMAT_SUBTYPE_OVERLAY : TGUID = '{e436eb7f-524f-11ce-9f53-0020af0ba770}'; + {$EXTERNALSYM KSDATAFORMAT_SUBTYPE_OVERLAY} + KSPROPSETID_OverlayUpdate : TGUID = '{490EA5CF-7681-11D1-A21C-00A0C9223196}'; + {$EXTERNALSYM KSPROPSETID_OverlayUpdate} + +type + KSPROPERTY_OVERLAYUPDATE = {$IFDEF TYPE_IDENTITY}type {$ENDIF} LongWord; + {$EXTERNALSYM KSPROPERTY_OVERLAYUPDATE} + const + KSPROPERTY_OVERLAYUPDATE_INTERESTS = $0; + {$EXTERNALSYM KSPROPERTY_OVERLAYUPDATE_INTERESTS} + KSPROPERTY_OVERLAYUPDATE_CLIPLIST = $1; + {$EXTERNALSYM KSPROPERTY_OVERLAYUPDATE_CLIPLIST} + KSPROPERTY_OVERLAYUPDATE_PALETTE = $2; + {$EXTERNALSYM KSPROPERTY_OVERLAYUPDATE_PALETTE} + KSPROPERTY_OVERLAYUPDATE_COLORKEY = $4; + {$EXTERNALSYM KSPROPERTY_OVERLAYUPDATE_COLORKEY} + KSPROPERTY_OVERLAYUPDATE_VIDEOPOSITION = $8; + {$EXTERNALSYM KSPROPERTY_OVERLAYUPDATE_VIDEOPOSITION} + KSPROPERTY_OVERLAYUPDATE_DISPLAYCHANGE = $10; + {$EXTERNALSYM KSPROPERTY_OVERLAYUPDATE_DISPLAYCHANGE} + KSPROPERTY_OVERLAYUPDATE_COLORREF = $10000000; + {$EXTERNALSYM KSPROPERTY_OVERLAYUPDATE_COLORREF} + +type + KSDISPLAYCHANGE = record + PelsWidth :ULONG; + PelsHeight :ULONG; + BitsPerPel :ULONG; + DeviceID :array[0..0] of WideChar; + end; + {$EXTERNALSYM KSDISPLAYCHANGE} + PKSDISPLAYCHANGE = ^KSDISPLAYCHANGE; + {$EXTERNALSYM PKSDISPLAYCHANGE} + TKSDisplayChange = KSDISPLAYCHANGE; + +{#define DEFINE_KSPROPERTY_ITEM_OVERLAYUPDATE_INTERESTS(Handler)\ + DEFINE_KSPROPERTY_ITEM(\ + KSPROPERTY_OVERLAYUPDATE_INTERESTS,\ + (Handler),\ + sizeof(KSPROPERTY),\ + sizeof(ULONG),\ + NULL, NULL, 0, NULL, NULL, 0) + +#define DEFINE_KSPROPERTY_ITEM_OVERLAYUPDATE_PALETTE(Handler)\ + DEFINE_KSPROPERTY_ITEM(\ + KSPROPERTY_OVERLAYUPDATE_PALETTE,\ + NULL,\ + sizeof(KSPROPERTY),\ + 0,\ + (Handler),\ + NULL, 0, NULL, NULL, 0) + +#define DEFINE_KSPROPERTY_ITEM_OVERLAYUPDATE_COLORKEY(Handler)\ + DEFINE_KSPROPERTY_ITEM(\ + KSPROPERTY_OVERLAYUPDATE_COLORKEY,\ + NULL,\ + sizeof(KSPROPERTY),\ + sizeof(COLORKEY),\ + (Handler),\ + NULL, 0, NULL, NULL, 0) + +#define DEFINE_KSPROPERTY_ITEM_OVERLAYUPDATE_CLIPLIST(Handler)\ + DEFINE_KSPROPERTY_ITEM(\ + KSPROPERTY_OVERLAYUPDATE_CLIPLIST,\ + NULL,\ + sizeof(KSPROPERTY),\ + 2 * sizeof(RECT) + sizeof(RGNDATAHEADER),\ + (Handler),\ + NULL, 0, NULL, NULL, 0) + +#define DEFINE_KSPROPERTY_ITEM_OVERLAYUPDATE_VIDEOPOSITION(Handler)\ + DEFINE_KSPROPERTY_ITEM(\ + KSPROPERTY_OVERLAYUPDATE_VIDEOPOSITION,\ + NULL,\ + sizeof(KSPROPERTY),\ + 2 * sizeof(RECT),\ + (Handler),\ + NULL, 0, NULL, NULL, 0) + +#define DEFINE_KSPROPERTY_ITEM_OVERLAYUPDATE_DISPLAYCHANGE(Handler)\ + DEFINE_KSPROPERTY_ITEM(\ + KSPROPERTY_OVERLAYUPDATE_DISPLAYCHANGE,\ + NULL,\ + sizeof(KSPROPERTY),\ + sizeof(KSDISPLAYCHANGE),\ + (Handler),\ + NULL, 0, NULL, NULL, 0) + +#define DEFINE_KSPROPERTY_ITEM_OVERLAYUPDATE_COLORREF(Handler)\ + DEFINE_KSPROPERTY_ITEM(\ + KSPROPERTY_OVERLAYUPDATE_COLORREF,\ + (Handler),\ + sizeof(KSPROPERTY),\ + sizeof(COLORREF),\ + NULL,\ + NULL, 0, NULL, NULL, 0) } + +//=========================================================================== +const + PROPSETID_VIDCAP_VIDEOCONTROL : TGUID = '{6a2e0670-28e4-11d0-a18c-00a0c9118956}'; + {$EXTERNALSYM PROPSETID_VIDCAP_VIDEOCONTROL} + +type + KSPROPERTY_VIDCAP_VIDEOCONTROL = ( + KSPROPERTY_VIDEOCONTROL_CAPS, // R + KSPROPERTY_VIDEOCONTROL_ACTUAL_FRAME_RATE, // R O + KSPROPERTY_VIDEOCONTROL_FRAME_RATES, // R O + KSPROPERTY_VIDEOCONTROL_MODE // RWO + ); + {$EXTERNALSYM KSPROPERTY_VIDCAP_VIDEOCONTROL} + TKSPropertyVidCapVideoControl = KSPROPERTY_VIDCAP_VIDEOCONTROL; + + KS_VideoControlFlags = {$IFDEF TYPE_IDENTITY}type {$ENDIF} LongWord; + {$EXTERNALSYM KS_VideoControlFlags} + const + KS_VideoControlFlag_FlipHorizontal = $0001; + {$EXTERNALSYM KS_VideoControlFlag_FlipHorizontal} + KS_VideoControlFlag_FlipVertical = $0002; + {$EXTERNALSYM KS_VideoControlFlag_FlipVertical} + KS_Obsolete_VideoControlFlag_ExternalTriggerEnable = $0010; // ***WARNING *** Flag msimatch with DSHOW. + {$EXTERNALSYM KS_Obsolete_VideoControlFlag_ExternalTriggerEnable} + KS_Obsolete_VideoControlFlag_Trigger = $0020; // ***WARNING *** Flag msimatch with DSHOW. + {$EXTERNALSYM KS_Obsolete_VideoControlFlag_Trigger} + KS_VideoControlFlag_ExternalTriggerEnable = $0004; + {$EXTERNALSYM KS_VideoControlFlag_ExternalTriggerEnable} + KS_VideoControlFlag_Trigger = $0008; + {$EXTERNALSYM KS_VideoControlFlag_Trigger} + +type + PKSPropertyVideoControlCapsS = ^TKSPropertyVideoControlCapsS; + KSPROPERTY_VIDEOCONTROL_CAPS_S = record + Property_ : KSPROPERTY; + StreamIndex : ULONG; + VideoControlCaps : ULONG; // KS_VideoControlFlags_* + end; + {$EXTERNALSYM KSPROPERTY_VIDEOCONTROL_CAPS_S} + PKSPROPERTY_VIDEOCONTROL_CAPS_S = ^KSPROPERTY_VIDEOCONTROL_CAPS_S; + {$EXTERNALSYM PKSPROPERTY_VIDEOCONTROL_CAPS_S} + TKSPropertyVideoControlCapsS = KSPROPERTY_VIDEOCONTROL_CAPS_S; + + PKSPropertyVideoControlModeS = ^TKSPropertyVideoControlModeS; + KSPROPERTY_VIDEOCONTROL_MODE_S = record + Property_ : KSPROPERTY; + StreamIndex : ULONG; + Mode : longint; // KS_VideoControlFlags_* + end; + {$EXTERNALSYM KSPROPERTY_VIDEOCONTROL_MODE_S} + PKSPROPERTY_VIDEOCONTROL_MODE_S = ^KSPROPERTY_VIDEOCONTROL_MODE_S; + {$EXTERNALSYM PKSPROPERTY_VIDEOCONTROL_MODE_S} + TKSPropertyVideoControlModeS = KSPROPERTY_VIDEOCONTROL_MODE_S; + + PKSPropertyVideoControlActualFrameRateS = ^TKSPropertyVideoControlActualFrameRateS; + KSPROPERTY_VIDEOCONTROL_ACTUAL_FRAME_RATE_S = record + Property_ : KSPROPERTY; + StreamIndex : ULONG; // Index of stream + RangeIndex : ULONG; // Index of range + Dimensions : TSIZE; // Size of image + CurrentActualFrameRate : int64; // Only correct if pin is open + CurrentMaxAvailableFrameRate : int64; // Max Rate temporarily limited on USB or 1394? + end; + {$EXTERNALSYM KSPROPERTY_VIDEOCONTROL_ACTUAL_FRAME_RATE_S} + PKSPROPERTY_VIDEOCONTROL_ACTUAL_FRAME_RATE_S = ^KSPROPERTY_VIDEOCONTROL_ACTUAL_FRAME_RATE_S; + {$EXTERNALSYM PKSPROPERTY_VIDEOCONTROL_ACTUAL_FRAME_RATE_S} + TKSPropertyVideoControlActualFrameRateS = KSPROPERTY_VIDEOCONTROL_ACTUAL_FRAME_RATE_S; + +// KSPROPERTY_VIDEOCONTROL_FRAME_RATES returns a list of available frame rates in 100 nS units + PKSPropertyVideoControlFrameRatesS = ^TKSPropertyVideoControlFrameRatesS; + KSPROPERTY_VIDEOCONTROL_FRAME_RATES_S = record + Property_ : KSPROPERTY; + StreamIndex : ULONG; // Index of stream + RangeIndex : ULONG; // Index of range + Dimensions : TSIZE; // Size of image + end; + {$EXTERNALSYM KSPROPERTY_VIDEOCONTROL_FRAME_RATES_S} + PKSPROPERTY_VIDEOCONTROL_FRAME_RATES_S = ^KSPROPERTY_VIDEOCONTROL_FRAME_RATES_S; + {$EXTERNALSYM PKSPROPERTY_VIDEOCONTROL_FRAME_RATES_S} + TKSPropertyVideoControlFrameRatesS = KSPROPERTY_VIDEOCONTROL_FRAME_RATES_S; + +//=========================================================================== +const + PROPSETID_VIDCAP_DROPPEDFRAMES : TGUID = '{C6E13344-30AC-11d0-A18C-00A0C9118956}'; + {$EXTERNALSYM PROPSETID_VIDCAP_DROPPEDFRAMES} + +type + KSPROPERTY_VIDCAP_DROPPEDFRAMES = ( + KSPROPERTY_DROPPEDFRAMES_CURRENT // R + ); + {$EXTERNALSYM KSPROPERTY_VIDCAP_DROPPEDFRAMES} + TKSPropertyVidCapDroppedFrames = KSPROPERTY_VIDCAP_DROPPEDFRAMES; + + PKSPropertyDroppedFramesCurrentS = ^TKSPropertyDroppedFramesCurrentS; + KSPROPERTY_DROPPEDFRAMES_CURRENT_S = record + Property_ : KSPROPERTY; + PictureNumber : int64; // Current Picture Number + DropCount : int64; // Count of frames dropped + AverageFrameSize : ULONG; // Average size of frames captured + end; + {$EXTERNALSYM KSPROPERTY_DROPPEDFRAMES_CURRENT_S} + PKSPROPERTY_DROPPEDFRAMES_CURRENT_S = ^KSPROPERTY_DROPPEDFRAMES_CURRENT_S; + {$EXTERNALSYM PKSPROPERTY_DROPPEDFRAMES_CURRENT_S} + TKSPropertyDroppedFramesCurrentS = KSPROPERTY_DROPPEDFRAMES_CURRENT_S; + +//=========================================================================== +// VPE +const + KSPROPSETID_VPConfig : TGUID = '{bc29a660-30e3-11d0-9e69-00c04fd7c15b}'; + {$EXTERNALSYM KSPROPSETID_VPConfig} + KSPROPSETID_VPVBIConfig : TGUID = '{ec529b00-1a1f-11d1-bad9-00609744111a}'; + {$EXTERNALSYM KSPROPSETID_VPVBIConfig} + +// Both of the above property sets use the same list of properties below + +type + KSPROPERTY_VPCONFIG = ( + KSPROPERTY_VPCONFIG_NUMCONNECTINFO, + KSPROPERTY_VPCONFIG_GETCONNECTINFO, + KSPROPERTY_VPCONFIG_SETCONNECTINFO, + KSPROPERTY_VPCONFIG_VPDATAINFO, + KSPROPERTY_VPCONFIG_MAXPIXELRATE, + KSPROPERTY_VPCONFIG_INFORMVPINPUT, + KSPROPERTY_VPCONFIG_NUMVIDEOFORMAT, + KSPROPERTY_VPCONFIG_GETVIDEOFORMAT, + KSPROPERTY_VPCONFIG_SETVIDEOFORMAT, + KSPROPERTY_VPCONFIG_INVERTPOLARITY, + KSPROPERTY_VPCONFIG_DECIMATIONCAPABILITY, // E_NOTIMPL for VBI + KSPROPERTY_VPCONFIG_SCALEFACTOR, // E_NOTIMPL for VBI + KSPROPERTY_VPCONFIG_DDRAWHANDLE, + KSPROPERTY_VPCONFIG_VIDEOPORTID, + KSPROPERTY_VPCONFIG_DDRAWSURFACEHANDLE, + KSPROPERTY_VPCONFIG_SURFACEPARAMS + ); + {$EXTERNALSYM KSPROPERTY_VPCONFIG} + TKSPropertyVPConfig = KSPROPERTY_VPCONFIG; + +//========================= +// IBasicAudio +// +const + CLSID_KsIBasicAudioInterfaceHandler : TGUID = '{b9f8ac3e-0f71-11d2-b72c-00c04fb6bd3d}'; + {$EXTERNALSYM CLSID_KsIBasicAudioInterfaceHandler} + +type + KSVPMAXPIXELRATE = record + Size : TAMVPSIZE; + MaxPixelsPerSecond : DWORD; + Reserved : DWORD; + end; + {$EXTERNALSYM KSVPMAXPIXELRATE} + PKSVPMAXPIXELRATE = ^KSVPMAXPIXELRATE; + {$EXTERNALSYM PKSVPMAXPIXELRATE} + TKSVPMaxPixelRate = KSVPMAXPIXELRATE; + + PKSVPSizeProp = ^TKSVPSizeProp; + KSVPSIZE_PROP = record + Property_ : KSPROPERTY; + Size : TAMVPSIZE; + end; + {$EXTERNALSYM KSVPSIZE_PROP} + PKSVPSIZE_PROP = ^KSVPSIZE_PROP; + {$EXTERNALSYM PKSVPSIZE_PROP} + TKSVPSizeProp = KSVPSIZE_PROP; + + KSVPSURFACEPARAMS = record + dwPitch : DWORD; + dwXOrigin : DWORD; + dwYOrigin : DWORD; + end; + {$EXTERNALSYM KSVPSURFACEPARAMS} + PKSVPSURFACEPARAMS = ^KSVPSURFACEPARAMS; + {$EXTERNALSYM PKSVPSURFACEPARAMS} + TKSVPSurfaceParams = KSVPSURFACEPARAMS; + +//========================================================================== +// The following definitions must be in sync with DDraw.h in DirectX SDK +//========================================================================== + +//* +//* The FourCC code is valid. +//* +// uses DirectDraw.pas + +//========================================================================== +// End of DDraw.h header info +//========================================================================== + +//========================================================================== +// The following definitions must be in sync with DVP.h in DirectX SDK +//========================================================================== + + + _DDVIDEOPORTCONNECT = record + dwSize : DWORD; // size of the DDVIDEOPORTCONNECT structure + dwPortWidth : DWORD; // Width of the video port + guidTypeID : TGUID; // Description of video port connection + dwFlags : DWORD; // Connection flags + dwReserved1 : DWORD; // Reserved, set to zero. + end; + {$EXTERNALSYM _DDVIDEOPORTCONNECT} + DDVIDEOPORTCONNECT = _DDVIDEOPORTCONNECT; + {$EXTERNALSYM DDVIDEOPORTCONNECT} + PDDVIDEOPORTCONNECT = ^DDVIDEOPORTCONNECT; + {$EXTERNALSYM PDDVIDEOPORTCONNECT} + TDDVideoPortConnect = _DDVIDEOPORTCONNECT; + +const + DDVPTYPE_E_HREFH_VREFH : TGUID = (D1:$54F39980;D2:$DA60;D3:$11CF;D4:($9B,$06,$00,$A0,$C9,$03,$A3,$B8)); + {$EXTERNALSYM DDVPTYPE_E_HREFH_VREFH} + DDVPTYPE_E_HREFL_VREFL : TGUID = (D1:$E09C77E0;D2:$DA60;D3:$11CF;D4:($9B,$06,$00,$A0,$C9,$03,$A3,$B8)); + {$EXTERNALSYM DDVPTYPE_E_HREFL_VREFL} + +//========================================================================== +// End of DVP.h header info +//========================================================================== + + +//========================================================================== +// The following definitions must be in sync with VPType.h in AM 2.0 SDK +//========================================================================== +type +// pixel aspect ratios corresponding to a 720x480 NTSC image or a 720x576 image + KS_AMPixAspectRatio = ( // AMPixAspectRatio + KS_PixAspectRatio_NTSC4x3, + KS_PixAspectRatio_NTSC16x9, + KS_PixAspectRatio_PAL4x3, + KS_PixAspectRatio_PAL16x9 + ); + {$NODEFINE KS_AMPixAspectRatio} + TKSAMPixAspectRatio = KS_AMPixAspectRatio; + {$NODEFINE TKSAMPixAspectRatio} + + KS_AMVP_SELECTFORMATBY = ( // AMVP_SELECTFORMATBY + KS_AMVP_DO_NOT_CARE, + KS_AMVP_BEST_BANDWIDTH, + KS_AMVP_INPUT_SAME_AS_OUTPUT + ); + {$NODEFINE KS_AMVP_SELECTFORMATBY} + TKSAMVPSelectFormatBy = KS_AMVP_SELECTFORMATBY; + {$NODEFINE TKSAMVPSelectFormatBy} + + KS_AMVP_MODE = ( // AMVP_MODE + KS_AMVP_MODE_WEAVE, + KS_AMVP_MODE_BOBINTERLEAVED, + KS_AMVP_MODE_BOBNONINTERLEAVED, + KS_AMVP_MODE_SKIPEVEN, + KS_AMVP_MODE_SKIPODD + ); + {$NODEFINE KS_AMVP_MODE} + TKSAMVPMode = KS_AMVP_MODE; + {$NODEFINE TKSAMVPMode} + + PKSAMVPDimInfo = ^TKSAMVPDimInfo; + {$NODEFINE PKSAMVPDimInfo} + tagKS_AMVPDIMINFO = record // AMVPDIMINFO + dwFieldWidth : DWORD; // [out] field width + dwFieldHeight : DWORD; // [out] field height + dwVBIWidth : DWORD; // [out] VBI data width + dwVBIHeight : DWORD; // [out] VBI data height + rcValidRegion : TRECT; // [out] valid rect for data cropping + end; + {$NODEFINE tagKS_AMVPDIMINFO} + KS_AMVPDIMINFO = tagKS_AMVPDIMINFO; + {$EXTERNALSYM KS_AMVPDIMINFO} + PKS_AMVPDIMINFO = ^KS_AMVPDIMINFO; + {$NODEFINE PKS_AMVPDIMINFO} + TKSAMVPDimInfo = tagKS_AMVPDIMINFO; + {$NODEFINE TKSAMVPDimInfo} + + PKSAMVPDataInfo = ^TKSAMVPDataInfo; + {$NODEFINE PKSAMVPDataInfo} + tagKS_AMVPDATAINFO = record // AMVPDATAINFO + dwSize : DWORD; // Size of the struct + dwMicrosecondsPerField : DWORD; // Time taken by each field + amvpDimInfo : TKSAMVPDimInfo; // Dimensional Information + dwPictAspectRatioX : DWORD; // Pict aspect ratio in X dimn + dwPictAspectRatioY : DWORD; // Pict aspect ratio in Y dimn + bEnableDoubleClock : BOOL; // Videoport should enable double clocking + bEnableVACT : BOOL; // Videoport should use an external VACT signal + bDataIsInterlaced : BOOL; // Indicates that the signal is interlaced + lHalfLinesOdd : Longint; // number of halflines in the odd field + bFieldPolarityInverted : BOOL; // Device inverts the polarity by default + dwNumLinesInVREF : DWORD; // Number of lines of data in VREF + lHalfLinesEven : Longint; // number of halflines in the even field + dwReserved1 : DWORD; // Reserved for future use + end; + {$NODEFINE tagKS_AMVPDATAINFO} + KS_AMVPDATAINFO = tagKS_AMVPDATAINFO; + {$NODEFINE KS_AMVPDATAINFO} + PKS_AMVPDATAINFO = ^KS_AMVPDATAINFO; + {$NODEFINE PKS_AMVPDATAINFO} + TKSAMVPDataInfo = tagKS_AMVPDATAINFO; + {$NODEFINE TKSAMVPDataInfo} + + PKSAMVPSize = ^TKSAMVPSize; + {$NODEFINE PKSAMVPSize} + tagKS_AMVPSIZE = record // AMVPSIZE + dwWidth : DWORD; // [in] width in pixels + dwHeight : DWORD; // [in] height in pixels + end; + {$NODEFINE tagKS_AMVPSIZE} + KS_AMVPSIZE = tagKS_AMVPSIZE; + {$NODEFINE KS_AMVPSIZE} + PKS_AMVPSIZE = ^KS_AMVPSIZE; + {$NODEFINE PKS_AMVPSIZE} + TKSAMVPSize = tagKS_AMVPSIZE; + {$NODEFINE TKSAMVPSize} + +//========================================================================== +// End of VPType.h header info +//========================================================================== + +{ // allready defined above + PKSVPMAXPIXELRATE = ^TKSVPMAXPIXELRATE; + TKSVPMAXPIXELRATE = record + Size : TKS_AMVPSIZE; + MaxPixelsPerSecond : DWORD; + Reserved : DWORD; + end; + + PKSVPSIZE_PROP = ^TKSVPSIZE_PROP; + TKSVPSIZE_PROP = record + Property_ : KSPROPERTY; + Size : TKS_AMVPSIZE; + end; + + PKSVPSURFACEPARAMS = ^TKSVPSURFACEPARAMS; + TKSVPSURFACEPARAMS = record + dwPitch : DWORD; + dwXOrigin : DWORD; + dwYOrigin : DWORD; + end; } + +// +// IVPNotify event notification +// +const + KSEVENTSETID_VPNotify : TGUID = '{20c5598e-d3c8-11d0-8dfc-00c04fd7c08b}'; + {$EXTERNALSYM KSEVENTSETID_VPNotify} + +type + KSEVENT_VPNOTIFY = ( + KSEVENT_VPNOTIFY_FORMATCHANGE + ); + {$EXTERNALSYM KSEVENT_VPNOTIFY} + TKSEventVPNotify = KSEVENT_VPNOTIFY; + +// +// VIDCAPTOSTI event notification +// +const + KSEVENTSETID_VIDCAPTOSTI : TGUID = '{DB47DE20-F628-11d1-BA41-00A0C90D2B05}'; + {$EXTERNALSYM KSEVENTSETID_VIDCAPTOSTI} + +type + KSEVENT_VIDCAPTOSTI = ( + KSEVENT_VIDCAPTOSTI_EXT_TRIGGER, + KSEVENT_VIDCAP_AUTO_UPDATE, + KSEVENT_VIDCAP_SEARCH + ); + {$EXTERNALSYM KSEVENT_VIDCAPTOSTI} + TKSEventVidCapToSTI = KSEVENT_VIDCAPTOSTI; + +// +// Extension Unit Properties +// +const + KSPROPERTY_EXTENSION_UNIT_PASS_THROUGH = $ffff; // (RW) + {$EXTERNALSYM KSPROPERTY_EXTENSION_UNIT_PASS_THROUGH} + +type + PKSPropertyExtensionUnit = ^TKSPropertyExtensionUnit; + KSPROPERTY_EXTENSION_UNIT = ( + KSPROPERTY_EXTENSION_UNIT_INFO, // (R) + KSPROPERTY_EXTENSION_UNIT_CONTROL // (RW) + ); + {$EXTERNALSYM KSPROPERTY_EXTENSION_UNIT} + PKSPROPERTY_EXTENSION_UNIT = ^KSPROPERTY_EXTENSION_UNIT; + {$EXTERNALSYM PKSPROPERTY_EXTENSION_UNIT} + TKSPropertyExtensionUnit = KSPROPERTY_EXTENSION_UNIT; + + +// +// IVPVBINotify event notification +// +const + KSEVENTSETID_VPVBINotify : TGUID = '{ec529b01-1a1f-11d1-bad9-00609744111a}'; + {$EXTERNALSYM KSEVENTSETID_VPVBINotify} + +type + KSEVENT_VPVBINOTIFY = ( + KSEVENT_VPVBINOTIFY_FORMATCHANGE + ); + {$EXTERNALSYM KSEVENT_VPVBINOTIFY} + TKSEventVPVBINotify = KSEVENT_VPVBINOTIFY; + +// +// closed caption information +// +const + KSDATAFORMAT_TYPE_AUXLine21Data : TGUID = '{670aea80-3a82-11d0-b79b-00aa003767a7}'; + {$EXTERNALSYM KSDATAFORMAT_TYPE_AUXLine21Data} + KSDATAFORMAT_SUBTYPE_Line21_BytePair : TGUID = '{6e8d4a22-310c-11d0-b79a-00aa003767a7}'; + {$EXTERNALSYM KSDATAFORMAT_SUBTYPE_Line21_BytePair} + KSDATAFORMAT_SUBTYPE_Line21_GOPPacket : TGUID = '{6e8d4a23-310c-11d0-b79a-00aa003767a7}'; + {$EXTERNALSYM KSDATAFORMAT_SUBTYPE_Line21_GOPPacket} + +type + PKSGopUserData = ^TKSGopUserData; + _KSGOP_USERDATA = record + sc : ULONG; + reserved1 : ULONG; + cFields : BYTE; + l21Data : array[0..2] of CHAR; + end; + {$EXTERNALSYM _KSGOP_USERDATA} + KSGOP_USERDATA = _KSGOP_USERDATA; + {$EXTERNALSYM KSGOP_USERDATA} + PKSGOP_USERDATA = ^KSGOP_USERDATA; + {$EXTERNALSYM PKSGOP_USERDATA} + TKSGopUserData = _KSGOP_USERDATA; + +// +// DVD encrypted PACK format type definition +// +const + KSDATAFORMAT_TYPE_DVD_ENCRYPTED_PACK : TGUID = '{ed0b916a-044d-11d1-aa78-00c04fc31d60}'; + {$EXTERNALSYM KSDATAFORMAT_TYPE_DVD_ENCRYPTED_PACK} + + KS_AM_UseNewCSSKey = $1; + {$EXTERNALSYM KS_AM_UseNewCSSKey} + +// ----------------------------------------------------------------------- +// KS_AM_KSPROPSETID_TSRateChange property set definitions for time stamp +// rate changes. +// ----------------------------------------------------------------------- + + KSPROPSETID_TSRateChange : TGUID = '{A503C5C0-1D1D-11D1-AD80-444553540000}'; + {$EXTERNALSYM KSPROPSETID_TSRateChange} + +type + PKSAMPropertyTSRateChange = ^TKSAMPropertyTSRateChange; + KS_AM_PROPERTY_TS_RATE_CHANGE = ( + KS_AM_RATE_Invalid, + KS_AM_RATE_SimpleRateChange, // rw, use KS_AM_SimpleRateChange + KS_AM_RATE_ExactRateChange, // rw, use KS_AM_ExactRateChange + KS_AM_RATE_MaxFullDataRate, // r, use KS_AM_MaxFullDataRate + KS_AM_RATE_Step // w, use KS_AM_Step + ); + {$EXTERNALSYM KS_AM_PROPERTY_TS_RATE_CHANGE} + TKSAMPropertyTSRateChange = KS_AM_PROPERTY_TS_RATE_CHANGE; + + PKSAMSimpleRateChange = ^TKSAMSimpleRateChange; + KS_AM_SimpleRateChange = record + // this is the simplest mechanism to set a time stamp rate change on + // a filter (simplest for the person setting the rate change, harder + // for the filter doing the rate change). + StartTime : TReferenceTime; //stream time at which to start this rate + Rate : Longint; //new rate * 10000 (decimal) + end; + {$EXTERNALSYM KS_AM_SimpleRateChange} + PKS_AM_SimpleRateChange = ^KS_AM_SimpleRateChange; + {$EXTERNALSYM PKS_AM_SimpleRateChange} + TKSAMSimpleRateChange = KS_AM_SimpleRateChange; + + PKSAMExactRateChange = ^TKSAMExactRateChange; + KS_AM_ExactRateChange = record + OutputZeroTime : TReferenceTime; //input TS that maps to zero output TS + Rate : Longint; //new rate * 10000 (decimal) + end; + {$EXTERNALSYM KS_AM_ExactRateChange} + PKS_AM_ExactRateChange = ^KS_AM_ExactRateChange; + {$EXTERNALSYM PKS_AM_ExactRateChange} + TKSAMExactRateChange = KS_AM_ExactRateChange; + + KS_AM_MaxFullDataRate = {$IFDEF TYPE_IDENTITY}type {$ENDIF} Longint; //rate * 10000 (decimal) + {$EXTERNALSYM KS_AM_MaxFullDataRate} + + KS_AM_Step = {$IFDEF TYPE_IDENTITY}type {$ENDIF} DWORD; // number of frame to step + {$EXTERNALSYM KS_AM_Step} + +//=========================================================================== +//ENCODER API DEFINITIONS +//=========================================================================== +const + KSCATEGORY_ENCODER : TGUID = '{19689BF6-C384-48fd-AD51-90E58C79F70B}'; + {$EXTERNALSYM KSCATEGORY_ENCODER} + KSCATEGORY_MULTIPLEXER : TGUID = '{7A5DE1D3-01A1-452c-B481-4FA2B96271E8}'; + {$EXTERNALSYM KSCATEGORY_MULTIPLEXER} +// ENCAPIPARAM_BITRATE : TGUID = '{49CC4C43-CA83-4ad4-A9AF-F3696AF666DF}'; +// ENCAPIPARAM_PEAK_BITRATE : TGUID = '{703F16A9-3D48-44a1-B077-018DFF915D19}'; +// ENCAPIPARAM_BITRATE_MODE : TGUID = '{EE5FB25C-C713-40d1-9D58-C0D7241E250F}'; +// CODECAPI_CHANGELISTS : TGUID = '{62B12ACF-F6B0-47D9-9456-96F22C4E0B9D}'; +// CODECAPI_VIDEO_ENCODER : TGUID = '{7112E8E1-3D03-47EF-8E60-03F1CF537301}'; +// CODECAPI_AUDIO_ENCODER : TGUID = '{B9D19A3E-F897-429C-BC46-8138B7272B2D}'; +// CODECAPI_SETALLDEFAULTS : TGUID = '{6C5E6A7C-ACF8-4F55-A999-1A628109051B}'; +// CODECAPI_ALLSETTINGS : TGUID = '{6A577E92-83E1-4113-ADC2-4FCEC32F83A1}'; +// CODECAPI_SUPPORTSEVENTS : TGUID = '{0581AF97-7693-4DBD-9DCA-3F9EBD6585A1}'; +// CODECAPI_CURRENTCHANGELIST : TGUID = '{1CB14E83-7D72-4657-83FD-47A2C5B9D13D}'; + + {************************************************************************ + * * + * dmksctrl.h -- Definition of IKsControl * + * * + * Copyright (c) 1998-1999 Microsoft Corporation * + * * + * * + * This header file contains the definition of IKsControl, which * + * duplicates definitions from ks.h and ksproxy.h. Your code should * + * include ks.h and ksproxy.h directly if you have them (they are * + * provided in the Windows 98 DDK and will be in the Windows NT 5 * + * SDK). * + * * + ************************************************************************} +// IID_IKsControl : TGUID = (D1:$28F54685;D2:$06FD;D3:$11D2;D4:($B2,$7A,$00,$A0,$C9,$22,$31,$96)); + +type + {$HPPEMIT 'typedef System::DelphiInterface _di_IKsControl;'} + {$EXTERNALSYM IKsControl} + IKsControl = interface(IUnknown) + ['{28F54685-06FD-11D2-B27A-00A0C9223196}'] + (*** IKsControl methods ***) + procedure KsProperty(Property_: PKSPROPERTY; PropertyLength: ULONG; PropertyData: Pointer; + DataLength: ULONG; out BytesReturned: ULONG); stdcall; + procedure KsMethod(Method: PKSMETHOD; MethodLength: ULONG; MethodData: Pointer; + DataLength: ULONG; out BytesReturned: ULONG); stdcall; + procedure KsEvent({OPTIONAL}Event: PKSEVENT; EventLength: ULONG; EventData: Pointer; + DataLength: ULONG; out BytesReturned: ULONG); stdcall; + end; + +//------------------------------------------------------------------------------ +// File: BDAMedia.h +// +// Desc: Broadcast Driver Architecture Multimedia Definitions. +// +// Copyright (c) 1996 - 2000, Microsoft Corporation. All rights reserved. +//------------------------------------------------------------------------------ + + +//=========================================================================== +// +// KSProperty Set Structure Definitions for BDA +// +//=========================================================================== + + PKSPBDANodePin = ^TKSPBDANodePin; + KSP_BDA_NODE_PIN = record + Property_ : KSPROPERTY; + ulNodeType : ULONG; + ulInputPinId : ULONG; + ulOutputPinId : ULONG; + end; + {$EXTERNALSYM KSP_BDA_NODE_PIN} + PKSP_BDA_NODE_PIN = ^KSP_BDA_NODE_PIN; + {$EXTERNALSYM PKSP_BDA_NODE_PIN} + TKSPBDANodePin = KSP_BDA_NODE_PIN; + + PKSMBDAPin = ^TKSMBDAPin; + KSM_BDA_PIN = record + Method: KSMETHOD; + case integer of + 0 : (PinId : ULONG; + Reserved : ULONG); + 1 : (PinType : ULONG; + Reserved_ : ULONG); + end; + {$EXTERNALSYM KSM_BDA_PIN} + PKSM_BDA_PIN = ^KSM_BDA_PIN; + {$EXTERNALSYM PKSM_BDA_PIN} + TKSMBDAPin = KSM_BDA_PIN; + + PKSMBDAPinPair = ^TKSMBDAPinPair; + KSM_BDA_PIN_PAIR = record + Method: KSMETHOD; + case integer of + 0 : (InputPinId : ULONG; + OutputPinId : ULONG); + 1 : (InputPinType : ULONG; + OutputPinType : ULONG); + end; + {$EXTERNALSYM KSM_BDA_PIN_PAIR} + PKSM_BDA_PIN_PAIR = ^KSM_BDA_PIN_PAIR; + {$EXTERNALSYM PKSM_BDA_PIN_PAIR} + TKSMBDAPinPair = KSM_BDA_PIN_PAIR; + + PKSPNodeESPID = ^TKSPNodeESPID; + KSP_NODE_ESPID = record + Property_ : TKSPNode; + EsPid : ULONG; + end; + {$EXTERNALSYM KSP_NODE_ESPID} + PKSP_NODE_ESPID = ^KSP_NODE_ESPID; + {$EXTERNALSYM PKSP_NODE_ESPID} + TKSPNodeESPID = KSP_NODE_ESPID; + +//=========================================================================== +// +// BDA Data Range definitions. Includes specifier definitions. +// +//=========================================================================== + +// Antenna Signal Formats +// + + PKSDataRangeBDAAntenna = ^TKSDataRangeBDAAntenna; + KS_DATARANGE_BDA_ANTENNA = record + DataRange : TKSDataRange; + // Antenna specifier can go here if required + // + end; + {$EXTERNALSYM KS_DATARANGE_BDA_ANTENNA} + PKS_DATARANGE_BDA_ANTENNA = ^KS_DATARANGE_BDA_ANTENNA; + {$EXTERNALSYM PKS_DATARANGE_BDA_ANTENNA} + TKSDataRangeBDAAntenna = KS_DATARANGE_BDA_ANTENNA; + +// Transport Formats +// + + PBDATransportInfo = ^TBDATransportInfo; + BDA_TRANSPORT_INFO = record + ulcbPhyiscalPacket : ULONG; // Size, in bytes, of a physical packet + // (e.g. Satellite link payload size. + ulcbPhyiscalFrame : ULONG; // Size, in bytes, of each physical frame + // 0 indicates no HW requirement + ulcbPhyiscalFrameAlignment : ULONG; // Capture buffer alignment in bytes + // 0 and 1 indicate no alignment requirements + AvgTimePerFrame : TReferenceTime ; // Normal ActiveMovie units (100 nS) + end; + {$EXTERNALSYM BDA_TRANSPORT_INFO} + PBDA_TRANSPORT_INFO = ^BDA_TRANSPORT_INFO; + {$EXTERNALSYM PBDA_TRANSPORT_INFO} + TBDATransportInfo = BDA_TRANSPORT_INFO; + + PKSDataRangeBDATransport = ^TKSDataRangeBDATransport; + KS_DATARANGE_BDA_TRANSPORT = record + DataRange : TKSDataRange; + BdaTransportInfo : TBDATransportInfo; + // Transport specifier can go here if required + // + end; + {$EXTERNALSYM KS_DATARANGE_BDA_TRANSPORT} + PKS_DATARANGE_BDA_TRANSPORT = ^KS_DATARANGE_BDA_TRANSPORT; + {$EXTERNALSYM PKS_DATARANGE_BDA_TRANSPORT} + TKSDataRangeBDATransport = KS_DATARANGE_BDA_TRANSPORT; + +//=========================================================================== +// BDA Event Guids +// +// These are sent by the IBroadcastEvent service on the graph. +// To receive, +// 0) Implement IBroadcastEvent in your receiving object - this has one Method on it: Fire() +// 1) QI the graphs service provider for SID_SBroadcastEventService +// for the IID_IBroadcastEvent object +// 2) OR create the event service (CLSID_BroadcastEventService) if not already there +// and register it +// 3) QI that object for it's IConnectionPoint interface (*pCP) +// 4) Advise your object on *pCP (e.g. pCP->Advise(static_cast(this), &dwCookie) +// 5) Unadvise when done.. +// 6) Implement IBroadcastEvent::Fire(GUID gEventID) +// Check for relevant event below and deal with it appropriatly... +//=========================================================================== + +const + EVENTID_TuningChanged : TGUID = '{9D7E6235-4B7D-425d-A6D1-D717C33B9C4C}'; + {$EXTERNALSYM EVENTID_TuningChanged} + EVENTID_CADenialCountChanged : TGUID = '{2A65C528-2249-4070-AC16-00390CDFB2DD}'; + {$EXTERNALSYM EVENTID_CADenialCountChanged} + EVENTID_SignalStatusChanged : TGUID = '{6D9CFAF2-702D-4b01-8DFF-6892AD20D191}'; + {$EXTERNALSYM EVENTID_SignalStatusChanged} + +//=========================================================================== +// +// BDA Stream Format GUIDs +// +//=========================================================================== +const + KSDATAFORMAT_TYPE_BDA_ANTENNA : TGUID = '{71985F41-1CA1-11d3-9CC8-00C04F7971E0}'; + {$EXTERNALSYM KSDATAFORMAT_TYPE_BDA_ANTENNA} + KSDATAFORMAT_SUBTYPE_BDA_MPEG2_TRANSPORT : TGUID = '{F4AEB342-0329-4fdd-A8FD-4AFF4926C978}'; + {$EXTERNALSYM KSDATAFORMAT_SUBTYPE_BDA_MPEG2_TRANSPORT} + KSDATAFORMAT_SPECIFIER_BDA_TRANSPORT : TGUID = '{8DEDA6FD-AC5F-4334-8ECF-A4BA8FA7D0F0}'; + {$EXTERNALSYM KSDATAFORMAT_SPECIFIER_BDA_TRANSPORT} + KSDATAFORMAT_TYPE_BDA_IF_SIGNAL : TGUID = '{61BE0B47-A5EB-499b-9A85-5B16C07F1258}'; + {$EXTERNALSYM KSDATAFORMAT_TYPE_BDA_IF_SIGNAL} + KSDATAFORMAT_TYPE_MPEG2_SECTIONS : TGUID = '{455F176C-4B06-47CE-9AEF-8CAEF73DF7B5}'; + {$EXTERNALSYM KSDATAFORMAT_TYPE_MPEG2_SECTIONS} + KSDATAFORMAT_SUBTYPE_ATSC_SI : TGUID = '{B3C7397C-D303-414D-B33C-4ED2C9D29733}'; + {$EXTERNALSYM KSDATAFORMAT_SUBTYPE_ATSC_SI} + KSDATAFORMAT_SUBTYPE_DVB_SI : TGUID = '{e9dd31a3-221d-4adb-8532-9af309c1a408}'; + {$EXTERNALSYM KSDATAFORMAT_SUBTYPE_DVB_SI} + KSDATAFORMAT_SUBTYPE_BDA_OPENCABLE_PSIP : TGUID = '{762E3F66-336F-48d1-BF83-2B00352C11F0}'; + {$EXTERNALSYM KSDATAFORMAT_SUBTYPE_BDA_OPENCABLE_PSIP} + KSDATAFORMAT_SUBTYPE_BDA_OPENCABLE_OOB_PSIP : TGUID = '{951727DB-D2CE-4528-96F6-3301FABB2DE0}'; + {$EXTERNALSYM KSDATAFORMAT_SUBTYPE_BDA_OPENCABLE_OOB_PSIP} + +//=========================================================================== +// +// KSPinName Definitions for BDA +// +//=========================================================================== + +// Pin name for a BDA transport pin + PINNAME_BDA_TRANSPORT : TGUID = '{78216A81-CFA8-493e-9711-36A61C08BD9D}'; + {$EXTERNALSYM PINNAME_BDA_TRANSPORT} + +// Pin name for a BDA analog video pin + PINNAME_BDA_ANALOG_VIDEO : TGUID = '{5C0C8281-5667-486c-8482-63E31F01A6E9}'; + {$EXTERNALSYM PINNAME_BDA_ANALOG_VIDEO} + +// Pin name for a BDA analog audio pin + PINNAME_BDA_ANALOG_AUDIO : TGUID = '{D28A580A-9B1F-4b0c-9C33-9BF0A8EA636B}'; + {$EXTERNALSYM PINNAME_BDA_ANALOG_AUDIO} + +// Pin name for a BDA FM Radio pin + PINNAME_BDA_FM_RADIO : TGUID = '{D2855FED-B2D3-4eeb-9BD0-193436A2F890}'; + {$EXTERNALSYM PINNAME_BDA_FM_RADIO} + +// Pin name for a BDA Intermediate Frequency pin + PINNAME_BDA_IF_PIN : TGUID = '{1A9D4A42-F3CD-48a1-9AEA-71DE133CBE14}'; + {$EXTERNALSYM PINNAME_BDA_IF_PIN} + +// Pin name for a BDA Open Cable PSIP pin + PINNAME_BDA_OPENCABLE_PSIP_PIN : TGUID = '{297BB104-E5C9-4ACE-B123-95C3CBB24D4F}'; + {$EXTERNALSYM PINNAME_BDA_OPENCABLE_PSIP_PIN} + +//=========================================================================== +// +// KSProperty Set Definitions for BDA +// +//=========================================================================== + + +//------------------------------------------------------------ +// +// BDA Network Ethernet Filter Property Set + KSPROPSETID_BdaEthernetFilter : TGUID = '{71985F43-1CA1-11d3-9CC8-00C04F7971E0}'; + {$EXTERNALSYM KSPROPSETID_BdaEthernetFilter} + +type + KSPROPERTY_BDA_ETHERNET_FILTER = ( + KSPROPERTY_BDA_ETHERNET_FILTER_MULTICAST_LIST_SIZE, + KSPROPERTY_BDA_ETHERNET_FILTER_MULTICAST_LIST, + KSPROPERTY_BDA_ETHERNET_FILTER_MULTICAST_MODE + ); + {$EXTERNALSYM KSPROPERTY_BDA_ETHERNET_FILTER} + TKSPropertyBDAEthernetFilter = KSPROPERTY_BDA_ETHERNET_FILTER; + +//------------------------------------------------------------ +// +// BDA Network IPv4 Filter Property Set +// +// {71985F44-1CA1-11d3-9CC8-00C04F7971E0} +// +const + KSPROPSETID_BdaIPv4Filter : TGUID ='{71985F44-1CA1-11d3-9CC8-00C04F7971E0}'; + {$EXTERNALSYM KSPROPSETID_BdaIPv4Filter} + +type + KSPROPERTY_BDA_IPv4_FILTER = ( + KSPROPERTY_BDA_IPv4_FILTER_MULTICAST_LIST_SIZE, + KSPROPERTY_BDA_IPv4_FILTER_MULTICAST_LIST, + KSPROPERTY_BDA_IPv4_FILTER_MULTICAST_MODE + ); + {$EXTERNALSYM KSPROPERTY_BDA_IPv4_FILTER} + TKSPropertyBDAIPv4Filter = KSPROPERTY_BDA_IPv4_FILTER; +//------------------------------------------------------------ +// +// BDA Network IPv6 Filter Property Set +// +// {E1785A74-2A23-4fb3-9245-A8F88017EF33} +// +const + KSPROPSETID_BdaIPv6Filter : TGUID = '{E1785A74-2A23-4fb3-9245-A8F88017EF33}'; + {$EXTERNALSYM KSPROPSETID_BdaIPv6Filter} + +type + KSPROPERTY_BDA_IPv6_FILTER = ( + KSPROPERTY_BDA_IPv6_FILTER_MULTICAST_LIST_SIZE, + KSPROPERTY_BDA_IPv6_FILTER_MULTICAST_LIST, + KSPROPERTY_BDA_IPv6_FILTER_MULTICAST_MODE + ); + {$EXTERNALSYM KSPROPERTY_BDA_IPv6_FILTER} + TKSPropertyBDAIPv6Filter = KSPROPERTY_BDA_IPv6_FILTER; + +//------------------------------------------------------------ +// BDA Signal Statistics Property Set +// + +const + KSPROPSETID_BdaSignalStats : TGUID = '{1347D106-CF3A-428a-A5CB-AC0D9A2A4338}'; + {$EXTERNALSYM KSPROPSETID_BdaSignalStats} + +type + KSPROPERTY_BDA_SIGNAL_STATS = ( + KSPROPERTY_BDA_SIGNAL_STRENGTH, + KSPROPERTY_BDA_SIGNAL_QUALITY, + KSPROPERTY_BDA_SIGNAL_PRESENT, + KSPROPERTY_BDA_SIGNAL_LOCKED, + KSPROPERTY_BDA_SAMPLE_TIME + ); + {$EXTERNALSYM KSPROPERTY_BDA_SIGNAL_STATS} + TKSPropertyBDASignalStats = KSPROPERTY_BDA_SIGNAL_STATS; + +//------------------------------------------------------------ +// BDA Signal Property Set +// +// {D2F1644B-B409-11d2-BC69-00A0C9EE9E16} + +const + KSPROPSETID_BdaSignal : TGUID = '{D2F1644B-B409-11d2-BC69-00A0C9EE9E16}'; + {$EXTERNALSYM KSPROPSETID_BdaSignal} + +//type +// KSPROPERTY_BDA_SIGNAL = ( +// KSPROPERTY_BDA_SIGNAL_SOURCE, +// KSPROPERTY_BDA_SIGNAL_TUNING_SPACE, +// KSPROPERTY_BDA_SIGNAL_NETWORK_TYPE, +// KSPROPERTY_BDA_SIGNAL_STATE +// ); +// {$NODEFINE KSPROPERTY_BDA_SIGNAL} +// TKSPropertyBDASignal = KSPROPERTY_BDA_SIGNAL; +// {$NODEFINE TKSPropertyBDASignal} + +//------------------------------------------------------------ +// +// +// BDA Change Sync Method Set +// +const + KSMETHODSETID_BdaChangeSync : TGUID = '{FD0A5AF3-B41D-11d2-9C95-00C04F7971E0}'; + {$EXTERNALSYM KSMETHODSETID_BdaChangeSync} + +type + KSMETHOD_BDA_CHANGE_SYNC = ( + KSMETHOD_BDA_START_CHANGES, + KSMETHOD_BDA_CHECK_CHANGES, + KSMETHOD_BDA_COMMIT_CHANGES, + KSMETHOD_BDA_GET_CHANGE_STATE + ); + {$EXTERNALSYM KSMETHOD_BDA_CHANGE_SYNC} + TKSMethodBDAChangeSync = KSMETHOD_BDA_CHANGE_SYNC; + +//------------------------------------------------------------ +// +// +// BDA Device Configuration Method Set +// +const + KSMETHODSETID_BdaDeviceConfiguration : TGUID = '{71985F45-1CA1-11d3-9CC8-00C04F7971E0}'; + {$EXTERNALSYM KSMETHODSETID_BdaDeviceConfiguration} + +type + KSMETHOD_BDA_DEVICE_CONFIGURATION = ( + KSMETHOD_BDA_CREATE_PIN_FACTORY, + KSMETHOD_BDA_DELETE_PIN_FACTORY, + KSMETHOD_BDA_CREATE_TOPOLOGY + ); + {$EXTERNALSYM KSMETHOD_BDA_DEVICE_CONFIGURATION} + TKSMethodBDADeviceConfiguration = KSMETHOD_BDA_DEVICE_CONFIGURATION; + +//------------------------------------------------------------ +// +// +// BDA Topology Property Set +// +const + KSPROPSETID_BdaTopology : TGUID = '{A14EE835-0A23-11d3-9CC7-00C04F7971E0}'; + {$EXTERNALSYM KSPROPSETID_BdaTopology} + +type + KSPROPERTY_BDA_TOPOLOGY = ( + KSPROPERTY_BDA_NODE_TYPES, + KSPROPERTY_BDA_PIN_TYPES, + KSPROPERTY_BDA_TEMPLATE_CONNECTIONS, + KSPROPERTY_BDA_NODE_METHODS, + KSPROPERTY_BDA_NODE_PROPERTIES, + KSPROPERTY_BDA_NODE_EVENTS, + KSPROPERTY_BDA_CONTROLLING_PIN_ID, + KSPROPERTY_BDA_NODE_DESCRIPTORS + ); + {$EXTERNALSYM KSPROPERTY_BDA_TOPOLOGY} + TKSPropertyBDATopology = KSPROPERTY_BDA_TOPOLOGY; + +//------------------------------------------------------------ +// +// +// BDA Pin Control Property Set +// +// {0DED49D5-A8B7-4d5d-97A1-12B0C195874D} +// +const + KSPROPSETID_BdaPinControl : TGUID = '{0DED49D5-A8B7-4d5d-97A1-12B0C195874D}'; + {$EXTERNALSYM KSPROPSETID_BdaPinControl} + +type + KSPROPERTY_BDA_PIN_CONTROL = ( + KSPROPERTY_BDA_PIN_ID, + KSPROPERTY_BDA_PIN_TYPE + ); + {$EXTERNALSYM KSPROPERTY_BDA_PIN_CONTROL} + TKSPropertyBDAPinControl = KSPROPERTY_BDA_PIN_CONTROL; + +//------------------------------------------------------------ +// +// +// BDA Pin Event Set + +const + KSEVENTSETID_BdaPinEvent : TGUID = '{104781CD-50BD-40d5-95FB-087E0E86A591}'; + {$EXTERNALSYM KSEVENTSETID_BdaPinEvent} + +type + KSPROPERTY_BDA_PIN_EVENT = ( + {$EXTERNALSYM KSPROPERTY_BDA_PIN_EVENT} + KSEVENT_BDA_PIN_CONNECTED, + KSEVENT_BDA_PIN_DISCONNECTED + ); + TKSPropertyBDAPinEvent = KSPROPERTY_BDA_PIN_EVENT; + +//------------------------------------------------------------ +// +// +// BDA Void Transform Property Set +// +const + KSPROPSETID_BdaVoidTransform : TGUID = '{71985F46-1CA1-11d3-9CC8-00C04F7971E0}'; + {$EXTERNALSYM KSPROPSETID_BdaVoidTransform} + +type + KSPROPERTY_BDA_VOID_TRANSFORM = ( + KSPROPERTY_BDA_VOID_TRANSFORM_START, + KSPROPERTY_BDA_VOID_TRANSFORM_STOP + ); + {$EXTERNALSYM KSPROPERTY_BDA_VOID_TRANSFORM} + TKSPropertyBDAVoidTransform = KSPROPERTY_BDA_VOID_TRANSFORM; + +//------------------------------------------------------------ +// +// +// BDA Null Transform Property Set +// +const + KSPROPSETID_BdaNullTransform : TGUID = '{DDF15B0D-BD25-11d2-9CA0-00C04F7971E0}'; + {$EXTERNALSYM KSPROPSETID_BdaNullTransform} + +type + KSPROPERTY_BDA_NULL_TRANSFORM = ( + KSPROPERTY_BDA_NULL_TRANSFORM_START, + KSPROPERTY_BDA_NULL_TRANSFORM_STOP + ); + {$EXTERNALSYM KSPROPERTY_BDA_NULL_TRANSFORM} + TKSPropertyBDANullTransform = KSPROPERTY_BDA_NULL_TRANSFORM; + +//------------------------------------------------------------ +// +// +// BDA Frequency Filter Property Set +// +const + KSPROPSETID_BdaFrequencyFilter : TGUID = '{71985F47-1CA1-11d3-9CC8-00C04F7971E0}'; + {$EXTERNALSYM KSPROPSETID_BdaFrequencyFilter} + +type + KSPROPERTY_BDA_FREQUENCY_FILTER = ( + KSPROPERTY_BDA_RF_TUNER_FREQUENCY, + KSPROPERTY_BDA_RF_TUNER_POLARITY, + KSPROPERTY_BDA_RF_TUNER_RANGE, + KSPROPERTY_BDA_RF_TUNER_TRANSPONDER, + KSPROPERTY_BDA_RF_TUNER_BANDWIDTH, + KSPROPERTY_BDA_RF_TUNER_FREQUENCY_MULTIPLIER + ); + {$EXTERNALSYM KSPROPERTY_BDA_FREQUENCY_FILTER} + TKSPropertyBDAFrequencyFilter = KSPROPERTY_BDA_FREQUENCY_FILTER; + + +//------------------------------------------------------------ +// BDA LNB Info Property Set +// +// {992CF102-49F9-4719-A664-C4F23E2408F4} + +const + KSPROPSETID_BdaLNBInfo : TGUID = '{992CF102-49F9-4719-A664-C4F23E2408F4}'; + {$EXTERNALSYM KSPROPSETID_BdaLNBInfo} + +type + KSPROPERTY_BDA_LNB_INFO = ( + KSPROPERTY_BDA_LNB_LOF_LOW_BAND, + KSPROPERTY_BDA_LNB_LOF_HIGH_BAND, + KSPROPERTY_BDA_LNB_SWITCH_FREQUENCY + ); + {$EXTERNALSYM KSPROPERTY_BDA_LNB_INFO} + TKSPropertyBDALNBInfo = KSPROPERTY_BDA_LNB_INFO; + +//------------------------------------------------------------ +// +// +// BDA Digital Demodulator Property Set +// +const + KSPROPSETID_BdaDigitalDemodulator : TGUID = '{EF30F379-985B-4d10-B640-A79D5E04E1E0}'; + {$EXTERNALSYM KSPROPSETID_BdaDigitalDemodulator} + +type + KSPROPERTY_BDA_DIGITAL_DEMODULATOR = ( + KSPROPERTY_BDA_MODULATION_TYPE, + KSPROPERTY_BDA_INNER_FEC_TYPE, + KSPROPERTY_BDA_INNER_FEC_RATE, + KSPROPERTY_BDA_OUTER_FEC_TYPE, + KSPROPERTY_BDA_OUTER_FEC_RATE, + KSPROPERTY_BDA_SYMBOL_RATE, + KSPROPERTY_BDA_SPECTRAL_INVERSION, + KSPROPERTY_BDA_GUARD_INTERVAL, + KSPROPERTY_BDA_TRANSMISSION_MODE + ); + {$EXTERNALSYM KSPROPERTY_BDA_DIGITAL_DEMODULATOR} + TKSPropertyBDADigitalDemodulator = KSPROPERTY_BDA_DIGITAL_DEMODULATOR; + +//------------------------------------------------------------ +// +// +// BDA Table Section Property Set +// +// {516B99C5-971C-4aaf-B3F3-D9FDA8A15E16} +// + +const + KSPROPSETID_BdaTableSection : TGUID = '{516B99C5-971C-4aaf-B3F3-D9FDA8A15E16}'; + {$EXTERNALSYM KSPROPSETID_BdaTableSection} + +type + KSPROPERTY_IDS_BDA_TABLE = ( + KSPROPERTY_BDA_TABLE_SECTION + ); + {$EXTERNALSYM KSPROPERTY_IDS_BDA_TABLE} + TKSPropertyIdsBDATable = KSPROPERTY_IDS_BDA_TABLE; + +//------------------------------------------------------------ +// +// BDA PID Filter Property Set +// +const + KSPROPSETID_BdaPIDFilter : TGUID = '{D0A67D65-08DF-4fec-8533-E5B550410B85}'; + {$EXTERNALSYM KSPROPSETID_BdaPIDFilter} + +type + KSPROPERTY_BDA_PIDFILTER = ( + KSPROPERTY_BDA_PIDFILTER_MAP_PIDS, + KSPROPERTY_BDA_PIDFILTER_UNMAP_PIDS, + KSPROPERTY_BDA_PIDFILTER_LIST_PIDS + ); + {$EXTERNALSYM KSPROPERTY_BDA_PIDFILTER} + TKSPropertyBDAPIDFilter = KSPROPERTY_BDA_PIDFILTER; + +//------------------------------------------------------------ +// +// BDA CA Property Set +// +const + KSPROPSETID_BdaCA : TGUID = '{B0693766-5278-4ec6-B9E1-3CE40560EF5A}'; + {$EXTERNALSYM KSPROPSETID_BdaCA} + +type + KSPROPERTY_BDA_CA = ( + KSPROPERTY_BDA_ECM_MAP_STATUS, + KSPROPERTY_BDA_CA_MODULE_STATUS, + KSPROPERTY_BDA_CA_SMART_CARD_STATUS, + KSPROPERTY_BDA_CA_MODULE_UI, + KSPROPERTY_BDA_CA_SET_PROGRAM_PIDS, + KSPROPERTY_BDA_CA_REMOVE_PROGRAM + ); + {$EXTERNALSYM KSPROPERTY_BDA_CA} + TKSPropertyBDACA = KSPROPERTY_BDA_CA; + +//------------------------------------------------------------ +// +// BDA CA Event Set +// +const + KSEVENTSETID_BdaCAEvent : TGUID = '{488C4CCC-B768-4129-8EB1-B00A071F9068}'; + {$EXTERNALSYM KSEVENTSETID_BdaCAEvent} + +type + KSPROPERTY_BDA_CA_EVENT = ( + KSEVENT_BDA_PROGRAM_FLOW_STATUS_CHANGED, + KSEVENT_BDA_CA_MODULE_STATUS_CHANGED, + KSEVENT_BDA_CA_SMART_CARD_STATUS_CHANGED, + KSEVENT_BDA_CA_MODULE_UI_REQUESTED + ); + {$EXTERNALSYM KSPROPERTY_BDA_CA_EVENT} + TKSPropertyBDACAEvent = KSPROPERTY_BDA_CA_EVENT; + +//=========================================================================== +// +// BDA Filter Categories +// +//=========================================================================== +const + KSCATEGORY_BDA_RECEIVER_COMPONENT : TGUID = '{FD0A5AF4-B41D-11d2-9C95-00C04F7971E0}'; + {$EXTERNALSYM KSCATEGORY_BDA_RECEIVER_COMPONENT} + KSCATEGORY_BDA_NETWORK_TUNER : TGUID = '{71985F48-1CA1-11d3-9CC8-00C04F7971E0}'; + {$EXTERNALSYM KSCATEGORY_BDA_NETWORK_TUNER} + KSCATEGORY_BDA_NETWORK_EPG : TGUID = '{71985F49-1CA1-11d3-9CC8-00C04F7971E0}'; + {$EXTERNALSYM KSCATEGORY_BDA_NETWORK_EPG} + KSCATEGORY_BDA_IP_SINK : TGUID = '{71985F4A-1CA1-11d3-9CC8-00C04F7971E0}'; + {$EXTERNALSYM KSCATEGORY_BDA_IP_SINK} + KSCATEGORY_BDA_NETWORK_PROVIDER : TGUID = '{71985F4B-1CA1-11d3-9CC8-00C04F7971E0}'; + {$EXTERNALSYM KSCATEGORY_BDA_NETWORK_PROVIDER} + KSCATEGORY_BDA_TRANSPORT_INFORMATION : TGUID = '{A2E3074F-6C3D-11d3-B653-00C04F79498E}'; + {$EXTERNALSYM KSCATEGORY_BDA_TRANSPORT_INFORMATION} + +//=========================================================================== +// +// BDA Node Categories +// +//=========================================================================== + + KSNODE_BDA_RF_TUNER : TGUID = '{71985F4C-1CA1-11d3-9CC8-00C04F7971E0}'; + {$EXTERNALSYM KSNODE_BDA_RF_TUNER} + KSNODE_BDA_QAM_DEMODULATOR : TGUID = '{71985F4D-1CA1-11d3-9CC8-00C04F7971E0}'; + {$EXTERNALSYM KSNODE_BDA_QAM_DEMODULATOR} + KSNODE_BDA_QPSK_DEMODULATOR : TGUID = '{6390C905-27C1-4d67-BDB7-77C50D079300}'; + {$EXTERNALSYM KSNODE_BDA_QPSK_DEMODULATOR} + KSNODE_BDA_8VSB_DEMODULATOR : TGUID = '{71985F4F-1CA1-11d3-9CC8-00C04F7971E0}'; + {$EXTERNALSYM KSNODE_BDA_8VSB_DEMODULATOR} + KSNODE_BDA_OPENCABLE_POD : TGUID = '{D83EF8FC-F3B8-45ab-8B71-ECF7C339DEB4}'; + {$EXTERNALSYM KSNODE_BDA_OPENCABLE_POD} + KSNODE_BDA_PID_FILTER : TGUID = '{F5412789-B0A0-44e1-AE4F-EE999B1B7FBE}'; + {$EXTERNALSYM KSNODE_BDA_PID_FILTER} + KSNODE_BDA_IP_SINK : TGUID = '{71985F4E-1CA1-11d3-9CC8-00C04F7971E0}'; + {$EXTERNALSYM KSNODE_BDA_IP_SINK} + + KSNODE_BDA_COFDM_DEMODULATOR: TGUID = '{2DAC6E05-EDBE-4b9c-B387-1B6FAD7D6495}'; + {$EXTERNALSYM KSNODE_BDA_COFDM_DEMODULATOR} + KSNODE_BDA_COMMON_CA_POD : TGUID = '{D83EF8FC-F3B8-45ab-8B71-ECF7C339DEB4}'; + {$EXTERNALSYM KSNODE_BDA_COMMON_CA_POD} + +//=========================================================================== +// +// IPSink PINNAME GUID +// +//=========================================================================== + + PINNAME_IPSINK_INPUT : TGUID = '{3fdffa70-ac9a-11d2-8f17-00c04f7971e2}'; + {$EXTERNALSYM PINNAME_IPSINK_INPUT} + +//=========================================================================== +// +// BDA IPSink Categories/Types +// +//=========================================================================== + + KSDATAFORMAT_TYPE_BDA_IP : TGUID = '{e25f7b8e-cccc-11d2-8f25-00c04f7971e2}'; + {$EXTERNALSYM KSDATAFORMAT_TYPE_BDA_IP} + KSDATAFORMAT_SUBTYPE_BDA_IP : TGUID = '{5a9a213c-db08-11d2-8f32-00c04f7971e2}'; + {$EXTERNALSYM KSDATAFORMAT_SUBTYPE_BDA_IP} + KSDATAFORMAT_SPECIFIER_BDA_IP : TGUID = '{6B891420-DB09-11d2-8F32-00C04F7971E2}'; + {$EXTERNALSYM KSDATAFORMAT_SPECIFIER_BDA_IP} + KSDATAFORMAT_TYPE_BDA_IP_CONTROL : TGUID = '{DADD5799-7D5B-4b63-80FB-D1442F26B621}'; + {$EXTERNALSYM KSDATAFORMAT_TYPE_BDA_IP_CONTROL} + KSDATAFORMAT_SUBTYPE_BDA_IP_CONTROL : TGUID = '{499856E8-E85B-48ed-9BEA-410D0DD4EF81}'; + {$EXTERNALSYM KSDATAFORMAT_SUBTYPE_BDA_IP_CONTROL} + +//=========================================================================== +// +// MPE PINNAME GUID +// +//=========================================================================== + + PINNAME_MPE : TGUID = '{C1B06D73-1DBB-11d3-8F46-00C04F7971E2}'; + {$EXTERNALSYM PINNAME_MPE} + +///////////////////////////////////////////////////////////// +// +// BDA MPE Categories/Types +// + KSDATAFORMAT_TYPE_MPE : TGUID = '{455F176C-4B06-47ce-9AEF-8CAEF73DF7B5}'; + {$EXTERNALSYM KSDATAFORMAT_TYPE_MPE} + +//------------------------------------------------------------------------------ +// File: BDAIface.idl +// +// Desc: This file defines the Ring 3 BDA interfaces that are common to +// all BDA network and device types. +// +// The interfaces specific to a particular Network Type or filter +// implementation are defined in a separate include file for that +// Network Type or filter implementation. +// +// Copyright (c) 1999 - 2001, Microsoft Corporation. All rights reserved. +//------------------------------------------------------------------------------ + + + + +const + IID_IBDA_NetworkProvider : TGUID = '{fd501041-8ebe-11ce-8183-00aa00577da2}'; + {$EXTERNALSYM IID_IBDA_NetworkProvider} + IID_IBDA_EthernetFilter : TGUID = '{71985F43-1CA1-11d3-9CC8-00C04F7971E0}'; + {$EXTERNALSYM IID_IBDA_EthernetFilter} + IID_IBDA_IPV4Filter : TGUID = '{71985F44-1CA1-11d3-9CC8-00C04F7971E0}'; + {$EXTERNALSYM IID_IBDA_IPV4Filter} + IID_IBDA_IPV6Filter : TGUID = '{E1785A74-2A23-4fb3-9245-A8F88017EF33}'; + {$EXTERNALSYM IID_IBDA_IPV6Filter} + IID_IBDA_DeviceControl : TGUID = '{FD0A5AF3-B41D-11d2-9C95-00C04F7971E0}'; + {$EXTERNALSYM IID_IBDA_DeviceControl} + IID_IBDA_PinControl : TGUID = '{0DED49D5-A8B7-4d5d-97A1-12B0C195874D}'; + {$EXTERNALSYM IID_IBDA_PinControl} + IID_IBDA_SignalProperties : TGUID = '{D2F1644B-B409-11d2-BC69-00A0C9EE9E16}'; + {$EXTERNALSYM IID_IBDA_SignalProperties} + IID_IBDA_VoidTransform : TGUID = '{71985F46-1CA1-11d3-9CC8-00C04F7971E0}'; + {$EXTERNALSYM IID_IBDA_VoidTransform} + IID_IBDA_NullTransform : TGUID = '{DDF15B0D-BD25-11d2-9CA0-00C04F7971E0}'; + {$EXTERNALSYM IID_IBDA_NullTransform} + IID_IBDA_FrequencyFilter : TGUID = '{71985F47-1CA1-11d3-9CC8-00C04F7971E0}'; + {$EXTERNALSYM IID_IBDA_FrequencyFilter} + IID_IBDA_AutoDemodulate : TGUID = '{DDF15B12-BD25-11d2-9CA0-00C04F7971E0}'; + {$EXTERNALSYM IID_IBDA_AutoDemodulate} + IID_IBDA_DigitalDemodulator : TGUID = '{EF30F379-985B-4d10-B640-A79D5E04E1E0}'; + {$EXTERNALSYM IID_IBDA_DigitalDemodulator} + IID_IBDA_IPSinkControl : TGUID = '{3F4DC8E2-4050-11d3-8F4B-00C04F7971E2}'; + {$EXTERNALSYM IID_IBDA_IPSinkControl} + IID_IEnumPIDMap : TGUID = '{afb6c2a2-2c41-11d3-8a60-0000f81e0e4a}'; + {$EXTERNALSYM IID_IEnumPIDMap} + IID_IMPEG2PIDMap : TGUID = '{afb6c2a1-2c41-11d3-8a60-0000f81e0e4a}'; + {$EXTERNALSYM IID_IMPEG2PIDMap} + IID_IBDA_SignalStatistics : TGUID = '{1347D106-CF3A-428a-A5CB-AC0D9A2A4338}'; + {$EXTERNALSYM IID_IBDA_SignalStatistics} + IID_IBDA_Topology : TGUID = '{79B56888-7FEA-4690-B45D-38FD3C7849BE}'; + {$EXTERNALSYM IID_IBDA_Topology} + IID_IBDA_LNBInfo : TGUID = '{992CF102-49F9-4719-A664-C4F23E2408F4}'; + {$EXTERNALSYM IID_IBDA_LNBInfo} + IID_IBDA_IPSinkInfo : TGUID = '{A750108F-492E-4d51-95F7-649B23FF7AD7}'; + {$EXTERNALSYM IID_IBDA_IPSinkInfo} + + IID_IFrequencyMap : TGUID = '{06FB45C1-693C-4ea7-B79F-7A6A54D8DEF2}'; //DX9 + {$EXTERNALSYM IID_IFrequencyMap} + +type + + {$HPPEMIT 'typedef System::DelphiInterface _di_IBDA_NetworkProvider;'} + {$EXTERNALSYM IBDA_NetworkProvider} + IBDA_NetworkProvider = interface(IUnknown) + ['{fd501041-8ebe-11ce-8183-00aa00577da2}'] + (*** IBDA_NetworkProvider methods ***) + function PutSignalSource(ulSignalSource: ULONG): HResult; stdcall; + function GetSignalSource(out pulSignalSource: ULONG): HResult; stdcall; + function GetNetworkType(var pguidNetworkType: TGUID): HResult; stdcall; + function PutTuningSpace(const guidTuningSpace: TGUID): HResult; stdcall; + function GetTuningSpace(out pguidTuingSpace: TGUID): HResult; stdcall; + function RegisterDeviceFilter(pUnkFilterControl: IUnknown; + var ppvRegisitrationContext: ULONG): HResult; stdcall; + function UnRegisterDeviceFilter(pvRegistrationContext: ULONG): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IBDA_EthernetFilter;'} + {$EXTERNALSYM IBDA_EthernetFilter} + IBDA_EthernetFilter = interface(IUnknown) + ['{71985F43-1CA1-11d3-9CC8-00C04F7971E0}'] + (*** IBDA_EthernetFilter methods ***) + function GetMulticastListSize(out pulcbAddresses: ULONG): HResult; stdcall; + function PutMulticastList(ulcbAddresses: ULONG; pAddressList: Pointer): HResult; stdcall; + function GetMulticastList(out pulcbAddresses: ULONG; + out pAddressList): HResult; stdcall; + function PutMulticastMode(ulModeMask: ULONG): HResult; stdcall; + function GetMulticastMode(out pulModeMask: ULONG): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IBDA_IPV4Filter;'} + {$EXTERNALSYM IBDA_IPV4Filter} + IBDA_IPV4Filter = interface(IUnknown) + ['{71985F44-1CA1-11d3-9CC8-00C04F7971E0}'] + (*** IBDA_IPV4Filter methods ***) + function GetMulticastListSize(out pulcbAddresses: ULONG): HResult; stdcall; + function PutMulticastList(ulcbAddresses: ULONG; pAddressList: Pointer): HResult; stdcall; + function GetMulticastList(var pulcbAddresses: ULONG; out pAddressList): HResult; stdcall; + function PutMulticastMode(ulModeMask: ULONG): HResult; stdcall; + function GetMulticastMode(out pulModeMask: ULONG): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IBDA_IPV6Filter;'} + {$EXTERNALSYM IBDA_IPV6Filter} + IBDA_IPV6Filter = interface(IUnknown) + ['{E1785A74-2A23-4fb3-9245-A8F88017EF33}'] + (*** IBDA_IPV6Filter methods ***) + function GetMulticastListSize(out pulcbAddresses: ULONG): HResult; stdcall; + function PutMulticastList(ulcbAddresses: ULONG; pAddressList: Pointer): HResult; stdcall; + function GetMulticastList(var pulcbAddresses: ULONG; out pAddressList): HResult; stdcall; + function PutMulticastMode(ulModeMask: ULONG): HResult; stdcall; + function GetMulticastMode(out pulModeMask: ULONG): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IBDA_DeviceControl;'} + {$EXTERNALSYM IBDA_DeviceControl} + IBDA_DeviceControl = interface(IUnknown) + ['{FD0A5AF3-B41D-11d2-9C95-00C04F7971E0}'] + (*** IBDA_DeviceControl methods ***) + function StartChanges : HResult; stdcall; + function CheckChanges : HResult; stdcall; + function CommitChanges : HResult; stdcall; + function GetChangeState(var pState: ULONG): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IBDA_PinControl;'} + {$EXTERNALSYM IBDA_PinControl} + IBDA_PinControl = interface(IUnknown) + ['{0DED49D5-A8B7-4d5d-97A1-12B0C195874D}'] + (*** IBDA_PinControl methods ***) + function GetPinID(var pulPinID: ULONG): HResult; stdcall; + function GetPinType(var pulPinType: ULONG): HResult; stdcall; + function RegistrationContext(var pulRegistrationCtx: ULONG): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IBDA_SignalProperties;'} + {$EXTERNALSYM IBDA_SignalProperties} + IBDA_SignalProperties = interface(IUnknown) + ['{D2F1644B-B409-11d2-BC69-00A0C9EE9E16}'] + (*** IBDA_SignalProperties methods ***) + function PutNetworkType(const guidNetworkType: TGUID): HResult; stdcall; + function GetNetworkType(out pguidNetworkType: TGUID): HResult; stdcall; + function PutSignalSource(ulSignalSource: ULONG): HResult; stdcall; + function GetSignalSource(out pulSignalSource: ULONG): HResult; stdcall; + function PutTuningSpace(const guidTuningSpace: TGUID): HResult; stdcall; + function GetTuningSpace(out pguidTuingSpace: TGUID): HResult; stdcall; + end; + + //--------------------------------------------------------------------- + // + // IBDA_SignalStatistics interface + // + // Implemented by a BDA Control Node + // + // A BDA Control Node may return these properties to describe + // the condition of a signal that is being received. + // + //--------------------------------------------------------------------- + + {$HPPEMIT 'typedef System::DelphiInterface _di_IBDA_SignalStatistics;'} + {$EXTERNALSYM IBDA_SignalStatistics} + IBDA_SignalStatistics = interface(IUnknown) + ['{1347D106-CF3A-428a-A5CB-AC0D9A2A4338}'] + (*** IBDA_SignalStatistics methods ***) + function put_SignalStrength(lDbStrength: LongInt): HResult; stdcall; + function get_SignalStrength(out plDbStrength: LongInt): HResult; stdcall; + function put_SignalQuality(lPercentQuality: LongInt): HResult; stdcall; + function get_SignalQuality(out lPercentQuality: LongInt): HResult; stdcall; + function put_SignalPresent(fPresent: BOOL): HResult; stdcall; + function get_SignalPresent(out fPresent: BOOL): HResult; stdcall; + function put_SignalLocked(fLocked: BOOL): HResult; stdcall; + function get_SignalLocked(out pfLocked: BOOL): HResult; stdcall; + function put_SampleTime(lmsSampleTime: LongInt): HResult; stdcall; + function get_SampleTime(out plmsSampleTime: LongInt): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IBDA_Topology;'} + {$EXTERNALSYM IBDA_Topology} + IBDA_Topology = interface(IUnknown) + ['{79B56888-7FEA-4690-B45D-38FD3C7849BE}'] + (*** IBDA_Topology methods ***) + function GetNodeTypes(var pulcNodeTypes: ULONG; ulcNodeTypesMax: ULONG; + var rgulNodeTypes: ULONG): HResult; stdcall; + function GetNodeDescriptors(var ulcNodeDescriptors: ULONG; ulcNodeDescriptorsMax: ULONG; + rgNodeDescriptors: PBDANodeDescriptor): HResult; stdcall; + function GetNodeInterfaces(ulNodeType: ULONG; var pulcInterfaces: ULONG; + ulcInterfacesMax: ULONG; rgguidInterfaces: PGUID): HResult; stdcall; + function GetPinTypes(var pulcPinTypes: ULONG; ulcPinTypesMax: ULONG; + var rgulPinTypes: ULONG): HResult; stdcall; + function GetTemplateConnections(var pulcConnections: ULONG; ulcConnectionsMax: ULONG; + var rgConnections: TBDATemplateConnection): HResult; stdcall; + function CreatePin(ulPinType: ULONG; var pulPinId: ULONG): HResult; stdcall; + function DeletePin(ulPinId: ULONG): HResult; stdcall; + function SetMediaType(ulPinId :ULONG; pMediaType: PAMMediaType): HResult; stdcall; + function SetMedium(ulPinId: ULONG; pMedium: PREGPINMEDIUM): HResult; stdcall; + function CreateTopology(ulInputPinId, ulOutputPinId: ULONG): HResult; stdcall; + function GetControlNode(ulInputPinId, ulOutputPinId, ulNodeType: ULONG; + ppControlNode: IUnknown): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IBDA_VoidTransform;'} + {$EXTERNALSYM IBDA_VoidTransform} + IBDA_VoidTransform = interface(IUnknown) + ['{71985F46-1CA1-11d3-9CC8-00C04F7971E0}'] + (*** IBDA_VoidTransform methods ***) + function Start: HResult; stdcall; + function Stop: HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IBDA_NullTransform;'} + {$EXTERNALSYM IBDA_NullTransform} + IBDA_NullTransform = interface(IUnknown) + ['{DDF15B0D-BD25-11d2-9CA0-00C04F7971E0}'] + (*** IBDA_NullTransform methods ***) + function Start: HResult; stdcall; + function Stop: HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IBDA_FrequencyFilter;'} + {$EXTERNALSYM IBDA_FrequencyFilter} + IBDA_FrequencyFilter = interface(IUnknown) + ['{71985F47-1CA1-11d3-9CC8-00C04F7971E0}'] + (*** IBDA_FrequencyFilter methods ***) + function put_Autotune(pulTransponder: PULONG): HResult; stdcall; + function get_Autotune(pulTransponder: PULONG): HResult; stdcall; + function put_Frequency(pulFrequency: PULONG): HResult; stdcall; + function get_Frequency(pulFrequency: PULONG): HResult; stdcall; + function put_Polarity(pulPolarity: PULONG): HResult; stdcall; + function get_Polarity(pulPolarity: PULONG): HResult; stdcall; + function put_Range(pulRange: PULONG): HResult; stdcall; + function get_Range(pulRange: PULONG): HResult; stdcall; + function put_Bandwidth(ulBandwidth: ULONG): HResult; stdcall; + function get_Bandwidth(out pulBandwidth: ULONG): HResult; stdcall; + function put_FrequencyMultiplier(ulMultiplier: ULONG): HResult; stdcall; + function get_FrequencyMultiplier(out pulMultiplier: ULONG): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IBDA_LNBInfo;'} + {$EXTERNALSYM IBDA_LNBInfo} + IBDA_LNBInfo = interface(IUnknown) + ['{992CF102-49F9-4719-A664-C4F23E2408F4}'] + (*** IBDA_LNBInfo methods ***) + function put_LocalOscilatorFrequencyLowBand(ulLOFLow: ULONG): HResult; stdcall; + function get_LocalOscilatorFrequencyLowBand(out pulLOFLow: ULONG): HResult; stdcall; + function put_LocalOscilatorFrequencyHighBand(ulLOFHigh: ULONG): HResult; stdcall; + function get_LocalOscilatorFrequencyHighBand(out pulLOFHigh: ULONG): HResult; stdcall; + function put_HighLowSwitchFrequency(ulSwitchFrequency: ULONG): HResult; stdcall; + function get_HighLowSwitchFrequency(out pulSwitchFrequency: ULONG): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IBDA_AutoDemodulate;'} + {$EXTERNALSYM IBDA_AutoDemodulate} + IBDA_AutoDemodulate = interface(IUnknown) + ['{DDF15B12-BD25-11d2-9CA0-00C04F7971E0}'] + (*** IBDA_AutoDemodulate methods ***) + function put_AutoDemodulate : HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IBDA_DigitalDemodulator;'} + {$EXTERNALSYM IBDA_DigitalDemodulator} + IBDA_DigitalDemodulator = interface(IUnknown) + ['{EF30F379-985B-4d10-B640-A79D5E04E1E0}'] + (*** IBDA_DigitalDemodulator methods ***) + function put_ModulationType(var pModulationType: ModulationType): HResult; stdcall; + function get_ModulationType(out pModulationType: ModulationType): HResult; stdcall; + function put_InnerFECMethod(var pFECMethod: FECMethod): HResult; stdcall; + function get_InnerFECMethod(out pFECMethod: FECMethod): HResult; stdcall; + function put_InnerFECRate(var pFECRate: BinaryConvolutionCodeRate): HResult; stdcall; + function get_InnerFECRate(out pFECRate: BinaryConvolutionCodeRate): HResult; stdcall; + function put_OuterFECMethod(var pFECMethod: FECMethod): HResult; stdcall; + function get_OuterFECMethod(out pFECMethod: FECMethod): HResult; stdcall; + function put_OuterFECRate(var pFECRate: BinaryConvolutionCodeRate): HResult; stdcall; + function get_OuterFECRate(out pFECRate: BinaryConvolutionCodeRate): HResult; stdcall; + function put_SymbolRate(var pSymbolRate: ULONG): HResult; stdcall; + function get_SymbolRate(out pSymbolRate: ULONG): HResult; stdcall; + function put_SpectralInversion(var pSpectralInversion: SpectralInversion): HResult; stdcall; + function get_SpectralInversion(out pSpectralInversion: SpectralInversion): HResult; stdcall; + end; + + KSPROPERTY_IPSINK = ( + KSPROPERTY_IPSINK_MULTICASTLIST, + KSPROPERTY_IPSINK_ADAPTER_DESCRIPTION, + KSPROPERTY_IPSINK_ADAPTER_ADDRESS + ); + {$EXTERNALSYM KSPROPERTY_IPSINK} + TKSPropertyIPSink = KSPROPERTY_IPSINK; + + //--------------------------------------------------------------------- + // IBDA_IPSinkControl interface (mutlimedia\filters.ks\ipsink) + // IBDA_IPSinkInfo interface + // + // IBDA_IPSinkControl is no longer being supported for Ring3 clients. + // Use the BDA_IPSinkInfo interface instead. + //--------------------------------------------------------------------- + + {$HPPEMIT 'typedef System::DelphiInterface _di_IBDA_IPSinkControl;'} + {$EXTERNALSYM IBDA_IPSinkControl} + IBDA_IPSinkControl = interface(IUnknown) + ['{3F4DC8E2-4050-11d3-8F4B-00C04F7971E2}'] + (*** IBDA_IPSinkControl methods ***) + function GetMulticastList(var pulcbSize: ULONG; pbBuffer: Pointer): HResult; stdcall; + function GetAdapterIPAddress(var pulcbSize: ULONG; pbBuffer: Pointer): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IBDA_IPSinkInfo;'} + {$EXTERNALSYM IBDA_IPSinkInfo} + IBDA_IPSinkInfo = interface(IUnknown) + ['{A750108F-492E-4d51-95F7-649B23FF7AD7}'] + (*** IBDA_IPSinkInfo methods ***) + // returns N 6-byte 802.3 IP addreses. + function get_MulticastList(pulcbAddresses: PULONG; // 6*N + out ppbAddressList: PBYTE // Allocated by caller, must deallocate in callee with CoTaskMemFree() + ): HResult; stdcall; + function get_AdapterIPAddress(out pbstrBuffer: WideString): HResult; stdcall; + function get_AdapterDescription(out pbstrBuffer: WideString): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IEnumPIDMap;'} + {$EXTERNALSYM IEnumPIDMap} + IEnumPIDMap = interface(IUnknown) + ['{afb6c2a2-2c41-11d3-8a60-0000f81e0e4a}'] + (*** IEnumPIDMap methods ***) + function Next(cRequest: ULONG; var pPIDMap: TPIDMap; out pcReceived: ULONG): HResult; stdcall; + function Skip(cRecords: ULONG): HResult; stdcall; + function Reset: HResult; stdcall; + function Clone(out ppIEnumPIDMap: IEnumPIDMap): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IMPEG2PIDMap;'} + {$EXTERNALSYM IMPEG2PIDMap} + IMPEG2PIDMap = interface(IUnknown) + ['{afb6c2a1-2c41-11d3-8a60-0000f81e0e4a}'] + (*** IMPEG2PIDMap methods ***) + function MapPID(culPID: ULONG; pulPID: PULONG; + MediaSampleContent: TMediaSampleContent): HResult; stdcall; + function UnmapPID(culPID: ULONG; pulPID: PULONG): HResult; stdcall; + function EnumPIDMap(out pIEnumPIDMap: IEnumPIDMap): HResult; stdcall; + end; + +//--------------------------------------------------------------------- +// IFrequencyMap interface +// Currently implemented on the TIF. The interface can be QIed on the NP +//--------------------------------------------------------------------- + // DirectX9 Specific + {$HPPEMIT 'typedef System::DelphiInterface _di_IFrequencyMap;'} + {$EXTERNALSYM IFrequencyMap} + IFrequencyMap = interface(IUnknown) + ['{06FB45C1-693C-4ea7-B79F-7A6A54D8DEF2}'] + (*** IFrequencyMap methods ***) + function get_FrequencyMapping(out ulCount: ULONG; out ppulList: PULONG): HResult; stdcall; + function put_FrequencyMapping(ulCount: ULONG; pList: PULONG): HResult; stdcall; + function get_CountryCode(out pulCountryCode: ULONG): HResult; stdcall; + function put_CountryCode(ulCountryCode: ULONG): HResult; stdcall; + function get_DefaultFrequencyMapping(ulCountryCode: ULONG; out pulCount: ULONG; + out ppulList: PULONG): HResult; stdcall; + function get_CountryCodeList(out pulCount: ULONG; out ppulList: PULONG): HResult; stdcall; + end; + +//--------------------------------------------------------------------- +// +// Copyright (c) 1999-2001 Microsoft Corporation +// +// BDATIF.idl +// +//--------------------------------------------------------------------- + +const + IID_IMPEG2_TIF_CONTROL : TGUID = '{F9BAC2F9-4149-4916-B2EF-FAA202326862}'; + {$EXTERNALSYM IID_IMPEG2_TIF_CONTROL} + IID_ITuneRequestInfo : TGUID = '{A3B152DF-7A90-4218-AC54-9830BEE8C0B6}'; + {$EXTERNALSYM IID_ITuneRequestInfo} + IID_IGuideDataEvent : TGUID = '{EFDA0C80-F395-42c3-9B3C-56B37DEC7BB7}'; + {$EXTERNALSYM IID_IGuideDataEvent} + IID_IGuideDataProperty : TGUID = '{88EC5E58-BB73-41d6-99CE-66C524B8B591}'; + {$EXTERNALSYM IID_IGuideDataProperty} + IID_IEnumGuideDataProperties : TGUID = '{AE44423B-4571-475c-AD2C-F40A771D80EF}'; + {$EXTERNALSYM IID_IEnumGuideDataProperties} + IID_IEnumTuneRequests : TGUID = '{1993299C-CED6-4788-87A3-420067DCE0C7}'; + {$EXTERNALSYM IID_IEnumTuneRequests} + IID_IGuideData : TGUID = '{61571138-5B01-43cd-AEAF-60B784A0BF93}'; + {$EXTERNALSYM IID_IGuideData} + IID_IGuideDataLoader : TGUID = '{4764ff7c-fa95-4525-af4d-d32236db9e38}'; + {$EXTERNALSYM IID_IGuideDataLoader} + IID_IBDA_TIF_REGISTRATION : TGUID = '{DFEF4A68-EE61-415f-9CCB-CD95F2F98A3A}'; // DX9 + {$EXTERNALSYM IID_IBDA_TIF_REGISTRATION} + + LIBID_PSISLOAD : TGUID = '{8224A083-7F8C-432D-B83E-3C5E9BDE3528}'; + {$EXTERNALSYM LIBID_PSISLOAD} + CLSID_TIFLoad : TGUID = '{14EB8748-1753-4393-95AE-4F7E7A87AAD6}';// default interface IGuideDataEvent + {$EXTERNALSYM CLSID_TIFLoad} + + +//****************************************************************************** +// +// IBDA_TIF_REGISTRATION interface +// +// Implemented by the Microsoft ATSC/DVB BDA Network Provider +// +// Used by a transport information filter (TIF) to Register with the NP +// AND obtain an Interface to the Demux to set/ Remove PIDs.The TIF here passes +// IUNKNOWN of the pin it is connecting to and obtains the IMPEG2PIDMAP interface +// implemented by the NP to Map/ UnMap pids. +// +type + // DirectX9 Specific + {$HPPEMIT 'typedef System::DelphiInterface _di_IBDA_TIF_REGISTRATION;'} + {$EXTERNALSYM IBDA_TIF_REGISTRATION} + IBDA_TIF_REGISTRATION = interface(IUnknown) + ['{DFEF4A68-EE61-415f-9CCB-CD95F2F98A3A}'] + (*** IBDA_TIF_REGISTRATION methods ***) + // Used to register a transport analyzer with the Network Provider. + function RegisterTIFEx(pTIFInputPin: IPin; out ppvRegistrationContext: ULONG; + out ppMpeg2DataControl: IUnknown): HResult; stdcall; + // Used to unregister TIF with the Network Provider. + function UnregisterTIF(pvRegistrationContext: ULONG): HResult; stdcall; + end; + + +//****************************************************************************** +// +// IMPEG2_TIF_CONTROL interface +// +// Implemented by the Microsoft ATSC/DVB BDA Network Provider +// +// Used by a transport information filter (TIF) to request table +// sections carried on specific PIDs within the transport stream. +// The Network Provider Filter will, in turn, do the necessary +// control on the Demux Filter. All sections are delivered as comlete +// mpeg2 table sections via the TIF's connection to the Demux Filter. +// + + {$HPPEMIT 'typedef System::DelphiInterface _di_IMPEG2_TIF_CONTROL;'} + {$EXTERNALSYM IMPEG2_TIF_CONTROL} + IMPEG2_TIF_CONTROL = interface(IUnknown) + ['{F9BAC2F9-4149-4916-B2EF-FAA202326862}'] + (*** IMPEG2_TIF_CONTROL methods ***) + // Used to register a transport analyzer with the Network Provider + function RegisterTIF(pUnkTIF: IUnknown; out ppvRegistrationContext: ULONG): HResult; stdcall; + // Used to unregister TIF with the Network Provider + function UnregisterTIF(pvRegistrationContext: ULONG): HResult; stdcall; + // Used to add PSI/SI MPEG2 packet IDs to the TIF's data stream + function AddPIDs(ulcPIDs: ULONG; pulPIDs: array of ULONG): HResult; stdcall; + // Used to remove PSI/SI MPEG2 packet IDs from the TIF's data stream + function DeletePIDs(ulcPIDs: ULONG; pulPIDs: array of ULONG): HResult; stdcall; + // Returns the number of MPEG2 Packet IDs being filtered into the TIF's input data. + function GetPIDCount(out pulcPIDs: ULONG): HResult; stdcall; + // Returns the the list of MPEG2 Packet IDs being filtered into the TIF's input data. + function GetPIDs(out pulcPIDs: ULONG; pulPIDs: array of ULONG): HResult; stdcall; + end; + + +//****************************************************************************** +// +// ITuneRequestInfo interface +// +// Implemented by a BDA transport information filter (TIF) +// +// Used by the BDA Network Provider to obtain network specific +// information about locating transport streams and aquiring +// services. +// +// GetLocatorData - +// GetComponentData - +// CreateComponentList - +// GetNextService - +// GetPreviouService - +// GetNextLocator - +// GetPreviousLocator - + + {$HPPEMIT 'typedef System::DelphiInterface _di_ITuneRequestInfo;'} + {$EXTERNALSYM ITuneRequestInfo} + ITuneRequestInfo = interface(IUnknown) + ['{A3B152DF-7A90-4218-AC54-9830BEE8C0B6}'] + (*** ITuneRequestInfo methods ***) + // TIF fills in channel/program locator information for the given tune request. + function GetLocatorData(Request: ITuneRequest): HResult; stdcall; + // TIF fills in all network specific component data for the existing component + // list on the given tune request. + function GetComponentData(CurrentRequest: ITuneRequest): HResult; stdcall; + // TIF creates a complete component list and fills in all network specific + // component data on the given tune request + function CreateComponentList(CurrentRequest: ITuneRequest): HResult; stdcall; + // TIF creates a new TuneRequest with channel/program locator information + // for the next service. + function GetNextProgram(CurrentRequest: ITuneRequest; out TuneRequest: ITuneRequest): HResult; stdcall; + // TIF creates a new TuneRequest with channel/program locator information + // for the previous service. + function GetPreviousProgram(CurrentRequest: ITuneRequest; out TuneRequest: ITuneRequest): HResult; stdcall; + // TIF creates a new TuneRequest with locator information for the next transport stream. + function GetNextLocator(CurrentRequest: ITuneRequest; out TuneRequest: ITuneRequest): HResult; stdcall; + // TIF creates a new TuneRequest with locator information for the previous transport stream. + function GetPreviousLocator(CurrentRequest: ITuneRequest; out TuneRequest: ITuneRequest): HResult; stdcall; + end; + +//****************************************************************************** +// +// IGuideDataEvent +// +// This is the guide data event notification callback interface. The +// callback interface is registered on a transport analyzer's +// IConnectionPoint by the event consumer. +// +// The event consumer MUST NOT BLOCK THE CALLING THREAD. +// +// If the consumer requires additional information about the event, it +// should queue the event to a separate thread. +// +// {EFDA0C80-F395-42c3-9B3C-56B37DEC7BB7} +// + + {$HPPEMIT 'typedef System::DelphiInterface _di_IGuideDataEvent;'} + {$EXTERNALSYM IGuideDataEvent} + IGuideDataEvent = interface(IUnknown) + ['{EFDA0C80-F395-42c3-9B3C-56B37DEC7BB7}'] + (*** IGuideDataEvent methods ***) + // Indicates that a complete set of guide data has been acquire from + // the current transport stream. + // + // MANDATORY - If a transport analyzer supports IGuideDataEvent then + // it must supply this event. + // + function GuideDataAcquired: HResult; stdcall; + + // Indicates that information about one or more programs changed. + // + // If varProgramDescriptionID is NULL then the consumer + // must get properties for all programs to determine which ones + // changed. + // + // MANDATORY - If a transport analyzer supports IGuideDataEvent then + // it must supply this event. + // + function ProgramChanged(varProgramDescriptionID: OLEVARIANT): HResult; stdcall; + // Indicates that information about one or more services changed. + // + // If varServiceDescriptionID is NULL then the consumer + // must get properties for all services to determine which ones + // changed. + // + // MANDATORY - If a transport analyzer supports IGuideDataEvent then + // it must supply this event. + // + function ServiceChanged(varServiceDescriptionID: OLEVARIANT): HResult; stdcall; + // Indicates that information about one or more schedule entries + // changed. + // + // If varScheduleEntryDescriptionID is NULL then the consumer + // must get properties for all schedule entries to determine which ones + // changed. + // + // MANDATORY - If a transport analyzer supports IGuideDataEvent then + // it must supply this event. + // + function ScheduleEntryChanged(varScheduleEntryDescriptionID: OLEVARIANT): HResult; stdcall; + // Indicates that the program with the given Description.ID + // has been deleted. + // + // + // Optional - Transport analyzer may supply this event. Consumer + // may return E_NOTIMPL. + // + function ProgramDeleted(varProgramDescriptionID: OLEVARIANT): HResult; stdcall; + // Indicates that the service with the given Description.ID + // has been deleted. + // + // + // Optional - Transport analyzer may supply this event. Consumer + // may return E_NOTIMPL. + // + function ServiceDeleted(varServiceDescriptionID: OLEVARIANT): HResult; stdcall; + // Indicates that the schedule entry with the given Description.ID + // has been deleted. + // + // + // Optional - Transport analyzer may supply this event. Consumer + // may return E_NOTIMPL. + // + function ScheduleDeleted(varScheduleEntryDescriptionID: OLEVARIANT): HResult; stdcall; + end; + +//****************************************************************************** +// +// IGuideDataPropery +// +// {88EC5E58-BB73-41d6-99CE-66C524B8B591} +// +// interface provided by a transport analyzer to represent a guide data property. + + {$HPPEMIT 'typedef System::DelphiInterface _di_IGuideDataProperty;'} + {$EXTERNALSYM IGuideDataProperty} + IGuideDataProperty = interface(IUnknown) + ['{88EC5E58-BB73-41d6-99CE-66C524B8B591}'] + (*** IGuideDataProperty methods ***) + function Name(out pbstrName: TBSTR): HResult; stdcall; + function Language(out idLang: longint): HResult; stdcall; + function Value(out pvar: OLEVARIANT): HResult; stdcall; + end; + +//****************************************************************************** +// +// IEnumGuideDataProperties +// +// {AE44423B-4571-475c-AD2C-F40A771D80EF} +// +// Interface provided by a transport analyzer to enumerate guide data properties. + + {$HPPEMIT 'typedef System::DelphiInterface _di_IEnumGuideDataProperties;'} + {$EXTERNALSYM IEnumGuideDataProperties} + IEnumGuideDataProperties = interface(IUnknown) + ['{AE44423B-4571-475c-AD2C-F40A771D80EF}'] + (*** IEnumGuideDataProperties methods ***) + function Next(celt: ULONG; out ppprop: IGuideDataProperty ; out pcelt: ULONG): HResult; stdcall; + function Skip(celt: ULONG): HResult; stdcall; + function Reset: HResult; stdcall; + function Clone(out ppenum: IEnumGuideDataProperties): HResult; stdcall; + end; + +//****************************************************************************** +// +// IEnumTuneRequests +// +// {1993299C-CED6-4788-87A3-420067DCE0C7} +// +// Interface provided by a transport analyzer to enumerate service tune requests + + {$HPPEMIT 'typedef System::DelphiInterface _di_IEnumTuneRequests;'} + {$EXTERNALSYM IEnumTuneRequests} + IEnumTuneRequests = interface(IUnknown) + ['{1993299C-CED6-4788-87A3-420067DCE0C7}'] + (*** IEnumTuneRequests methods ***) + function Next(celt: ULONG; out ppprop: ITuneRequest; out pcelt: ULONG): HResult; stdcall; + function Skip(celt: ULONG): HResult; stdcall; + function Reset: HResult; stdcall; + function Clone(out ppenum: IEnumTuneRequests): HResult; stdcall; + end; + +//****************************************************************************** +// +// IGuideData +// +// {61571138-5B01-43cd-AEAF-60B784A0BF93} +// +// Interface provided by a transport analyzer to supply guide data information. + + {$HPPEMIT 'typedef System::DelphiInterface _di_IGuideData;'} + {$EXTERNALSYM IGuideData} + IGuideData = interface(IUnknown) + ['{61571138-5B01-43cd-AEAF-60B784A0BF93}'] + (*** IGuideData methods ***) + //------------------------------------------------------------------------- + // + // GetServices + // Returns an enumeration of tune requests for all services whose + // information is found in the current transport stream. + // + // Parameters + // + // IEnumTuneRequests ** + // Location in which a reference to the resulting + // IEnumTuneRequests is placed. The caller must release + // this reference when finished with it. + // + // Comments + // This call is used to enumerate all services whose information + // can be found in the service descriptor table. Each tune request + // in the IEnumTuneRequest * contains the tune request including the + // locator data for the service. + // + // Returns an enumeration of services whose information is found in the given transport stream + function GetServices(out ppEnumTuneRequests: IEnumTuneRequests): HResult; stdcall; + + //------------------------------------------------------------------------- + // + // GetServiceProperties + // Returns an enumeration of all guide data properties for + // the service with the given Description.ID. + // + // Parameters + // ITuneRequest * + // Pointer to a tune request that contains information needed + // to indentify the requested transport stream. + // A NULL ITuneRequest * indicates that information about the + // current transport stream is requested. + // + // IEnumGuideDataProperties ** + // Location in which a reference to the resulting + // IEnumGuideDataProperties is placed. The caller must release + // this reference when finished with it. + // + // Required Properties + // The following properties MUST be included in the returned + // property enumeration. + // + // Description.ID + // Uniquely identifies a service. + // + // Description.Name + // The default name to use for this service in the channel lineup. + // + // Description.Version + // Identifies the current version of the properties associated + // with this service. + // + // Provider.Name + // Name of the service provider (e.g. "KCTS") + // + // Provider.NetworkName + // Name of the network on which the service is provided. + // (e.g. "PBS") + // + // Service.TuneRequest + // Contains a tune request in the variant + // + // + // Returns an enumeration of all guide data properties for the service specified by a tune request. + function GetServiceProperties(pTuneRequest: ITuneRequest; out ppEnumProperties: IEnumGuideDataProperties): HResult; stdcall; + + //------------------------------------------------------------------------- + // + // GetProgramIDs + // Returns an enumeration of the unique identifiers (Description.ID) + // of programs with description contained in all transport + // streams + // + // Parameters + // + // IEnumVARIANT ** + // Location in which a reference to the resulting + // IEnumVARIANT is placed. The caller must release + // this reference when finished with it. + // + // Comments + // This call is used to get a list of programs that have + // guide data properties in all transport streams. + // Each variant returned in the IEnumVARIANT * contains the + // unique Description.ID property for a program. + // Note that more than on transport stream may contain properties + // for the same program. In this case the properties should be + // merged. + // + // Returns an enumeration of the Description.ID property for all programs on + // the given transport stream. + + function GetGuideProgramIDs(out pEnumPrograms: IEnumVARIANT): HResult; stdcall; + + //------------------------------------------------------------------------- + // + // GetProgramProperties + // Returns an enumeration of all guide data properties for + // the program with the given Description.ID. + // + // Parameters + // varProgramDescriptionID + // Variant containing the unique identifier for the program + // for which properties are requested. + // + // IEnumGuideDataProperties ** + // Location in which a reference to the resulting + // IEnumGuideDataProperties is placed. The caller must release + // this reference when finished with it. + // + // Required Properties + // The following properties MUST be included in the returned + // property enumeration. + // + // Description.ID + // Uniquely identifies a program. + // + // Description.Version + // Identifies the current version of the properties associated + // with this program. + // + // Description.Title + // Human readable title of the program (e.g. "") + // + // Description.Long + // A description of the program. + // + // Returns an enumeration of all guide data properties for the program with + // the given Description.ID. + + function GetProgramProperties(varProgramDescriptionID: OLEVARIANT; + out ppEnumProperties: IEnumGuideDataProperties): HResult; stdcall; + + //------------------------------------------------------------------------- + // + // GetScheduleIDs + // Returns an enumeration of the unique identifiers (Description.ID) + // transport of schedule entries with description contained in the + // given transport stream. + // + // Parameters + // + // IEnumVARIANT ** + // Location in which a reference to the resulting + // IEnumVARIANT is placed. The caller must release + // this reference when finished with it. + // + // Comments + // This call is used to get a list of schedule entries that have + // guide data properties in all transport streams. + // Each variant returned in the IEnumVARIANT * contains the + // unique Description.ID property for a schedule entry. + // Note that more than on transport stream may contain properties + // for the same schedule entry. In this case the properties + // should be merged. + // + // Returns an enumeration of the Description.ID property for all schedule + // entries in the transport stream specified by a tune request. + function GetScheduleEntryIDs(out pEnumScheduleEntries: IEnumVARIANT): HResult; stdcall; + + //------------------------------------------------------------------------- + // + // GetScheduleEntryProperties + // Returns an enumeration of all guide data properties for + // the schedule entry with the given Description.ID. + // + // Parameters + // varScheduleEntryDescriptionID + // Variant containing the unique identifier for the schedule + // entry for which properties are requested. + // + // IEnumGuideDataProperties ** + // Location in which a reference to the resulting + // IEnumGuideDataProperties is placed. The caller must release + // this reference when finished with it. + // + // Required Properties + // The following properties MUST be included in the returned + // property enumeration. + // + // Description.ID + // Uniquely identifies a schedule entry. + // + // Description.Version + // Identifies the current version of the properties associated + // with this program. + // + // Time.Start + // The starting time and date of this schedule entry. + // + // Time.End + // The ending time and date of this schedule entry. + // + // Schedule.Program + // The Description.ID of the program that will play at the + // time specified by this schedule entry. + // + // Schedule.Service + // The Description.ID of the Service that carries the + // program that will play at the time specified by this + // schedule entry. + // + // Returns an enumeration of all guide data properties for the schedule + // entry with the given Description.ID.")] + function GetScheduleEntryProperties(varScheduleEntryDescriptionID: OLEVARIANT; + out ppEnumProperties: IEnumGuideDataProperties): HResult; stdcall; + end; + +//****************************************************************************** +// +// IGuideDataLoader +// +// All Guide Data Loaders MUST implement this interface. It is how they are +// provided with the IGuideData interface that they will use. +// +// + + {$HPPEMIT 'typedef System::DelphiInterface _di_IGuideDataLoader;'} + {$EXTERNALSYM IGuideDataLoader} + IGuideDataLoader = interface(IUnknown) + ['{4764ff7c-fa95-4525-af4d-d32236db9e38}'] + (*** IGuideDataLoader methods ***) + function Init(pGuideStore: IGuideData): HResult; stdcall; + function Terminate: HResult; stdcall; + end; + +//****************************************************************************** +// Copyright (c) 1998 Microsoft Corporation. All Rights Reserved. +// FileName: Mixerocx.idl + +const + + IID_IMixerOCXNotify : TGUID = '{81A3BD31-DEE1-11d1-8508-00A0C91F9CA0}'; + {$EXTERNALSYM IID_IMixerOCXNotify} + IID_IMixerOCX : TGUID = '{81A3BD32-DEE1-11d1-8508-00A0C91F9CA0}'; + {$EXTERNALSYM IID_IMixerOCX} + + // data id flags, used to notify the client whenever pertinent data changes + MIXER_DATA_ASPECT_RATIO = $00000001; // picture aspect ratio changed + {$EXTERNALSYM MIXER_DATA_ASPECT_RATIO} + MIXER_DATA_NATIVE_SIZE = $00000002; // native size of video changed + {$EXTERNALSYM MIXER_DATA_NATIVE_SIZE} + MIXER_DATA_PALETTE = $00000004; // palette of video changed + {$EXTERNALSYM MIXER_DATA_PALETTE} + + // status flags defined here + MIXER_STATE_MASK = $00000003; // use this mask with state status bits + {$EXTERNALSYM MIXER_STATE_MASK} + MIXER_STATE_UNCONNECTED = $00000000; // mixer is unconnected and stopped + {$EXTERNALSYM MIXER_STATE_UNCONNECTED} + MIXER_STATE_CONNECTED_STOPPED = $00000001; // mixer is connected and stopped + {$EXTERNALSYM MIXER_STATE_CONNECTED_STOPPED} + MIXER_STATE_CONNECTED_PAUSED = $00000002; // mixer is connected and paused + {$EXTERNALSYM MIXER_STATE_CONNECTED_PAUSED} + MIXER_STATE_CONNECTED_PLAYING = $00000003; // mixer is connected and playing + {$EXTERNALSYM MIXER_STATE_CONNECTED_PLAYING} + +type + {$HPPEMIT 'typedef System::DelphiInterface _di_IMixerOCXNotify;'} + {$EXTERNALSYM IMixerOCXNotify} + IMixerOCXNotify = interface(IUnknown) + ['{81A3BD31-DEE1-11d1-8508-00A0C91F9CA0}'] + (*** IMixerOCXNotify methods ***) + // invalidates the rect + function OnInvalidateRect(lpcRect: PRECT): HResult; stdcall; + // informs that a status change has occured, new status bits provided in ulStatusFlags + function OnStatusChange(ulStatusFlags: ULONG): HResult; stdcall; + // informs that data parameters, whose id is present in ilDataFlags has changed + function OnDataChange(ulDataFlags: ULONG): HResult; stdcall; + end; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IMixerOCX;'} + {$EXTERNALSYM IMixerOCX} + IMixerOCX = interface(IUnknown) + ['{81A3BD32-DEE1-11d1-8508-00A0C91F9CA0}'] + (*** IMixerOCX methods ***) + // used to notify the mixer that the display mode has changed, the mixer handles this + // asynchronously and the calls OnStatusChange(MIXER_DISPLAYCHANGE_HANDLED) when processing + // is done + function OnDisplayChange(ulBitsPerPixel, ulScreenWidth, ulScreenHeight: ULONG): HResult; stdcall; + function GetAspectRatio(out pdwPictAspectRatioX, pdwPictAspectRatioY: DWORD): HResult; stdcall; + function GetVideoSize(out pdwVideoWidth, pdwVideoHeight: DWORD): HResult; stdcall; + function GetStatus(out pdwStatus: DWORD): HResult; stdcall; + // the dc provided here is not supposed to be cached. If apps have set a dc using + // SetDrawInfo, then it is illegal to provide a non NULL argument here + function OnDraw(hdcDraw: HDC; prcDraw: PRECT): HResult; stdcall; + // lpptTopLeftSC should be NULL unless MIXER_DRAW_DC_ONSCREEN is set to TRUE + // specifying a NULL value for lprcClip means no clipping + // lpptTopLeftSC - top left corner of surface/dc in screen coordinates + // prcDrawCC - draw rectangle in surface/dc coordinates + // lprcClip - clipping rect in surface/dc coordinates (optional) + function SetDrawRegion(lpptTopLeftSC: PPOINT; prcDrawCC, lprcClip: PRECT): HResult; stdcall; + // function to set the sink interface for client notification + function Advise(pmdns: IMixerOCXNotify): HResult; stdcall; + // function to remove the sink interface + function UnAdvise: HResult; stdcall; + end; + +///////////////////////////////////////////////////////////////////////////// +// +// Copyright (c) Microsoft Corporation. All rights reserved. +// +// Module Name: +// +// Mpeg2Bits.h +// +// Abstract: +// +// This file defines the MPEG-2 section header bitfields. These are +// defined here instead of in mpegstructs.idl because of MIDL +// compiler conflicts with bitfield definitions. +// +///////////////////////////////////////////////////////////////////////////// + + // PID structure + + // WORD Reserved : 3; + // WORD ProgramId : 13; + PPIDBits = ^TPIDBits; + PID_BITS = packed record + Bits: WORD; + end; + {$EXTERNALSYM PID_BITS} + PPID_BITS = ^PID_BITS; + {$EXTERNALSYM PPID_BITS} + TPIDBits = PID_BITS; + + // Generic MPEG packet header structure + + // WORD SectionLength : 12; + // WORD Reserved : 2; + // WORD PrivateIndicator : 1; + // WORD SectionSyntaxIndicator : 1; + PMPEGHeaderBits = ^TMPEGHeaderBits; + MPEG_HEADER_BITS = packed record + Bits: WORD; + end; + {$EXTERNALSYM MPEG_HEADER_BITS} + PMPEG_HEADER_BITS = ^MPEG_HEADER_BITS; + {$EXTERNALSYM PMPEG_HEADER_BITS} + TMPEGHeaderBits = MPEG_HEADER_BITS; + + // Long MPEG packet header structure + + // BYTE CurrentNextIndicator : 1; + // BYTE VersionNumber : 5; + // BYTE Reserved : 2; + PMPEGHeaderVersionBits = ^TMPEGHeaderVersionBits; + MPEG_HEADER_VERSION_BITS = packed record + Bits: BYTE; + end; + {$EXTERNALSYM MPEG_HEADER_VERSION_BITS} + PMPEG_HEADER_VERSION_BITS = ^MPEG_HEADER_VERSION_BITS; + {$EXTERNALSYM PMPEG_HEADER_VERSION_BITS} + TMPEGHeaderVersionBits = MPEG_HEADER_VERSION_BITS; + +///////////////////////////////////////////////////////////////////////////// +// +// Copyright (c) Microsoft Corporation. All rights reserved. +// +// Module Name: +// +// Mpeg2Structs.idl +// +// Abstract: +// +// Definitions for the common structures used in Mpeg2Data +// +// Notes: +// +// This IDL file is not built independently, but is included and built +// in the master IDL file Mpeg2Data.idl +// +///////////////////////////////////////////////////////////////////////////// + + +type + // Basic Type Aliases + PPID = ^PID; + {$EXTERNALSYM PPID} + PID = WORD; + {$EXTERNALSYM PID} + PTID = ^TID; + {$EXTERNALSYM PTID} + TID = BYTE; + {$EXTERNALSYM TID} + ClientKey = UINT; + {$EXTERNALSYM ClientKey} + + // MPEG-2 Current/Next bit field + MPEG_CURRENT_NEXT_BIT = ( + {$EXTERNALSYM MPEG_CURRENT_NEXT_BIT} + MPEG_SECTION_IS_NEXT, + MPEG_SECTION_IS_CURRENT + ); + TMPEGCurrentNextBit = MPEG_CURRENT_NEXT_BIT; + + // MPEG-2 TID Extension structure + PTidExtension = ^TTidExtension; + TID_EXTENSION = packed record + wTidExt: WORD; + wCount : WORD; + end; + {$EXTERNALSYM TID_EXTENSION} + PTID_EXTENSION = ^TID_EXTENSION; + {$EXTERNALSYM PTID_EXTENSION} + TTidExtension = TID_EXTENSION; + + // MPEG-2 packet "small" header structure + SECTION = packed record + TableId : TID; + Header : TMPEGHeaderBits; + SectionData : array[0..0] of BYTE; // Array size is Header.S.SectionLength + end; + {$EXTERNALSYM SECTION} + PSECTION = ^SECTION; + {$EXTERNALSYM PSECTION} + TSection = SECTION; + + // MPEG-2 packet "long" header structure + PLongSection = ^TLongSection; + LONG_SECTION = packed record + TableId : TID; + Header : TMPEGHeaderBits; + TableIdExtension : WORD; + Version : TMPEGHeaderVersionBits; + SectionNumber : BYTE; + LastSectionNumber : BYTE; + RemainingData : array[0..0] of BYTE; // Array size is Header.S.SectionLength - 5 + end; + {$EXTERNALSYM LONG_SECTION} + PLONG_SECTION = ^LONG_SECTION; + {$EXTERNALSYM PLONG_SECTION} + TLongSection = LONG_SECTION; + + // DSM-CC packet header structure + PDSMCCSection = ^TDSMCCSection; + DSMCC_SECTION = packed record + TableId : TID; + Header : TMPEGHeaderBits; + TableIdExtension : WORD; + Version : TMPEGHeaderVersionBits; + SectionNumber : BYTE; + LastSectionNumber : BYTE; + ProtocolDiscriminator : BYTE; + DsmccType : BYTE; + MessageId : WORD; + TransactionId : DWORD; + Reserved : BYTE; + AdaptationLength : BYTE; + MessageLength : WORD; + RemainingData: array[0..0] of BYTE; + end; + {$EXTERNALSYM DSMCC_SECTION} + PDSMCC_SECTION = ^DSMCC_SECTION; + {$EXTERNALSYM PDSMCC_SECTION} + TDSMCCSection = DSMCC_SECTION; + + // MPEG-2 request/response packets structures + PMPEGRQSTPacket = ^TMPEGRQSTPacket; + MPEG_RQST_PACKET = packed record + dwLength: DWORD; + pSection: PSECTION; + end; + {$EXTERNALSYM MPEG_RQST_PACKET} + PMPEG_RQST_PACKET = ^MPEG_RQST_PACKET; + {$EXTERNALSYM PMPEG_RQST_PACKET} + TMPEGRQSTPacket = MPEG_RQST_PACKET; + + PMPEGPacketList = ^TMPEGPacketList; + MPEG_PACKET_LIST = packed record + wPacketCount : WORD ; + PacketList : array[0..0] of PMPEG_RQST_PACKET; // Array size is wPacketCount; + end; + {$EXTERNALSYM MPEG_PACKET_LIST} + PMPEG_PACKET_LIST = ^MPEG_PACKET_LIST; + {$EXTERNALSYM PMPEG_PACKET_LIST} + TMPEGPacketList = MPEG_PACKET_LIST; + + // DSM-CC request filter options + + PDSMCCFilterOptions = ^TDSMCCFilterOptions; + DSMCC_FILTER_OPTIONS = packed record + fSpecifyProtocol : BOOL; // If true, Protocol should be set to desired value + Protocol : BYTE; + fSpecifyType : BOOL; // If true, Type should be set to desired value + Type_ : BYTE; + fSpecifyMessageId : BOOL; // If true, MessageId should be set to desired value + MessageId : WORD; + fSpecifyTransactionId : BOOL; // If true, TransactionId (or DownloadId for DDB msgs) should be set to desired value + fUseTrxIdMessageIdMask : BOOL; // If false, TransactionId is filtered as is. + // If true, TransactionId is masked to look + // for any version of message with associated + // message identifier. See DVB - Data + // Broadcasting Guidlines 4.6.5. (Assignment + // and use of transactionId values). + TransactionId : DWORD; + fSpecifyModuleVersion : BOOL; // If true, ModuleVersion should be set to the desired value + ModuleVersion : BYTE; + fSpecifyBlockNumber : BOOL; // If true, BlockNumber should be set to desired value + BlockNumber : WORD; + fGetModuleCall : BOOL; // If true, NumberOfBlocksInModule should be set + NumberOfBlocksInModule : WORD; + end; + // 45 BYTES + {$EXTERNALSYM DSMCC_FILTER_OPTIONS} + PDSMCC_FILTER_OPTIONS = ^DSMCC_FILTER_OPTIONS; + {$EXTERNALSYM PDSMCC_FILTER_OPTIONS} + TDSMCCFilterOptions = DSMCC_FILTER_OPTIONS; + + + // ATSC request filter options + PATSCFilterOptions = ^TATSCFilterOptions; + ATSC_FILTER_OPTIONS = packed record + fSpecifyEtmId : BOOL; // If true, EtmId should be set to desired value + EtmId : DWORD; + end; + // 8 BYTES + {$EXTERNALSYM ATSC_FILTER_OPTIONS} + TATSCFilterOptions = ATSC_FILTER_OPTIONS; + + // MPEG-2 request filter structure + PMPEG2Filter = ^TMPEG2Filter; + MPEG2_FILTER = packed record + bVersionNumber : BYTE; // Must be set to 1 or more to match filter definition + wFilterSize : WORD; // Size of total filter structure. Version 1 filter is 73 bytes. + fUseRawFilteringBits : BOOL; // If true, Filter and Mask fields should be set to desired value, all other + // fields with be ignored. + Filter : array[0..15] of BYTE; // Bits with values to compare against for a match. + Mask : array[0..15] of BYTE; // Bits set to 0 are bits that are compared to those in the filter, those + // bits set to 1 are ignored. + fSpecifyTableIdExtension : BOOL; // If true, TableIdExtension should be set to desired value (false = don't care) + TableIdExtension : WORD; + fSpecifyVersion : BOOL; // If true, Version should be set to desired value (false = don't care) + Version : BYTE; + fSpecifySectionNumber : BOOL; // If true, SectionNumber should be set to desired value (false = don't care) + SectionNumber : BYTE; + fSpecifyCurrentNext : BOOL; // If true, fNext should be set to desired value (false = don't care) + fNext : BOOL; // If true, next table is queried. Else, current + fSpecifyDsmccOptions : BOOL; // If true, Dsmcc should be set with desired filter options + Dsmcc : TDSMCCFilterOptions; + fSpecifyAtscOptions : BOOL; // If true, Atsc should be set with desired filter options + Atsc : TATSCFilterOptions; + end; + // 124 BYTES + {$EXTERNALSYM MPEG2_FILTER} + PMPEG2_FILTER = ^MPEG2_FILTER; + {$EXTERNALSYM PMPEG2_FILTER} + TMPEG2Filter = MPEG2_FILTER; + +const + MPEG2_FILTER_VERSION_1_SIZE = 124; + {$EXTERNALSYM MPEG2_FILTER_VERSION_1_SIZE} + +type + // Mpeg-2 Stream buffer structure + PMPEGStreamBuffer = ^TMPEGStreamBuffer; + MPEG_STREAM_BUFFER = packed record + hr : HResult; + dwDataBufferSize : DWORD; + dwSizeOfDataRead : DWORD; + pDataBuffer : PBYTE; + end; + {$EXTERNALSYM MPEG_STREAM_BUFFER} + PMPEG_STREAM_BUFFER = ^MPEG_STREAM_BUFFER; + {$EXTERNALSYM PMPEG_STREAM_BUFFER} + TMPEGStreamBuffer = MPEG_STREAM_BUFFER; + + // MPEG-2 Time and Date structures + PMPEGTime = ^TMPEGTime; + MPEG_TIME = packed record + Hours : BYTE; // Legal Range: 0 to 23 + Minutes : BYTE; // Legal Range: 0 to 59 + Seconds : BYTE; // Legal Range: 0 to 59 + end; + {$EXTERNALSYM MPEG_TIME} + TMPEGTime = MPEG_TIME; + + MPEG_DURATION = MPEG_TIME; + {$EXTERNALSYM MPEG_DURATION} + + PMPEGDate = ^TMPEGDate; + MPEG_DATE = packed record + Date : BYTE; // Legal Range: 1 to 31 + Month : BYTE; // Legal Range: 1 to 12 + Year : WORD; // Legal Range: 1900 to 2100 + end; + {$EXTERNALSYM MPEG_DATE} + TMPEGDate = MPEG_DATE; + + PMPEGDateAndTime = ^TMPEGDateAndTime; + MPEG_DATE_AND_TIME = packed record + D: TMPEGDate; + T: TMPEGTime; + end; + {$EXTERNALSYM MPEG_DATE_AND_TIME} + TMPEGDateAndTime = MPEG_DATE_AND_TIME; + + // MPEG-2 API Context structures + MPEG_CONTEXT_TYPE = ( + MPEG_CONTEXT_BCS_DEMUX, + MPEG_CONTEXT_WINSOCK + ); + {$EXTERNALSYM MPEG_CONTEXT_TYPE} + TMPEGContextType = MPEG_CONTEXT_TYPE; + + MPEG_BCS_DEMUX = packed record + AVMGraphId: DWORD; + end; + {$EXTERNALSYM MPEG_BCS_DEMUX} + TMPEGBCSDemux = MPEG_BCS_DEMUX; + + MPEG_WINSOCK = record + AVMGraphId: DWORD; + end; + {$EXTERNALSYM MPEG_WINSOCK} + TMPEGWinsock = MPEG_WINSOCK; + + PMPEGContext = ^TMPEGContext; + MPEG_CONTEXT = packed record + Type_ : TMPEGContextType; + case byte of + 0: (Demux: TMPEGBCSDemux); + 1: (Winsock: TMPEGWinsock); + end; + {$EXTERNALSYM MPEG_CONTEXT} + PMPEG_CONTEXT = ^MPEG_CONTEXT; + {$EXTERNALSYM PMPEG_CONTEXT} + TMPEGContext = MPEG_CONTEXT; + + // MPEG-2 Service Request and Responses + MPEG_REQUEST_TYPE = ( + MPEG_RQST_UNKNOWN, + MPEG_RQST_GET_SECTION, + MPEG_RQST_GET_SECTION_ASYNC, + MPEG_RQST_GET_TABLE, + MPEG_RQST_GET_TABLE_ASYNC, + MPEG_RQST_GET_SECTIONS_STREAM, + MPEG_RQST_GET_PES_STREAM, + MPEG_RQST_GET_TS_STREAM, + MPEG_RQST_START_MPE_STREAM + ); + {$EXTERNALSYM MPEG_REQUEST_TYPE} + TMPEGRequestType = MPEG_REQUEST_TYPE; + + PMPEGServiceRequest = ^TMPEGServiceRequest; + MPEG_SERVICE_REQUEST = packed record + Type_ : TMPEGRequestType; + Context : TMPEGContext; + Pid : PID; + TableId : TID; + Filter : TMPEG2Filter; + Flags : DWORD; + end; + {$EXTERNALSYM MPEG_SERVICE_REQUEST} + PMPEG_SERVICE_REQUEST = ^MPEG_SERVICE_REQUEST; + {$EXTERNALSYM PMPEG_SERVICE_REQUEST} + TMPEGServiceRequest = MPEG_SERVICE_REQUEST; + + PMPEGServiceResponse = ^TMPEGServiceResponse; + MPEG_SERVICE_RESPONSE = packed record + IPAddress : DWORD; + Port : WORD; + end; + {$EXTERNALSYM MPEG_SERVICE_RESPONSE} + PMPEG_SERVICE_RESPONSE = ^MPEG_SERVICE_RESPONSE; + {$EXTERNALSYM PMPEG_SERVICE_RESPONSE} + TMPEGServiceResponse = MPEG_SERVICE_RESPONSE; + + // DSM-CC & MPE Query Results + PDSMCCElement = ^TDSMCCElement; + DSMCC_ELEMENT = packed record + pid : PID; + bComponentTag : BYTE; + dwCarouselId : DWORD; + dwTransactionId : DWORD; + pNext : PDSMCCElement; + end; + {$EXTERNALSYM DSMCC_ELEMENT} + PDSMCC_ELEMENT = ^DSMCC_ELEMENT; + {$EXTERNALSYM PDSMCC_ELEMENT} + TDSMCCElement = DSMCC_ELEMENT; + + PMPEElement = ^TMPEElement; + MPE_ELEMENT = packed record + pid : PID; + bComponentTag : BYTE; + pNext : PMPEElement; + end; + {$EXTERNALSYM MPE_ELEMENT} + PMPE_ELEMENT = ^MPE_ELEMENT; + {$EXTERNALSYM PMPE_ELEMENT} + TMPEElement = MPE_ELEMENT; + + // MPEG-2 Stream Filtering Structure + PMPEGStreamFilter = ^TMPEGStreamFilter; + MPEG_STREAM_FILTER = packed record + wPidValue : WORD; // PID value + dwFilterSize : DWORD; // size of filter in bits + fCrcEnabled : BOOL; // enable/disable CRC check + rgchFilter : array[0..15] of BYTE; // filter data + rgchMask : array[0..15] of BYTE; // filter mask + end; + {$EXTERNALSYM MPEG_STREAM_FILTER} + TMPEGStreamFilter = MPEG_STREAM_FILTER; + +///////////////////////////////////////////////////////////////////////////// +// +// Copyright (c) Microsoft Corporation. All rights reserved. +// +// Module Name: +// +// Mpeg2Data.idl +// +// Abstract: +// +// Main Mpeg2Data Library Definition, and interface definitions for +// the MPEG-2 Section and Table acquisition functionality +// +///////////////////////////////////////////////////////////////////////////// + + +const + // Declare well known PID/TID values for MPEG-2 tables + MPEG_PAT_PID = $0000; + {$EXTERNALSYM MPEG_PAT_PID} + MPEG_PAT_TID = $00; + {$EXTERNALSYM MPEG_PAT_TID} + + MPEG_CAT_PID = $0001; + {$EXTERNALSYM MPEG_CAT_PID} + MPEG_CAT_TID = $01; + {$EXTERNALSYM MPEG_CAT_TID} + + MPEG_PMT_TID = $02; + {$EXTERNALSYM MPEG_PMT_TID} + + MPEG_TSDT_PID = $0002; + {$EXTERNALSYM MPEG_TSDT_PID} + MPEG_TSDT_TID = $03; + {$EXTERNALSYM MPEG_TSDT_TID} + + // Declare well known PID/TID values for ATSC tables + ATSC_MGT_PID = $1FFB; + {$EXTERNALSYM ATSC_MGT_PID} + ATSC_MGT_TID = $C7; + {$EXTERNALSYM ATSC_MGT_TID} + + ATSC_VCT_PID = $1FFB; + {$EXTERNALSYM ATSC_VCT_PID} + ATSC_VCT_TERR_TID = $C8; + {$EXTERNALSYM ATSC_VCT_TERR_TID} + ATSC_VCT_CABL_TID = $C9; + {$EXTERNALSYM ATSC_VCT_CABL_TID} + + ATSC_RRT_PID = $1FFB; + {$EXTERNALSYM ATSC_RRT_PID} + ATSC_RRT_TID = $CA; + {$EXTERNALSYM ATSC_RRT_TID} + + ATSC_EIT_TID = $CB; + {$EXTERNALSYM ATSC_EIT_TID} + + ATSC_ETT_TID = $CC; + {$EXTERNALSYM ATSC_ETT_TID} + + ATSC_STT_PID = $1FFB; + {$EXTERNALSYM ATSC_STT_PID} + ATSC_STT_TID = $CD; + {$EXTERNALSYM ATSC_STT_TID} + + ATSC_PIT_TID = $D0; + {$EXTERNALSYM ATSC_PIT_TID} + + // Declare well known PID/TID values for DVB tables + DVB_NIT_PID = $0010; + {$EXTERNALSYM DVB_NIT_PID} + DVB_NIT_ACTUAL_TID = $40; + {$EXTERNALSYM DVB_NIT_ACTUAL_TID} + DVB_NIT_OTHER_TID = $41; + {$EXTERNALSYM DVB_NIT_OTHER_TID} + + DVB_SDT_PID = $0011; + {$EXTERNALSYM DVB_SDT_PID} + DVB_SDT_ACTUAL_TID = $42; + {$EXTERNALSYM DVB_SDT_ACTUAL_TID} + DVB_SDT_OTHER_TID = $46; + {$EXTERNALSYM DVB_SDT_OTHER_TID} + + DVB_BAT_PID = $0011; + {$EXTERNALSYM DVB_BAT_PID} + DVB_BAT_TID = $4A; + {$EXTERNALSYM DVB_BAT_TID} + + DVB_EIT_PID = $0012; + {$EXTERNALSYM DVB_EIT_PID} + DVB_EIT_ACTUAL_TID = $4E; + {$EXTERNALSYM DVB_EIT_ACTUAL_TID} + DVB_EIT_OTHER_TID = $4F; + {$EXTERNALSYM DVB_EIT_OTHER_TID} + + DVB_RST_PID = $0013; + {$EXTERNALSYM DVB_RST_PID} + DVB_RST_TID = $71; + {$EXTERNALSYM DVB_RST_TID} + + DVB_TDT_PID = $0014; + {$EXTERNALSYM DVB_TDT_PID} + DVB_TDT_TID = $70; + {$EXTERNALSYM DVB_TDT_TID} + + DVB_ST_PID_16 = $0010; + {$EXTERNALSYM DVB_ST_PID_16} + DVB_ST_PID_17 = $0011; + {$EXTERNALSYM DVB_ST_PID_17} + DVB_ST_PID_18 = $0012; + {$EXTERNALSYM DVB_ST_PID_18} + DVB_ST_PID_19 = $0013; + {$EXTERNALSYM DVB_ST_PID_19} + DVB_ST_PID_20 = $0014; + {$EXTERNALSYM DVB_ST_PID_20} + DVB_ST_TID = $72; + {$EXTERNALSYM DVB_ST_TID} + + DVB_TOT_PID = $0014; + {$EXTERNALSYM DVB_TOT_PID} + DVB_TOT_TID = $73; + {$EXTERNALSYM DVB_TOT_TID} + + DVB_DIT_PID = $001E; + {$EXTERNALSYM DVB_DIT_PID} + DVB_DIT_TID = $7E; + {$EXTERNALSYM DVB_DIT_TID} + + DVB_SIT_PID = $001F; + {$EXTERNALSYM DVB_SIT_PID} + DVB_SIT_TID = $7F; + {$EXTERNALSYM DVB_SIT_TID} + + // Declare well known PID/TID values for ISDB tables + ISDB_DCT_PID = $0017; + {$EXTERNALSYM ISDB_DCT_PID} + ISDB_DCT_TID = $C0; + {$EXTERNALSYM ISDB_DCT_TID} + + ISDB_LIT_PID = $0020; + {$EXTERNALSYM ISDB_LIT_PID} + ISDB_LIT_TID = $D0; + {$EXTERNALSYM ISDB_LIT_TID} + + ISDB_ERT_PID = $0021; + {$EXTERNALSYM ISDB_ERT_PID} + ISDB_ERT_TID = $D1; + {$EXTERNALSYM ISDB_ERT_TID} + + ISDB_ITT_TID = $D2; + {$EXTERNALSYM ISDB_ITT_TID} + + ISDB_DLT_TID = $C1; + {$EXTERNALSYM ISDB_DLT_TID} + + ISDB_PCAT_PID = $0022; + {$EXTERNALSYM ISDB_PCAT_PID} + ISDB_PCAT_TID = $C2; + {$EXTERNALSYM ISDB_PCAT_TID} + + ISDB_SDTT_PID = $0023; + {$EXTERNALSYM ISDB_SDTT_PID} + ISDB_SDTT_TID = $C3; + {$EXTERNALSYM ISDB_SDTT_TID} + + +//////////////////////////////////// +// +// Mpeg2DataLib Library +// +//////////////////////////////////// + +const + LIBID_Mpeg2DataLib : TGUID = '{DBAF6C1B-B6A4-4898-AE65-204F0D9509A1}'; + {$EXTERNALSYM LIBID_Mpeg2DataLib} + + IID_IMpeg2Data : TGUID = '{9B396D40-F380-4e3c-A514-1A82BF6EBFE6}'; + {$EXTERNALSYM IID_IMpeg2Data} + IID_ISectionList : TGUID = '{AFEC1EB5-2A64-46c6-BF4B-AE3CCB6AFDB0}'; + {$EXTERNALSYM IID_ISectionList} + IID_IMpeg2FilterControl : TGUID = '{7066CCDA-5C09-4e4f-85BC-2A2D6E0E310D}'; + {$EXTERNALSYM IID_IMpeg2FilterControl} + IID_IMpeg2Stream : TGUID = '{400CC286-32A0-4ce4-9041-39571125A635}'; + {$EXTERNALSYM IID_IMpeg2Stream} + + CLSID_SectionList : TGUID = '{73DA5D04-4347-45d3-A9DC-FAE9DDBE558D}'; // ISectionList + {$EXTERNALSYM CLSID_SectionList} + CLSID_Mpeg2Stream : TGUID = '{F91D96C7-8509-4d0b-AB26-A0DD10904BB7}'; // IMpeg2Stream + {$EXTERNALSYM CLSID_Mpeg2Stream} + CLSID_Mpeg2Data : TGUID = '{C666E115-BB62-4027-A113-82D643FE2D99}'; // IMpeg2FilterControl (IAtscPsipParser IDvbSiParser Not available in DX9) + {$NODEFINE CLSID_Mpeg2Data} + +type + //////////////////////////////////// + // + // IMpeg2Data Interface + // + //////////////////////////////////// + ISectionList = interface; + IMpeg2Stream = interface; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IMpeg2Data;'} + {$EXTERNALSYM IMpeg2Data} + IMpeg2Data = interface(IUnknown) + ['{9B396D40-F380-4e3c-A514-1A82BF6EBFE6}'] + (*** IMpeg2Data methods ***) + function GetSection(pid: PID; tid: TID; pFilter: PMPEG2_FILTER {OPTIONAL}; + dwTimeout: DWORD; out ppSectionList: ISectionList): HResult; stdcall; + function GetTable(pid: PID; tid: TID; pFilter: PMPEG2_FILTER {OPTIONAL}; + dwTimeout: DWORD; out ppSectionList: ISectionList): HResult; stdcall; + function GetStreamOfSections(pid: PID; tid: TID; pFilter: PMPEG2_FILTER {OPTIONAL}; + hDataReadyEvent: THandle; out ppMpegStream: IMpeg2Stream): HResult; stdcall; + end; + + //////////////////////////////////// + // + // ISectionList Interface + // + //////////////////////////////////// + + {$HPPEMIT 'typedef System::DelphiInterface _di_ISectionList;'} + {$EXTERNALSYM ISectionList} + ISectionList = interface(IUnknown) + ['{AFEC1EB5-2A64-46c6-BF4B-AE3CCB6AFDB0}'] + (*** ISectionList methods ***) + function Initialize(requestType: TMPEGRequestType; pMpeg2Data: IMpeg2Data; + pContext: PMPEG_CONTEXT; pid: PID; tid: TID; pFilter: PMPEG2_FILTER {OPTIONAL}; + timeout: DWORD; hDoneEvent: THandle {OPTIONAL}): HResult; stdcall; + function InitializeWithRawSections(pmplSections: PMPEG_PACKET_LIST): HResult; stdcall; + function CancelPendingRequest: HResult; stdcall; + function GetNumberOfSections(out pCount: WORD): HResult; stdcall; + function GetSectionData(sectionNumber: WORD; out pdwRawPacketLength: DWORD; + out ppSection: PSECTION): HResult; stdcall; + function GetProgramIdentifier(pPid: PPID): HResult; stdcall; + function GetTableIdentifier(pTableId: PTID): HResult; stdcall; + end; + + //////////////////////////////////// + // + // IMpeg2FilterControl Interface + // + //////////////////////////////////// + + // Defined in DX9 RC0 but removed in RC1 ??? + {$NODEFINE IMpeg2FilterControl} + IMpeg2FilterControl = interface(IUnknown) + ['{7066CCDA-5C09-4e4f-85BC-2A2D6E0E310D}'] + (*** IMpeg2FilterControl methods ***) + function SetFilter(culFilterItems: ULONG; prgFilterCriteria: PMPEGStreamFilter; + MediaSampleContent: TMediaSampleContent; hEvent: THandle; + out pClientKey: ClientKey): HResult; stdcall; + function ClearFilter(clientKey: ClientKey): HResult; stdcall; + + function GetData(pbDataBuffer: PBYTE; dwBufferSize: DWORD; + out pdwBytesWritten: DWORD; clientKey: ClientKey): HResult; + end; + + //////////////////////////////////// + // + // IMpeg2Stream Interface + // + //////////////////////////////////// + + {$HPPEMIT 'typedef System::DelphiInterface _di_IMpeg2Stream;'} + {$EXTERNALSYM IMpeg2Stream} + IMpeg2Stream = interface(IUnknown) + ['{400CC286-32A0-4ce4-9041-39571125A635}'] + (*** IMpeg2Stream methods ***) + function Initialize(requestType: TMPEGRequestType; pMpeg2Data: IMpeg2Data; + pContext: PMPEG_CONTEXT; pid: PID; tid: TID; pFilter: PMPEG2_FILTER {OPTIONAL}; + hDataReadyEvent: THandle): HResult; stdcall; + function SupplyDataBuffer(pStreamBuffer: PMPEG_STREAM_BUFFER): HResult; stdcall; + end; + +///////////////////////////////////////////////////////////////////////////// +// +// Copyright (c) Microsoft Corporation. All rights reserved. +// +// Module Name: +// +// MPEG2Error.h +// +// Abstract: +// +// Interface specific HResult error codes for MPEG-2 tables. +// +///////////////////////////////////////////////////////////////////////////// + + + // Interface specific SUCCESS and ERROR macros + +const + // MPEG-2 base HResult code (must be at least 0x200) + MPEG2_BASE = Cardinal($200); + {$EXTERNALSYM MPEG2_BASE} + + // MPEG-2 Success HRESULTs + MPEG2_S_MORE_DATA_AVAILABLE = HResult((SEVERITY_SUCCESS shl 31) or (FACILITY_ITF shl 16) or (MPEG2_BASE + 0)); + {$EXTERNALSYM MPEG2_S_MORE_DATA_AVAILABLE} + MPEG2_S_NO_MORE_DATA_AVAILABLE = HResult((SEVERITY_SUCCESS shl 31) or (FACILITY_ITF shl 16) or (MPEG2_BASE + 1)); + {$EXTERNALSYM MPEG2_S_NO_MORE_DATA_AVAILABLE} + MPEG2_S_SG_INFO_FOUND = HResult((SEVERITY_SUCCESS shl 31) or (FACILITY_ITF shl 16) or (MPEG2_BASE + 2)); + {$EXTERNALSYM MPEG2_S_SG_INFO_FOUND} + MPEG2_S_SG_INFO_NOT_FOUND = HResult((SEVERITY_SUCCESS shl 31) or (FACILITY_ITF shl 16) or (MPEG2_BASE + 3)); + {$EXTERNALSYM MPEG2_S_SG_INFO_NOT_FOUND} + MPEG2_S_MPE_INFO_FOUND = HResult((SEVERITY_SUCCESS shl 31) or (FACILITY_ITF shl 16) or (MPEG2_BASE + 4)); + {$EXTERNALSYM MPEG2_S_MPE_INFO_FOUND} + MPEG2_S_MPE_INFO_NOT_FOUND = HResult((SEVERITY_SUCCESS shl 31) or (FACILITY_ITF shl 16) or (MPEG2_BASE + 5)); + {$EXTERNALSYM MPEG2_S_MPE_INFO_NOT_FOUND} + MPEG2_S_NEW_MODULE_VERSION = HResult((SEVERITY_SUCCESS shl 31) or (FACILITY_ITF shl 16) or (MPEG2_BASE + 6)); + {$EXTERNALSYM MPEG2_S_NEW_MODULE_VERSION} + + // MPEG-2 Error HRESULTs + MPEG2_E_UNINITIALIZED = HResult((SEVERITY_ERROR shl 31) or (FACILITY_ITF shl 16) or (MPEG2_BASE + 0)); + {$EXTERNALSYM MPEG2_E_UNINITIALIZED} + MPEG2_E_ALREADY_INITIALIZED = HResult((SEVERITY_ERROR shl 31) or (FACILITY_ITF shl 16) or (MPEG2_BASE + 1)); + {$EXTERNALSYM MPEG2_E_ALREADY_INITIALIZED} + MPEG2_E_OUT_OF_BOUNDS = HResult((SEVERITY_ERROR shl 31) or (FACILITY_ITF shl 16) or (MPEG2_BASE + 2)); + {$EXTERNALSYM MPEG2_E_OUT_OF_BOUNDS} + MPEG2_E_MALFORMED_TABLE = HResult((SEVERITY_ERROR shl 31) or (FACILITY_ITF shl 16) or (MPEG2_BASE + 3)); + {$EXTERNALSYM MPEG2_E_MALFORMED_TABLE} + MPEG2_E_UNDEFINED = HResult((SEVERITY_ERROR shl 31) or (FACILITY_ITF shl 16) or (MPEG2_BASE + 4)); + {$EXTERNALSYM MPEG2_E_UNDEFINED} + MPEG2_E_NOT_PRESENT = HResult((SEVERITY_ERROR shl 31) or (FACILITY_ITF shl 16) or (MPEG2_BASE + 5)); + {$EXTERNALSYM MPEG2_E_NOT_PRESENT} + MPEG2_E_SECTION_NOT_FOUND = HResult((SEVERITY_ERROR shl 31) or (FACILITY_ITF shl 16) or (MPEG2_BASE + 6)); + {$EXTERNALSYM MPEG2_E_SECTION_NOT_FOUND} + MPEG2_E_TX_STREAM_UNAVAILABLE = HResult((SEVERITY_ERROR shl 31) or (FACILITY_ITF shl 16) or (MPEG2_BASE + 7)); + {$EXTERNALSYM MPEG2_E_TX_STREAM_UNAVAILABLE} + MPEG2_E_SERVICE_ID_NOT_FOUND = HResult((SEVERITY_ERROR shl 31) or (FACILITY_ITF shl 16) or (MPEG2_BASE + 8)); + {$EXTERNALSYM MPEG2_E_SERVICE_ID_NOT_FOUND} + MPEG2_E_SERVICE_PMT_NOT_FOUND = HResult((SEVERITY_ERROR shl 31) or (FACILITY_ITF shl 16) or (MPEG2_BASE + 9)); + {$EXTERNALSYM MPEG2_E_SERVICE_PMT_NOT_FOUND} + MPEG2_E_DSI_NOT_FOUND = HResult((SEVERITY_ERROR shl 31) or (FACILITY_ITF shl 16) or (MPEG2_BASE + 10)); + {$EXTERNALSYM MPEG2_E_DSI_NOT_FOUND} + MPEG2_E_SERVER_UNAVAILABLE = HResult((SEVERITY_ERROR shl 31) or (FACILITY_ITF shl 16) or (MPEG2_BASE + 11)); + {$EXTERNALSYM MPEG2_E_SERVER_UNAVAILABLE} + MPEG2_E_INVALID_CAROUSEL_ID = HResult((SEVERITY_ERROR shl 31) or (FACILITY_ITF shl 16) or (MPEG2_BASE + 12)); + {$EXTERNALSYM MPEG2_E_INVALID_CAROUSEL_ID} + MPEG2_E_MALFORMED_DSMCC_MESSAGE = HResult((SEVERITY_ERROR shl 31) or (FACILITY_ITF shl 16) or (MPEG2_BASE + 13)); + {$EXTERNALSYM MPEG2_E_MALFORMED_DSMCC_MESSAGE} + MPEG2_E_INVALID_SG_OBJECT_KIND = HResult((SEVERITY_ERROR shl 31) or (FACILITY_ITF shl 16) or (MPEG2_BASE + 14)); + {$EXTERNALSYM MPEG2_E_INVALID_SG_OBJECT_KIND} + MPEG2_E_OBJECT_NOT_FOUND = HResult((SEVERITY_ERROR shl 31) or (FACILITY_ITF shl 16) or (MPEG2_BASE + 15)); + {$EXTERNALSYM MPEG2_E_OBJECT_NOT_FOUND} + MPEG2_E_OBJECT_KIND_NOT_A_DIRECTORY = HResult((SEVERITY_ERROR shl 31) or (FACILITY_ITF shl 16) or (MPEG2_BASE + 16)); + {$EXTERNALSYM MPEG2_E_OBJECT_KIND_NOT_A_DIRECTORY} + MPEG2_E_OBJECT_KIND_NOT_A_FILE = HResult((SEVERITY_ERROR shl 31) or (FACILITY_ITF shl 16) or (MPEG2_BASE + 17)); + {$EXTERNALSYM MPEG2_E_OBJECT_KIND_NOT_A_FILE} + MPEG2_E_FILE_OFFSET_TOO_BIG = HResult((SEVERITY_ERROR shl 31) or (FACILITY_ITF shl 16) or (MPEG2_BASE + 18)); + {$EXTERNALSYM MPEG2_E_FILE_OFFSET_TOO_BIG} + MPEG2_E_STREAM_STOPPED = HResult((SEVERITY_ERROR shl 31) or (FACILITY_ITF shl 16) or (MPEG2_BASE + 19)); + {$EXTERNALSYM MPEG2_E_STREAM_STOPPED} + MPEG2_E_REGISTRY_ACCESS_FAILED = HResult((SEVERITY_ERROR shl 31) or (FACILITY_ITF shl 16) or (MPEG2_BASE + 20)); + {$EXTERNALSYM MPEG2_E_REGISTRY_ACCESS_FAILED} + MPEG2_E_INVALID_UDP_PORT = HResult((SEVERITY_ERROR shl 31) or (FACILITY_ITF shl 16) or (MPEG2_BASE + 21)); + {$EXTERNALSYM MPEG2_E_INVALID_UDP_PORT} + MPEG2_E_DATA_SOURCE_FAILED = HResult((SEVERITY_ERROR shl 31) or (FACILITY_ITF shl 16) or (MPEG2_BASE + 22)); + {$EXTERNALSYM MPEG2_E_DATA_SOURCE_FAILED} + MPEG2_E_DII_NOT_FOUND = HResult((SEVERITY_ERROR shl 31) or (FACILITY_ITF shl 16) or (MPEG2_BASE + 23)); + {$EXTERNALSYM MPEG2_E_DII_NOT_FOUND} + MPEG2_E_DSHOW_PIN_NOT_FOUND = HResult((SEVERITY_ERROR shl 31) or (FACILITY_ITF shl 16) or (MPEG2_BASE + 24)); + {$EXTERNALSYM MPEG2_E_DSHOW_PIN_NOT_FOUND} + MPEG2_E_BUFFER_TOO_SMALL = HResult((SEVERITY_ERROR shl 31) or (FACILITY_ITF shl 16) or (MPEG2_BASE + 25)); + {$EXTERNALSYM MPEG2_E_BUFFER_TOO_SMALL} + MPEG2_E_MISSING_SECTIONS = HResult((SEVERITY_ERROR shl 31) or (FACILITY_ITF shl 16) or (MPEG2_BASE + 26)); + {$EXTERNALSYM MPEG2_E_MISSING_SECTIONS} + MPEG2_E_TOO_MANY_SECTIONS = HResult((SEVERITY_ERROR shl 31) or (FACILITY_ITF shl 16) or (MPEG2_BASE + 27)); + {$EXTERNALSYM MPEG2_E_TOO_MANY_SECTIONS} + MPEG2_E_NEXT_TABLE_OPS_NOT_AVAILABLE = HResult((SEVERITY_ERROR shl 31) or (FACILITY_ITF shl 16) or (MPEG2_BASE + 28)); + {$EXTERNALSYM MPEG2_E_NEXT_TABLE_OPS_NOT_AVAILABLE} + +//////////////////////////////////////////////////////////////////////////////// +// Copyright (C) Microsoft Corporation, 1998 - 1999 +// +// Module Name: +// EDevCtrl.h +// +// Abstract: +// This header contain structures and peroperty sets for +// interfacing to an external device, like a DV. +// The code is modeled after DirectShow's Vcrctrl Sample +// (VCR Control Filter). It contain IAMExtDevice, +// IAMExtTransport, and IAMTimecodeReader interfaces, and +// a new interface IAMAdvancedAVControl() is added +// for additional advanced device controls. +// +// Note: (From DShow DDK) +// The VCR control sample filter, Vcrctrl, is a simple +// implementation of the external device control interfaces +// that DirectShow provides. Vcrctrl provides basic transport +// control and SMPTE timecode-reading capabilities for certain +// Betacam and SVHS videocassette recorders with RS-422 or RS-232 +// serial interfaces (see source code for specific machine types +// supported). +// +// Note: some methods in IAM* interfaces may not be +// used and will return not implemented. +// +// Created: +// September 23, 1998 +// Yee J. Wu +// +// Revision: 0.6 +// +//////////////////////////////////////////////////////////////////////////////// + +type + + // Device Capabilities + tagDEVCAPS = record + CanRecord : LongInt; + CanRecordStrobe : LongInt; + HasAudio : LongInt; + HasVideo : LongInt; + UsesFiles : LongInt; + CanSave : LongInt; + DeviceType : LongInt; + TCRead : LongInt; + TCWrite : LongInt; + CTLRead : LongInt; + IndexRead : LongInt; + Preroll : LongInt; + Postroll : LongInt; + SyncAcc : LongInt; + NormRate : LongInt; + CanPreview : LongInt; + CanMonitorSrc : LongInt; + CanTest : LongInt; + VideoIn : LongInt; + AudioIn : LongInt; + Calibrate : LongInt; + SeekType : LongInt; + SimulatedHardware : LongInt; // private + end; + {$EXTERNALSYM tagDEVCAPS} + DEVCAPS = tagDEVCAPS; + {$EXTERNALSYM DEVCAPS} + PDEVCAPS = ^DEVCAPS; + {$EXTERNALSYM PDEVCAPS} + TDevCaps = tagDEVCAPS; + + // transport status + tagTRANSPORTSTATUS = record + Mode : LongInt; + LastError : LongInt; + RecordInhibit : LongInt; + ServoLock : LongInt; + MediaPresent : LongInt; + MediaLength : LongInt; + MediaSize : LongInt; + MediaTrackCount : LongInt; + MediaTrackLength : LongInt; + MediaTrackSide : LongInt; + MediaType : LongInt; + LinkMode : LongInt; + NotifyOn : LongInt; + end; + {$EXTERNALSYM tagTRANSPORTSTATUS} + TRANSPORTSTATUS = tagTRANSPORTSTATUS; + {$EXTERNALSYM TRANSPORTSTATUS} + PTRANSPORTSTATUS = ^TRANSPORTSTATUS; + {$EXTERNALSYM PTRANSPORTSTATUS} + TTransportStatus = tagTRANSPORTSTATUS; + + // transport basic parameters + tagTRANSPORTBASICPARMS = record + TimeFormat : LongInt; + TimeReference : LongInt; + Superimpose : LongInt; + EndStopAction : LongInt; + RecordFormat : LongInt; + StepFrames : LongInt; + SetpField : LongInt; + Preroll : LongInt; + RecPreroll : LongInt; + Postroll : LongInt; + EditDelay : LongInt; + PlayTCDelay : LongInt; + RecTCDelay : LongInt; + EditField : LongInt; + FrameServo : LongInt; + ColorFrameServo : LongInt; + ServoRef : LongInt; + WarnGenlock : LongInt; + SetTracking : LongInt; + VolumeName: array[0..39] of Char; + Ballistic: array[0..19] of LongInt; + Speed : LongInt; + CounterFormat : LongInt; + TunerChannel : LongInt; + TunerNumber : LongInt; + TimerEvent : LongInt; + TimerStartDay : LongInt; + TimerStartTime : LongInt; + TimerStopDay : LongInt; + TimerStopTime : LongInt; + end; + {$EXTERNALSYM tagTRANSPORTBASICPARMS} + TRANSPORTBASICPARMS = tagTRANSPORTBASICPARMS; + {$EXTERNALSYM TRANSPORTBASICPARMS} + PTRANSPORTBASICPARMS = ^TRANSPORTBASICPARMS; + {$EXTERNALSYM PTRANSPORTBASICPARMS} + TTransportBasicParms = tagTRANSPORTBASICPARMS; + + + // transport video parameters + tagTRANSPORTVIDEOPARMS = record + OutputMode : LongInt; + Input : LongInt; + end; + {$EXTERNALSYM tagTRANSPORTVIDEOPARMS} + TRANSPORTVIDEOPARMS = tagTRANSPORTVIDEOPARMS; + {$EXTERNALSYM TRANSPORTVIDEOPARMS} + PTRANSPORTVIDEOPARMS = ^TRANSPORTVIDEOPARMS; + {$EXTERNALSYM PTRANSPORTVIDEOPARMS} + TTransportVideoParms = tagTRANSPORTVIDEOPARMS; + + // transport audio parameters + tagTRANSPORTAUDIOPARMS = record + EnableOutput : LongInt; + EnableRecord : LongInt; + EnableSelsync : LongInt; + Input : LongInt; + MonitorSource : LongInt; + end; + {$EXTERNALSYM tagTRANSPORTAUDIOPARMS} + TRANSPORTAUDIOPARMS = tagTRANSPORTAUDIOPARMS; + {$EXTERNALSYM TRANSPORTAUDIOPARMS} + PTRANSPORTAUDIOPARMS = ^TRANSPORTAUDIOPARMS; + {$EXTERNALSYM PTRANSPORTAUDIOPARMS} + TTransportAudioParms = tagTRANSPORTAUDIOPARMS; + + // low level machine status structure filled in after + // REQUEST_STATUS command from above. This structure would + // grow in a full implementation + tagVCRSTATUS = record + bCassetteOut : BOOL; // OATRUE means no cassette + bLocal : BOOL; // OATRUE means front panel switch in local + end; + {$NODEFINE tagVCRSTATUS} + VCRSTATUS = tagVCRSTATUS; + {$NODEFINE VCRSTATUS} + PVCRSTATUS = ^VCRSTATUS; + {$NODEFINE PVCRSTATUS} + TVCRStatus = tagVCRSTATUS; + {$NODEFINE TVCRStatus} +//--------------------------------------------------------- +// STATIC_PROPSETID_VIDCAP_EXT_DEVICE +//--------------------------------------------------------- +// This guid and interface is defined in strmif.h +const + PROPSETID_EXT_DEVICE : TGUID = '{B5730A90-1A2C-11cf-8C23-00AA006B6814}'; + {$EXTERNALSYM PROPSETID_EXT_DEVICE} + +type + // KS properties and structure for this interface + KSPROPERTY_EXTDEVICE = ( + KSPROPERTY_EXTDEVICE_ID, // ID (such as Symbolic Lin) that can uniquely idenfy this device + KSPROPERTY_EXTDEVICE_VERSION, // Device model number and version (such AV/C VCR Subunit Spec. 2.01) + KSPROPERTY_EXTDEVICE_POWER_STATE, // Return current device power state. + KSPROPERTY_EXTDEVICE_PORT, // Can use this to return DEV_PORT_1394 + KSPROPERTY_EXTDEVICE_CAPABILITIES // Device specific capabilities + ); + {$EXTERNALSYM KSPROPERTY_EXTDEVICE} + TKSPropertyExtDevice = KSPROPERTY_EXTDEVICE; + + PKSPropertyExtDeviceS = ^TKSPropertyExtDeviceS; + KSPROPERTY_EXTDEVICE_S = record + Property_ : KSPROPERTY; + // Client is responsible for allocating this. + case byte of + 0: (Capabilities: TDEVCAPS); + 1: (DevPort: ULONG); + 2: (PowerState: ULONG); + 3: (pawchString: array[0..MAX_PATH-1] of WideChar); + 4: (NodeUniqueID: array[0..1] of DWORD); + end; + {$EXTERNALSYM KSPROPERTY_EXTDEVICE_S} + PKSPROPERTY_EXTDEVICE_S = ^KSPROPERTY_EXTDEVICE_S; + {$EXTERNALSYM PKSPROPERTY_EXTDEVICE_S} + TKSPropertyExtDeviceS = KSPROPERTY_EXTDEVICE_S; + +//--------------------------------------------------------- +// STATIC_PROPSETID_VIDCAP_EXT_TRANSPORT +//--------------------------------------------------------- +const + // This guid and interface is defined in strmif.h + PROPSETID_EXT_TRANSPORT : TGUID = '{A03CD5F0-3045-11cf-8C44-00AA006B6814}'; + {$EXTERNALSYM PROPSETID_EXT_TRANSPORT} + +type + // KS properties and structure for this interface + KSPROPERTY_EXTXPORT = ( + KSPROPERTY_EXTXPORT_CAPABILITIES, // Transport specific capability + KSPROPERTY_EXTXPORT_INPUT_SIGNAL_MODE, // MPEG, D-VHS, Analog VHS etc. + KSPROPERTY_EXTXPORT_OUTPUT_SIGNAL_MODE, // MPEG, D-VHS, Analog VHS etc. + KSPROPERTY_EXTXPORT_LOAD_MEDIUM, // Eject, open tray, close tray + KSPROPERTY_EXTXPORT_MEDIUM_INFO, // cassettte_type and tape_grade_and_write_protect + KSPROPERTY_EXTXPORT_STATE, // Get/Set transport mode and state + KSPROPERTY_EXTXPORT_STATE_NOTIFY, // NOTIFY: Mode + State (Table 4-8) + KSPROPERTY_EXTXPORT_TIMECODE_SEARCH, // Request VCR subunit to search for a specific timecode on the medium + KSPROPERTY_EXTXPORT_ATN_SEARCH, // Request VCR subunit to search for a specific ATN on the medium + KSPROPERTY_EXTXPORT_RTC_SEARCH, // Request VCR subunit to search for a specific RelativeTimeCounter on the medium + // Implemented for testing purpose + // Will remove this later... + KSPROPERTY_RAW_AVC_CMD // Send/Rcv raw AVC commnad with a FCP packet. + ); + {$EXTERNALSYM KSPROPERTY_EXTXPORT} + TKSPropertyExtXPort = KSPROPERTY_EXTXPORT; + + PMediumInfo = ^TMediumInfo; + MEDIUM_INFO = record + MediaPresent : BOOL; // TRUE/FALSE + MediaType : ULONG; // DVCR standard, small, medium; VHS; VHS-C; unknown + RecordInhibit : BOOL; // TRUE/FALSE + end; + {$EXTERNALSYM MEDIUM_INFO} + PMEDIUM_INFO = ^MEDIUM_INFO; + {$EXTERNALSYM PMEDIUM_INFO} + TMediumInfo = MEDIUM_INFO; + + PTransportState = ^TTransportState; + TRANSPORT_STATE = record + Mode : ULONG; // LOAD MEDIUM, RECORD, PLAY or WIND + State : ULONG; // Vary depend on mode (Table 4-8) + end; + {$EXTERNALSYM TRANSPORT_STATE} + PTRANSPORT_STATE = ^TRANSPORT_STATE; + {$EXTERNALSYM PTRANSPORT_STATE} + TTransportState = TRANSPORT_STATE; + + PKSPropertyExtXPortS = ^TKSPropertyExtXPortS; + KSPROPERTY_EXTXPORT_S = record + Property_: KSPROPERTY; + case byte of + 0: (Capabilities: ULONG); // May need to expand on the existing structure + 1: (SignalMode: ULONG); // May need to expand on the existing structure + 2: (LoadMedium: ULONG); // MPEG, D-VHS, Analog VHS etc. + 3: (MediumInfo: TMediumInfo); // Eject, open tray, close tray + 4: (XPrtState: TTransportState); + 5: (Timecode: record + frame : BYTE; + second : BYTE; + minute : BYTE; + hour : BYTE; + end; + ); + 6: (dwTimecode: DWORD); // hour:minute:second:frame + 7: (dwAbsTrackNumber: DWORD); // absolute track number + // Implemented for testing purpose + // Will remove this later or will keep this for + // packet specific command. + 8: (RawAVC: record + PayloadSize : ULONG; + Payload : array[0..511] of BYTE; // This is only for testing sending AVC command from User mode. + end;); + end; + {$EXTERNALSYM KSPROPERTY_EXTXPORT_S} + PKSPROPERTY_EXTXPORT_S = ^KSPROPERTY_EXTXPORT_S; + {$EXTERNALSYM PKSPROPERTY_EXTXPORT_S} + TKSPropertyExtXPortS = KSPROPERTY_EXTXPORT_S; + + PKSPropertyExtxportNodeS = ^TKSPropertyExtxportNodeS; + KSPROPERTY_EXTXPORT_NODE_S = packed record + NodeProperty: KSP_NODE; + case byte of + 0: (Capabilities: ULONG); + 1: (SignalMode: ULONG); + 2: (LoadMedium: ULONG); + 3: (MediumInfo: MEDIUM_INFO); + 4: (XPrtState: TRANSPORT_STATE); + 5: (Timecode: record + frame: byte; + second: byte; + minute: byte; + hour: byte; + end); + 6: (dwTimecode: DWORD); + 7: (dwAbsTrackNumber: DWORD); + 8: (RawAVC: record + PayloadSize: ULONG; + Payload: array[0..511] of byte; + end); + end; + {$EXTERNALSYM KSPROPERTY_EXTXPORT_NODE_S} + PKSPROPERTY_EXTXPORT_NODE_S = KSPROPERTY_EXTXPORT_NODE_S; + {$EXTERNALSYM PKSPROPERTY_EXTXPORT_NODE_S} + TKSPropertyExtxportNodeS = KSPROPERTY_EXTXPORT_NODE_S; + +//--------------------------------------------------------- +// PROPSETID_TIMECODE +//--------------------------------------------------------- +// This guid and interface is defined in strmif.h +const + PROPSETID_TIMECODE_READER : TGUID = '{9B496CE1-811B-11cf-8C77-00AA006B6814}'; + {$EXTERNALSYM PROPSETID_TIMECODE_READER} + +type + // KS properties and structure for this interface + KSPROPERTY_TIMECODE = ( + KSPROPERTY_TIMECODE_READER, // Timecode for the current medium position + KSPROPERTY_ATN_READER, // Absolute track number the current medium position + KSPROPERTY_RTC_READER // Relative time counter for the current medium position + ); + {$EXTERNALSYM KSPROPERTY_TIMECODE} + TKSPropertyTimeCode = KSPROPERTY_TIMECODE; + + KSPROPERTY_TIMECODE_S = record + Property_: KSPROPERTY; + TimecodeSamp: TTimeCodeSample; + end; + {$EXTERNALSYM KSPROPERTY_TIMECODE_S} + PKSPROPERTY_TIMECODE_S = ^KSPROPERTY_TIMECODE_S; + {$EXTERNALSYM PKSPROPERTY_TIMECODE_S} + TKSPropertyTimeCodeS = KSPROPERTY_TIMECODE_S; + + PKSPropertyTimecodeNodeS = ^TKSPropertyTimecodeNodeS; + KSPROPERTY_TIMECODE_NODE_S = packed record + NodeProperty: KSP_NODE; + TimecodeSamp: TIMECODE_SAMPLE; + end; + {$EXTERNALSYM KSPROPERTY_TIMECODE_NODE_S} + PKSPROPERTY_TIMECODE_NODE_S = ^KSPROPERTY_TIMECODE_NODE_S; + {$EXTERNALSYM PKSPROPERTY_TIMECODE_NODE_S} + TKSPropertyTimecodeNodeS = PKSPROPERTY_TIMECODE_NODE_S; + +//--------------------------------------------------------- +// External Device Command event notification +//--------------------------------------------------------- +const + KSEVENTSETID_EXTDEV_Command : TGUID = '{109c7988-b3cb-11d2-b48e-006097b3391b}'; + {$EXTERNALSYM KSEVENTSETID_EXTDEV_Command} + +type + KSEVENT_DEVCMD = ( + KSEVENT_EXTDEV_COMMAND_NOTIFY_INTERIM_READY, + KSEVENT_EXTDEV_COMMAND_CONTROL_INTERIM_READY, + KSEVENT_EXTDEV_COMMAND_BUSRESET, + KSEVENT_EXTDEV_TIMECODE_UPDATE, + KSEVENT_EXTDEV_OPERATION_MODE_UPDATE, // Notify mode of operation change (VCR,OFF,Camera) + KSEVENT_EXTDEV_TRANSPORT_STATE_UPDATE, // XPrt state change + KSEVENT_EXTDEV_NOTIFY_REMOVAL, // Notify device removal + KSEVENT_EXTDEV_NOTIFY_MEDIUM_CHANGE // Notify medium (tape) is removed or added + ); + {$EXTERNALSYM KSEVENT_DEVCMD} + TKSEventDevCmd = KSEVENT_DEVCMD; + + +//////////////////////////////////////////////////////////////////////////////// +// Copyright (c) 2002 Microsoft Corporation +// +// Module Name: +// +// sbe.idl +// +// Abstract: +// +// This module the StreamBuffer interface definitions & CLSIDs, public +// +//////////////////////////////////////////////////////////////////////////////// + +const + IID_IStreamBufferSink : TGUID = '{afd1f242-7efd-45ee-ba4e-407a25c9a77a}'; // get recording objects + {$EXTERNALSYM IID_IStreamBufferSink} + IID_IStreamBufferSource : TGUID = '{1c5bd776-6ced-4f44-8164-5eab0e98db12}'; // associates with IStreamBufferSink + {$EXTERNALSYM IID_IStreamBufferSource} + IID_IStreamBufferRecordControl : TGUID = '{ba9b6c99-f3c7-4ff2-92db-cfdd4851bf31}'; // recording control + {$EXTERNALSYM IID_IStreamBufferRecordControl} + IID_IStreamBufferRecComp : TGUID = '{9E259A9B-8815-42ae-B09F-221970B154FD}'; + {$EXTERNALSYM IID_IStreamBufferRecComp} + IID_IStreamBufferRecordingAttribute : TGUID = '{16CA4E03-FE69-4705-BD41-5B7DFC0C95F3}'; // StreamBuffer attribute creation + {$EXTERNALSYM IID_IStreamBufferRecordingAttribute} + IID_IEnumStreamBufferRecordingAttrib : TGUID = '{C18A9162-1E82-4142-8C73-5690FA62FE33}'; // StreamBuffer attribute enumeration + {$EXTERNALSYM IID_IEnumStreamBufferRecordingAttrib} + IID_IStreamBufferConfigure : TGUID = '{ce14dfae-4098-4af7-bbf7-d6511f835414}'; // configuration interface + {$EXTERNALSYM IID_IStreamBufferConfigure} + IID_IStreamBufferMediaSeeking : TGUID = '{f61f5c26-863d-4afa-b0ba-2f81dc978596}'; // IMediaSeeking but with different GUID + {$EXTERNALSYM IID_IStreamBufferMediaSeeking} + IID_IStreamBufferInitialize : TGUID = '{9ce50f2d-6ba7-40fb-a034-50b1a674ec78}'; // allows 3rd party app to set HKEY + {$EXTERNALSYM IID_IStreamBufferInitialize} +// ??? IID_IStreamBufferPolicy : TGUID = '{}'; // StreamBuffer policies + +type + {$HPPEMIT 'typedef System::DelphiInterface _di_IStreamBufferInitialize;'} + {$EXTERNALSYM IStreamBufferInitialize} + IStreamBufferInitialize = interface(IUnknown) + ['{9ce50f2d-6ba7-40fb-a034-50b1a674ec78}'] + (*** IStreamBufferInitialize methods ***) + // Implemented on StreamBufferStreamSink and StreamBufferSource filters. + // Gives a hosting application the ability to specify HKEY root in + // registry. This method must called **early**: after the filter is + // instantiated, but before StreamBufferSource is locked (explicitly or + // implicitely) if calling the method on StreamBufferSource, or before + // a source is set (via IStreamBufferSource or IFileSourceFilter) if + // calling the method on StreamBufferStreamSource. If a call is made + // after either filter has been initialized internally, the call will + // fail with E_UNEXPECTED. The hosting application is responsible for + // ensuring that the HKEY passed in is writable & readable per the + // logged-on user privileges. The HKEY is duplicated internally, + // so the caller can close it after making this call. + function SetHKEY(hkeyRoot: HKEY): HResult; stdcall; + + // Implemented on StreamBufferStreamSink and StreamBufferSource filters. + // Provides a way for the hosting application to specify security-level + // sharing between capture and render processes and contexts. By + // default security attributes are inherited from the hosting process, + // unless the application overrides the defaults and provides them via + // this method. + function SetSIDs(cSIDs: DWORD; var ppSID: PSID): HResult; stdcall; + end; + +// ============================================================================ +// ============================================================================ +// IStreamBufferSink +// +// Stream Source interface; +// implemented on the StreamBufferSink filter; +// Only way to get a recorder object's IUnknown (object will subsequently +// be associated with this Sink) +const + RECORDING_TYPE_CONTENT = 0; // no post-recording or overlapped + {$EXTERNALSYM RECORDING_TYPE_CONTENT} + RECORDING_TYPE_REFERENCE = 1; // allows post-recording & overlapped + {$EXTERNALSYM RECORDING_TYPE_REFERENCE} + +type + {$HPPEMIT 'typedef System::DelphiInterface _di_IStreamBufferSink;'} + {$EXTERNALSYM IStreamBufferSink} + IStreamBufferSink = interface(IUnknown) + ['{afd1f242-7efd-45ee-ba4e-407a25c9a77a}'] + (*** IStreamBufferSink methods ***) + // 1. Locks the profile; + // 2. No *new* input pin connections will be accepted; + // 3. Existing pins that are, or have ever been, connected can be + // reconnected if the media type is exactly the same as the first + // successful connection; + // 4. Can be called multiple times safely with NULL parameter, but only + // once with non-NULL parameter; returns E_UNEXPECTED if called more + // than once with non-NULL param, or after the hosting filter has run; + // 5. Must be called before the filter that implements this interface is + // ever run; when it is run, it locks implicitely and this method has + // no effect if called with NULL parameters, or fails if called with + // non-NULL parameter for the reasons listed above; + // 6. Errors with VFW_E_UNSUPPORTED_STREAM if there are no streams in the + // profile; + // Parameter Detail + // ---------------- + // + // pszStreamBufferFilename + // + // Is a NULL-terminated filename string. If the content written by + // this sink is to be shared cross-process, this parameter specifies a + // filename that will be opened by any reader(s) to read & render the + // content sent into the sink. + // + // Can be NULL (not specified) + // + // Must be a full-path filename; if no path is specified, the file is + // created in a "current" directory + // + // If the file already exists, the call fails + // + // Is opened with DELETE_ON_CLOSE flag, so is automatically deleted + // when the sink is unlocked, or when the hosting process terminates + function LockProfile(pszStreamBufferFilename: PWideChar): HResult; stdcall; + + // 1. Returns a *new* recorder object's IUnknown; + // 2. Caller can call QueryInterface() on the returned pointer to get + // interface pointers to configure & control the recording; + // 3. Returned IUnknown pointer is ref'd & must be Release()'d by the + // caller + // 4. IStreamBufferSink interface must have been locked (explicitely or + // implicitely) prior to call + // + // To create an ordinary recording, specify RECORDING_TYPE_CONTENT for the + // dwRecordType parammeter. This will record the content directly into + // the specified file. These recording types only accept start and stop + // times that occur in the future. + // + // A recording of type RECORDING_TYPE_REFERENCE generates a small file + // that references content saved in temporary storage. Recordings of this + // type can have start and stop times that occurs in the past, and can + // overlap other same-type recordings. + // + // Reference recording *content* will be saved in the same subdirectory as + // the specified reference file, but with hidden and system attributes. + // The naming convention of the files will append a _1.sbe, _2.sbe, etc... + // to the filename (minus extension) specified in the call e.g. a + // "seinfeld01.sbe" reference file will have saved content in hidden + // and system files "seinfeld01_1.sbe", "seinfeld01_2.sbe", etc... + function CreateRecorder(pszFilename: PWideChar; dwRecordType: DWORD; // RECORDING_TYPE_CONTENT or RECORDING_TYPE_REFERENCE + out pRecordingIUnknown: IUnknown): HResult; stdcall; + + // 1. Returns S_OK if the profile is locked and S_FALSE if it is not. + // 2. Returns E_FAIL on error. + function IsProfileLocked: HResult; stdcall; + end; + +// ============================================================================ +// ============================================================================ +// IStreamBufferSource () +// +// Stream Source reader interface; +// Implemented on the StreamBufferSource filter; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IStreamBufferSource;'} + {$EXTERNALSYM IStreamBufferSource} + IStreamBufferSource = interface(IUnknown) + ['{1c5bd776-6ced-4f44-8164-5eab0e98db12}'] + (*** IStreamBufferSource methods ***) + //------------------------------------------------------------------------ + // SetStreamSink () + // + // 1. Sets the StreamBuffer Sink that streams from this Source; + // 2. IStreamBufferSink object must be in the same process as this object; + // 3. Interface is AddRef()'d if the call succeeds; + // + // Parameter Detail + // ---------------- + // + // pIStreamBufferSink + // Sink that will stream to this Source + function SetStreamSink(pIStreamBufferSink: IStreamBufferSink): HResult; stdcall; + end; + +// ============================================================================ +// ============================================================================ +// IStreamBufferRecordControl +// +// obtained by QIing IStreamBufferSink::CreateRecorder()-returned IUnknown * + + {$HPPEMIT 'typedef System::DelphiInterface _di_IStreamBufferRecordControl;'} + {$EXTERNALSYM IStreamBufferRecordControl} + IStreamBufferRecordControl = interface(IUnknown) + ['{ba9b6c99-f3c7-4ff2-92db-cfdd4851bf31}'] + (*** IStreamBufferRecordControl methods ***) + // 1. Starts a recording; + // 2. Will save to the filename that is specified when this interface's + // IUnknown is requested (IStreamBufferSink::CreateRecorder()); + // + // Parameter Detail + // ---------------- + // + // rtStart + // + // Start time relative to "now; + // + // If the recording type is a content recording, can only refer to + // seconds in the future; allowed seconds are [0,5] + // + // If the recording type is a reference recording, can refer to any + // time that still has valid content i.e. content that has not yet + // become stale + // + // If the recording is a reference recording and (* prtStart) is + // earlier than the earliest still-valid content, the call will reset + // it to the earliest content; the value when the recording was + // actually started will be [out] + function Start(prtStart: PReferenceTime): HResult; stdcall; + + // 1. Stops a recording; + // 2. Closes out the file; + // + // Parameter Detail + // ---------------- + // + // rtStart + // + // Stop time relative to "now; + // + // If the recording type is a content recording, can only refer to + // seconds in the future; allowed seconds are [0,5] + // + // If the recording type is a reference recording, can refer to any + // time that still has valid content i.e. content that has not yet + // become stale; stop time cannot be <= start time + function Stop(rtStop: TReferenceTime): HResult; stdcall; + + // 1. Retrieves the status of the recording + // + // Parameter Detail + // ---------------- + // + // phResult + // + // The (current) status of writing or closing the recording file; + // + // Can be NULL; + // + // pbStarted + // + // If supplied, set to a non-zero value if the recording has been + // started + // + // Can be NULL; + // + // pbStopped + // + // If supplied, set to a non-zero value if the recording has been + // stopped; + // + // Can be NULL; + // + // NOTE: If the recording has never been started, it will not be flagged + // as stopped. + function GetRecordingStatus(phResult: PHRESULT; pbStarted, pbStopped: PBOOL): HResult; stdcall; + end; + +// ============================================================================ +// ============================================================================ +// IStreamBufferRecComp +// +// CoCreateInstance CLSID_StreamBufferComposeRecording and QueryInterface for +// this interface; this interface allows the creation of a single target +// content recording which consists of a number of concatenated recordings +// (reference or content; can mix & match if desired) + + {$HPPEMIT 'typedef System::DelphiInterface _di_IStreamBufferRecComp;'} + {$EXTERNALSYM IStreamBufferRecComp} + IStreamBufferRecComp = interface(IUnknown) + ['{9E259A9B-8815-42ae-B09F-221970B154FD}'] + (*** IStreamBufferRecComp methods ***) + // 1. Initializes for a target recording + // + // Parameter Detail + // ---------------- + // + // pszTargetFilename + // + // Sets the target filename + // + // Fails if the file already exists + // + // pszSBRecProfileRef + // + // Must be a completed, SBE-generated recording + // + // This recording's profile will be used to define the target profile + // + // Appended files must have exactly the same profile + function Initialize(pszTargetFilename, pszSBRecProfileRef: PWideChar): HResult; stdcall; + + // 1. appends an entire recording + // 2. fails if the recording is live + function Append (pszSBRecording: PwideChar): HResult; stdcall; + + // 1. appends the specified portion of the recording; the parameters must + // be accurate; the call will not readjust them within the boundaries + // 2. the time spread must be at least 2 seconds + // 3. fails if the recording is live + function AppendEx(pszSBRecording: PWideChar; rtStart, rtStop: TReferenceTime): HResult; stdcall; + + // 1. returns the current length of the recording; updates as recordings + // are appended; + // 2. can be called repeatedly during a Append() call on another + // thread; + function GetCurrentLength(out pcSeconds: DWORD): HResult; stdcall; + + // 1. explicitely closes the recording + // 2. final release of interface closes the recording as well + function Close: HResult; stdcall; + + // 1. cancels an in-progress appending operation; has no effect otherwise + function Cancel: HResult; stdcall; + end; + +// ============================================================================ +// ============================================================================ +// IStreamBufferRecordingAttribute +// +// obtained by calling QueryInterface on a recorder +// +// well-known attributes: +// +// NAME DESCRIPTION +// ------------------- ---------------------------------------------------- +// +// Title String containing the content title. +// +// Author String containing the name of the content author. +// +// Description String containing a description of the content. +// +// Rating String containing a content rating. +// +// Copyright String containing a content copyright message. +// +// Duration Quadruple word value containing the playing duration +// of the file, in 100-nanosecond units. +// +// Bitrate Double word value containing the bit rate. +// +// Seekable Boolean value; true denoting that the content is +// seekable. +// +// Stridable Boolean value, true denoting that the content is +// stridable (fast forward and rewind are enabled). +// +// Broadcast Boolean value; true denoting that the content is not +// copyright-protected, and can be broadcast. +// +// Use_DRM reserved +// +// DRM_Flags reserved +// +// DRM_Level reserved +// +// Is_Protected reserved +// +// Is_Trusted reserved +// +// Signature_Name reserved +// +// HasAudio Boolean, true denoting the content includes an +// audio stream. +// +// HasImage Boolean, true denoting the content includes a still +// image stream (such as JPEG images). +// +// HasScript Boolean, true denoting the content includes a script +// stream. +// +// HasVideo Boolean, true denoting the content includes a video +// stream. +// +// CurrentBitrate Double word containing the current total bitrate, +// usually used for MEB (multi-bit rate) streams. +// +// OptimalBitrate Double word containing the minimum total bitrate +// recommended to stream the content and get +// maximum quality. +// +// WM/AlbumTitle String containing the album title. +// +// WM/Track Double word containing the track number. +// +// WM/PromotionURL String with a URL to an HTML page that contains +// information about products and events (such as +// concerts) that are related to this music. +// +// WM/AlbumCoverURL String with a URL to an HTML page that contains an +// image of the album cover and information about +// the album. +// +// WM/Genre String with the genre of the music. +// +// WM/Year String with the year of publication of the music. +// +// WM/GenreID +// +// WM/MCDI +// +// BannerImageType One member of the WMT_ATTR_IMAGETYPE enumeration +// type. +// +// BannerImageData The actual image data: a bitmap, JPEG, or GIF image. +// +// +// BannerImageURL If the banner image is clicked on then this URL is +// activated. +// +// CopyrightURL An URL to a copyright page. +// +// NSC_Name String containing the multicast station contact +// name (read-only). +// +// NSC_Address String containing the multicast station contact +// address (read-only). +// +// NSC_Phone String containing the multicast station contact +// phone number (read-only). +// +// NSC_Email String containing the multicast station contact +// email address (read-only). +// +// NSC_Description String containing the multicast station contact +// description (read-only). + +//////////////////////////////////////////////////////////////// +// +// List of pre-defined attributes +const + g_wszStreamBufferRecordingDuration = WideString('Duration'); + {$EXTERNALSYM g_wszStreamBufferRecordingDuration} + g_wszStreamBufferRecordingBitrate = WideString('Bitrate'); + {$EXTERNALSYM g_wszStreamBufferRecordingBitrate} + g_wszStreamBufferRecordingSeekable = WideString('Seekable'); + {$EXTERNALSYM g_wszStreamBufferRecordingSeekable} + g_wszStreamBufferRecordingStridable = WideString('Stridable'); + {$EXTERNALSYM g_wszStreamBufferRecordingStridable} + g_wszStreamBufferRecordingBroadcast = WideString('Broadcast'); + {$EXTERNALSYM g_wszStreamBufferRecordingBroadcast} + g_wszStreamBufferRecordingProtected = WideString('Is_Protected'); + {$EXTERNALSYM g_wszStreamBufferRecordingProtected} + g_wszStreamBufferRecordingTrusted = WideString('Is_Trusted'); + {$EXTERNALSYM g_wszStreamBufferRecordingTrusted} + g_wszStreamBufferRecordingSignature_Name = WideString('Signature_Name'); + {$EXTERNALSYM g_wszStreamBufferRecordingSignature_Name} + g_wszStreamBufferRecordingHasAudio = WideString('HasAudio'); + {$EXTERNALSYM g_wszStreamBufferRecordingHasAudio} + g_wszStreamBufferRecordingHasImage = WideString('HasImage'); + {$EXTERNALSYM g_wszStreamBufferRecordingHasImage} + g_wszStreamBufferRecordingHasScript = WideString('HasScript'); + {$EXTERNALSYM g_wszStreamBufferRecordingHasScript} + g_wszStreamBufferRecordingHasVideo = WideString('HasVideo'); + {$EXTERNALSYM g_wszStreamBufferRecordingHasVideo} + g_wszStreamBufferRecordingCurrentBitrate = WideString('CurrentBitrate'); + {$EXTERNALSYM g_wszStreamBufferRecordingCurrentBitrate} + g_wszStreamBufferRecordingOptimalBitrate = WideString('OptimalBitrate'); + {$EXTERNALSYM g_wszStreamBufferRecordingOptimalBitrate} + g_wszStreamBufferRecordingHasAttachedImages = WideString('HasAttachedImages'); + {$EXTERNALSYM g_wszStreamBufferRecordingHasAttachedImages} + g_wszStreamBufferRecordingSkipBackward = WideString('Can_Skip_Backward'); + {$EXTERNALSYM g_wszStreamBufferRecordingSkipBackward} + g_wszStreamBufferRecordingSkipForward = WideString('Can_Skip_Forward'); + {$EXTERNALSYM g_wszStreamBufferRecordingSkipForward} + g_wszStreamBufferRecordingNumberOfFrames = WideString('NumberOfFrames'); + {$EXTERNALSYM g_wszStreamBufferRecordingNumberOfFrames} + g_wszStreamBufferRecordingFileSize = WideString('FileSize'); + {$EXTERNALSYM g_wszStreamBufferRecordingFileSize} + g_wszStreamBufferRecordingHasArbitraryDataStream = WideString('HasArbitraryDataStream'); + {$EXTERNALSYM g_wszStreamBufferRecordingHasArbitraryDataStream} + g_wszStreamBufferRecordingHasFileTransferStream = WideString('HasFileTransferStream'); + {$EXTERNALSYM g_wszStreamBufferRecordingHasFileTransferStream} + +//////////////////////////////////////////////////////////////// +// +// The content description object supports 5 basic attributes. + + g_wszStreamBufferRecordingTitle = WideString('Title'); + {$EXTERNALSYM g_wszStreamBufferRecordingTitle} + g_wszStreamBufferRecordingAuthor = WideString('Author'); + {$EXTERNALSYM g_wszStreamBufferRecordingAuthor} + g_wszStreamBufferRecordingDescription = WideString('Description'); + {$EXTERNALSYM g_wszStreamBufferRecordingDescription} + g_wszStreamBufferRecordingRating = WideString('Rating'); + {$EXTERNALSYM g_wszStreamBufferRecordingRating} + g_wszStreamBufferRecordingCopyright = WideString('Copyright'); + {$EXTERNALSYM g_wszStreamBufferRecordingCopyright} + +//////////////////////////////////////////////////////////////// +// +// These attributes are used to configure DRM using IWMDRMWriter::SetDRMAttribute. + + g_wszStreamBufferRecordingUse_DRM = WideString('Use_DRM'); + {$EXTERNALSYM g_wszStreamBufferRecordingUse_DRM} + g_wszStreamBufferRecordingDRM_Flags = WideString('DRM_Flags'); + {$EXTERNALSYM g_wszStreamBufferRecordingDRM_Flags} + g_wszStreamBufferRecordingDRM_Level = WideString('DRM_Level'); + {$EXTERNALSYM g_wszStreamBufferRecordingDRM_Level} + +//////////////////////////////////////////////////////////////// +// +// These are the additional attributes defined in the WM attribute +// namespace that give information about the content. + + g_wszStreamBufferRecordingAlbumTitle = WideString('WM/AlbumTitle'); + {$EXTERNALSYM g_wszStreamBufferRecordingAlbumTitle} + g_wszStreamBufferRecordingTrack = WideString('WM/Track'); + {$EXTERNALSYM g_wszStreamBufferRecordingTrack} + g_wszStreamBufferRecordingPromotionURL = WideString('WM/PromotionURL'); + {$EXTERNALSYM g_wszStreamBufferRecordingPromotionURL} + g_wszStreamBufferRecordingAlbumCoverURL = WideString('WM/AlbumCoverURL'); + {$EXTERNALSYM g_wszStreamBufferRecordingAlbumCoverURL} + g_wszStreamBufferRecordingGenre = WideString('WM/Genre'); + {$EXTERNALSYM g_wszStreamBufferRecordingGenre} + g_wszStreamBufferRecordingYear = WideString('WM/Year'); + {$EXTERNALSYM g_wszStreamBufferRecordingYear} + g_wszStreamBufferRecordingGenreID = WideString('WM/GenreID'); + {$EXTERNALSYM g_wszStreamBufferRecordingGenreID} + g_wszStreamBufferRecordingMCDI = WideString('WM/MCDI'); + {$EXTERNALSYM g_wszStreamBufferRecordingMCDI} + g_wszStreamBufferRecordingComposer = WideString('WM/Composer'); + {$EXTERNALSYM g_wszStreamBufferRecordingComposer} + g_wszStreamBufferRecordingLyrics = WideString('WM/Lyrics'); + {$EXTERNALSYM g_wszStreamBufferRecordingLyrics} + g_wszStreamBufferRecordingTrackNumber = WideString('WM/TrackNumber'); + {$EXTERNALSYM g_wszStreamBufferRecordingTrackNumber} + g_wszStreamBufferRecordingToolName = WideString('WM/ToolName'); + {$EXTERNALSYM g_wszStreamBufferRecordingToolName} + g_wszStreamBufferRecordingToolVersion = WideString('WM/ToolVersion'); + {$EXTERNALSYM g_wszStreamBufferRecordingToolVersion} + g_wszStreamBufferRecordingIsVBR = WideString('IsVBR'); + {$EXTERNALSYM g_wszStreamBufferRecordingIsVBR} + +// WM/AlbumArtist is a potentially different value than Author + + g_wszStreamBufferRecordingAlbumArtist = WideString('WM/AlbumArtist'); + {$EXTERNALSYM g_wszStreamBufferRecordingAlbumArtist} + +//////////////////////////////////////////////////////////////// +// +// These optional attributes may be used to give information +// about the branding of the content. + + g_wszStreamBufferRecordingBannerImageType = WideString('BannerImageType'); + {$EXTERNALSYM g_wszStreamBufferRecordingBannerImageType} + g_wszStreamBufferRecordingBannerImageData = WideString('BannerImageData'); + {$EXTERNALSYM g_wszStreamBufferRecordingBannerImageData} + g_wszStreamBufferRecordingBannerImageURL = WideString('BannerImageURL'); + {$EXTERNALSYM g_wszStreamBufferRecordingBannerImageURL} + g_wszStreamBufferRecordingCopyrightURL = WideString('CopyrightURL'); + {$EXTERNALSYM g_wszStreamBufferRecordingCopyrightURL} + +//////////////////////////////////////////////////////////////// +// +// Optional attributes, used to give information +// about video stream properties. + + g_wszStreamBufferRecordingAspectRatioX = WideString('AspectRatioX'); + {$EXTERNALSYM g_wszStreamBufferRecordingAspectRatioX} + g_wszStreamBufferRecordingAspectRatioY = WideString('AspectRatioY'); + {$EXTERNALSYM g_wszStreamBufferRecordingAspectRatioY} + +//////////////////////////////////////////////////////////////// +// +// The NSC file supports the following attributes. + + g_wszStreamBufferRecordingNSCName = WideString('NSC_Name'); + {$EXTERNALSYM g_wszStreamBufferRecordingNSCName} + g_wszStreamBufferRecordingNSCAddress = WideString('NSC_Address'); + {$EXTERNALSYM g_wszStreamBufferRecordingNSCAddress} + g_wszStreamBufferRecordingNSCPhone = WideString('NSC_Phone'); + {$EXTERNALSYM g_wszStreamBufferRecordingNSCPhone} + g_wszStreamBufferRecordingNSCEmail = WideString('NSC_Email'); + {$EXTERNALSYM g_wszStreamBufferRecordingNSCEmail} + g_wszStreamBufferRecordingNSCDescription = WideString('NSC_Description'); + {$EXTERNALSYM g_wszStreamBufferRecordingNSCDescription} + +type + // StreamBuffer Attribute datatypes; + STREAMBUFFER_ATTR_DATATYPE = ( + STREAMBUFFER_TYPE_DWORD, + STREAMBUFFER_TYPE_STRING, + STREAMBUFFER_TYPE_BINARY, + STREAMBUFFER_TYPE_BOOL, + STREAMBUFFER_TYPE_QWORD, + STREAMBUFFER_TYPE_WORD, + STREAMBUFFER_TYPE_GUID + ); + {$EXTERNALSYM STREAMBUFFER_ATTR_DATATYPE} + TStreamBufferAttrDataType = STREAMBUFFER_ATTR_DATATYPE; + + IEnumStreamBufferRecordingAttrib = interface; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IStreamBufferRecordingAttribute;'} + {$EXTERNALSYM IStreamBufferRecordingAttribute} + IStreamBufferRecordingAttribute = interface(IUnknown) + ['{16CA4E03-FE69-4705-BD41-5B7DFC0C95F3}'] + (*** IStreamBufferRecordingAttribute methods ***) + // 1. Sets an attribute on a recording object; + // 2. Fails if the IStreamBufferRecordControl::Start has already been successfully + // called; + // 3. If an attribute of the same name already exists, overwrites the old; + function SetAttribute(ulReserved: ULONG; pszAttributeName: PWideChar; + StreamBufferAttributeType: TStreamBufferAttrDataType; pbAttribute: PBYTE; + cbAttributeLength: WORD): HResult; stdcall; + + // 1. Returns the count of attributes currently set; + function GetAttributeCount(ulReserved: ULONG; out pcAttributes: WORD): HResult; stdcall; + + // 1. Given a name, returns the attribute data; + // 2. If the provided buffer is too small, returns VFW_E_BUFFER_OVERFLOW, + // and (* pcbLength) contains the minimum required length of the buffer + // 3. To learn the length of the attribute, pass in non-NULL pcbLength, + // and NULL pbAttribute parameter; [out] value will be the length of + // the attribute + function GetAttributeByName(pszAttributeName: PWideChar; pulReserved: PULONG; + out pStreamBufferAttributeType: TStreamBufferAttrDataType; + {out} pbAttribute: PBYTE; var pcbLength: WORD): HResult; stdcall; + + // 1. Given an 0-based index, returns the attribute name and data + // 2. If either buffer is too small, returns VFW_E_BUFFER_OVERFLOW, and + // (* pcbLength) and (* pcchNameLength) contain the minimum required + // length of each buffer + // 3. The length returned by pcchNameLength includes the null-terminator + // 4. To learn the length of the name & attribute, pass in non-NULL + // pcchNameLength & pcbLength, and NULL pszAttributeName & pbAttribute + // parameters; [out] value of the non-NULL parameters will be the + // lengths of the name and attribute + function GetAttributeByIndex(wIndex: WORD; pulReserved: PULONG; + pszAttributeName: PWideChar; var pcchNameLength: WORD; // includes NULL-terminator; in BYTES + out pStreamBufferAttributeType: TStreamBufferAttrDataType; + pbAttribute: PBYTE; pcbLength: PWORD): HResult; stdcall; + + // 1. Returns a StreamBuffer attribute enumeration object that snapshots + // the attributes at time-of-call + function EnumAttributes(out ppIEnumStreamBufferAttrib: IEnumStreamBufferRecordingAttrib): HResult; stdcall; + end; + +// ============================================================================ +// ============================================================================ +// IEnumStreamBufferRecordingAttrib +// +// obtained by calling IStreamBufferRecordingAttribute::EnumAttributes, or +// calling clone on this interface + + PStreamBufferAttribute = ^TStreamBufferAttribute; + STREAMBUFFER_ATTRIBUTE = record + pszName : PWideChar; // allocated by callee; freed by caller + StreamBufferAttributeType : TStreamBufferAttrDataType; + pbAttribute : PBYTE; // allocated by caller; freed by caller + cbLength : WORD; + end; + {$EXTERNALSYM STREAMBUFFER_ATTRIBUTE} + TStreamBufferAttribute = STREAMBUFFER_ATTRIBUTE; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IEnumStreamBufferRecordingAttrib;'} + {$EXTERNALSYM IEnumStreamBufferRecordingAttrib} + IEnumStreamBufferRecordingAttrib = interface(IUnknown) + ['{C18A9162-1E82-4142-8C73-5690FA62FE33}'] + (*** IEnumStreamBufferRecordingAttrib methods ***) + function Next(cRequest: ULONG; pStreamBufferAttribute: PStreamBufferAttribute; + out pcReceived: ULONG): HResult; stdcall; + function Skip(cRecords: ULONG): HResult; stdcall; + function Reset: HResult; stdcall; + function Clone(out ppIEnumStreamBufferAttrib: IEnumStreamBufferRecordingAttrib): HResult; stdcall; + end; + +// ============================================================================ +// ============================================================================ +// IStreamBufferConfigure + + {$HPPEMIT 'typedef System::DelphiInterface _di_IStreamBufferConfigure;'} + {$EXTERNALSYM IStreamBufferConfigure} + IStreamBufferConfigure = interface(IUnknown) + ['{ce14dfae-4098-4af7-bbf7-d6511f835414}'] + (*** IStreamBufferConfigure methods ***) + // 1. Sets the directory where all content is saved, ringbuffer & + // StreamBuffer; + // 2. Creates directory if necessary; + // 3. All TEMP files have hidden+system attributes + function SetDirectory(pszDirectoryName: PWideChar): HResult; stdcall; + + // 1. Retrieves previously set backing store directory, or default + // location if none was specified + function GetDirectory(out ppszDirectoryName: PWideChar): HResult; stdcall; + + // 1. Sets the number of backing files + // 2. valid values + // + // 4 <= min <= 100 + // 6 <= max <= 102 + // min max delta >= 2 + function SetBackingFileCount(dwMin, dwMax: DWORD): HResult; stdcall; + + // 1. Retrieves previously set backing file counts, or defaults if none + // have have been set + function GetBackingFileCount(out pdwMin, pdwMax: DWORD): HResult; stdcall; + + // 1. Sets the seconds of content each backing file will hold + // 2. valid values: + // dwSeconds >= 15 + function SetBackingFileDuration(dwSeconds: DWORD): HResult; stdcall; + + // 1. Retrieves previously set backing file duration, or default of none + // is set + function GetBackingFileDuration(out pdwSeconds: DWORD): HResult; stdcall; + end; + +// ============================================================================ +// ============================================================================ +// IStreamBufferMediaSeeking +// +// Implemented on the StreamBufferSource filter. Used to seek and set the +// playback rate. + + {$HPPEMIT 'typedef System::DelphiInterface _di_IStreamBufferMediaSeeking;'} + {$EXTERNALSYM IStreamBufferMediaSeeking} + IStreamBufferMediaSeeking = interface(IMediaSeeking) + ['{f61f5c26-863d-4afa-b0ba-2f81dc978596}'] + (*** IStreamBufferMediaSeeking methods ***) + // no additional methods have been added + end; + +// ============================================================================ +// ============================================================================ +// events + +// see evcode.h comment for range +// stream buffer engine (PVR) 0x0326 - 0x0350 (sbe.idl) +const + STREAMBUFFER_EC_BASE = $0326; + {$EXTERNALSYM STREAMBUFFER_EC_BASE} + + // timehole event + // param1 = timehole stream offset ms + // param1 = timehole size ms + STREAMBUFFER_EC_TIMEHOLE = STREAMBUFFER_EC_BASE; + {$EXTERNALSYM STREAMBUFFER_EC_TIMEHOLE} + STREAMBUFFER_EC_STALE_DATA_READ = STREAMBUFFER_EC_TIMEHOLE + 1; + {$EXTERNALSYM STREAMBUFFER_EC_STALE_DATA_READ} + STREAMBUFFER_EC_STALE_FILE_DELETED = STREAMBUFFER_EC_STALE_DATA_READ + 1; + {$EXTERNALSYM STREAMBUFFER_EC_STALE_FILE_DELETED} + STREAMBUFFER_EC_CONTENT_BECOMING_STALE = STREAMBUFFER_EC_STALE_FILE_DELETED + 1; + {$EXTERNALSYM STREAMBUFFER_EC_CONTENT_BECOMING_STALE} + STREAMBUFFER_EC_WRITE_FAILURE = STREAMBUFFER_EC_CONTENT_BECOMING_STALE + 1; + {$EXTERNALSYM STREAMBUFFER_EC_WRITE_FAILURE} + + // unexpected read failure + // param1 = HResult failure + // param2 = undefined + STREAMBUFFER_EC_READ_FAILURE = STREAMBUFFER_EC_WRITE_FAILURE + 1; + {$EXTERNALSYM STREAMBUFFER_EC_READ_FAILURE} + + // playback rate change + // param1 = old_playback_rate * 10000 e.g. 2x is 20000 + // param2 = new_playback_rate * 10000 + STREAMBUFFER_EC_RATE_CHANGED = STREAMBUFFER_EC_READ_FAILURE + 1; + {$EXTERNALSYM STREAMBUFFER_EC_RATE_CHANGED} + +/////////////////////////////////////////////////////////////////////////////// +// +// Public Interfaces for the DX9 Video Mixing Renderer DShow filter +// +// Copyright (c) 1999 - 2002, Microsoft Corporation. All rights reserved. +/////////////////////////////////////////////////////////////////////////////// + +// public interfaces supported by the VMR9 +const + IID_IVMRSurface9 : TGUID = '{dfc581a1-6e1f-4c3a-8d0a-5e9792ea2afc}'; + {$EXTERNALSYM IID_IVMRSurface9} + + IID_IVMRSurfaceAllocator9 : TGUID = '{8d5148ea-3f5d-46cf-9df1-d1b896eedb1f}'; + {$EXTERNALSYM IID_IVMRSurfaceAllocator9} + IID_IVMRSurfaceAllocatorNotify9 : TGUID = '{dca3f5df-bb3a-4d03-bd81-84614bfbfa0c}'; + {$EXTERNALSYM IID_IVMRSurfaceAllocatorNotify9} + IID_IVMRImagePresenter9 : TGUID = '{69188c61-12a3-40f0-8ffc-342e7b433fd7}'; + {$EXTERNALSYM IID_IVMRImagePresenter9} + IID_IVMRImagePresenterConfig9 : TGUID = '{45c15cab-6e22-420a-8043-ae1f0ac02c7d}'; + {$EXTERNALSYM IID_IVMRImagePresenterConfig9} + IID_IVMRMonitorConfig9 : TGUID = '{46c2e457-8ba0-4eef-b80b-0680f0978749}'; + {$EXTERNALSYM IID_IVMRMonitorConfig9} + IID_IVMRWindowlessControl9 : TGUID = '{8f537d09-f85e-4414-b23b-502e54c79927}'; + {$EXTERNALSYM IID_IVMRWindowlessControl9} + + IID_IVMRMixerControl9 : TGUID = '{1a777eaa-47c8-4930-b2c9-8fee1c1b0f3b}'; + {$EXTERNALSYM IID_IVMRMixerControl9} + IID_IVMRImageCompositor9 : TGUID = '{4a5c89eb-df51-4654-ac2a-e48e02bbabf6}'; + {$EXTERNALSYM IID_IVMRImageCompositor9} + IID_IVMRMixerBitmap9 : TGUID = '{ced175e5-1935-4820-81bd-ff6ad00c9108}'; + {$EXTERNALSYM IID_IVMRMixerBitmap9} + + IID_IVMRFilterConfig9 : TGUID = '{5a804648-4f66-4867-9c43-4f5c822cf1b8}'; + {$EXTERNALSYM IID_IVMRFilterConfig9} + IID_IVMRAspectRatioControl9 : TGUID = '{00d96c29-bbde-4efc-9901-bb5036392146}'; + {$EXTERNALSYM IID_IVMRAspectRatioControl9} + IID_IVMRVideoStreamControl9 : TGUID = '{d0cfe38b-93e7-4772-8957-0400c49a4485}'; + {$EXTERNALSYM IID_IVMRVideoStreamControl9} + + IID_IVMRDeinterlaceControl9 : TGUID = '{a215fb8d-13c2-4f7f-993c-003d6271a459}'; + {$EXTERNALSYM IID_IVMRDeinterlaceControl9} + +/////////////////////////////////////////////////////////////////////////////// +// +// Allocator Presenter interfaces +// +/////////////////////////////////////////////////////////////////////////////// + + +//===================================================================== +// +// IVMRImagePresenter9 +// +//===================================================================== +type + VMR9PresentationFlags = {$IFDEF TYPE_IDENTITY}type {$ENDIF} LongWord; + {$EXTERNALSYM VMR9PresentationFlags} + const + VMR9Sample_SyncPoint = $00000001; + {$EXTERNALSYM VMR9Sample_SyncPoint} + VMR9Sample_Preroll = $00000002; + {$EXTERNALSYM VMR9Sample_Preroll} + VMR9Sample_Discontinuity = $00000004; + {$EXTERNALSYM VMR9Sample_Discontinuity} + VMR9Sample_TimeValid = $00000008; + {$EXTERNALSYM VMR9Sample_TimeValid} + VMR9Sample_SrcDstRectsValid = $00000010; + {$EXTERNALSYM VMR9Sample_SrcDstRectsValid} + + +type + PVMR9PresentationInfo = ^TVMR9PresentationInfo; + VMR9PresentationInfo = record + dwFlags : DWORD; + lpSurf : IDirect3DSurface9; + rtStart : TReferenceTime; + rtEnd : TReferenceTime; + szAspectRatio : TSIZE; + rcSrc : TRECT; + rcDst : TRECT; + dwReserved1 : DWORD; + dwReserved2 : DWORD; + end; + {$EXTERNALSYM VMR9PresentationInfo} + TVMR9PresentationInfo = VMR9PresentationInfo; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IVMRImagePresenter9;'} + {$EXTERNALSYM IVMRImagePresenter9} + IVMRImagePresenter9 = interface(IUnknown) + ['{69188c61-12a3-40f0-8ffc-342e7b433fd7}'] + (*** IVMRImagePresenter9 methods ***) + function StartPresenting(dwUserID: DWORD): HResult; stdcall; + function StopPresenting(dwUserID: DWORD): HResult; stdcall; + function PresentImage(dwUserID: DWORD; lpPresInfo: PVMR9PresentationInfo): HResult; stdcall; + end; + +//===================================================================== +// +// IVMRSurfaceAllocator +// +//===================================================================== + + VMR9SurfaceAllocationFlags = {$IFDEF TYPE_IDENTITY}type {$ENDIF} LongWord; + {$EXTERNALSYM VMR9SurfaceAllocationFlags} + const + // surface types/usage + VMR9AllocFlag_3DRenderTarget = $0001; + {$EXTERNALSYM VMR9AllocFlag_3DRenderTarget} + VMR9AllocFlag_DXVATarget = $0002; + {$EXTERNALSYM VMR9AllocFlag_DXVATarget} + // VMR9AllocFlag_TextureSurface can be combined with + // DXVATarget and 3DRenderTarget + VMR9AllocFlag_TextureSurface = $0004; + {$EXTERNALSYM VMR9AllocFlag_TextureSurface} + VMR9AllocFlag_OffscreenSurface = $0008; + {$EXTERNALSYM VMR9AllocFlag_OffscreenSurface} + VMR9AllocFlag_UsageReserved = $00F0; + {$EXTERNALSYM VMR9AllocFlag_UsageReserved} + VMR9AllocFlag_UsageMask = $00FF; + {$EXTERNALSYM VMR9AllocFlag_UsageMask} + +type + PVMR9AllocationInfo = ^TVMR9AllocationInfo; + _VMR9AllocationInfo = record + dwFlags : DWORD; // see VMR9SurfaceAllocationFlags + dwWidth : DWORD; + dwHeight : DWORD; + Format : TD3DFORMAT; // 0 means use a format compatible with the display + Pool : TD3DPOOL; + MinBuffers : DWORD; + szAspectRatio : TSIZE; + szNativeSize : TSIZE; + end; + {$EXTERNALSYM _VMR9AllocationInfo} + VMR9AllocationInfo = _VMR9AllocationInfo; + {$EXTERNALSYM VMR9AllocationInfo} + TVMR9AllocationInfo = _VMR9AllocationInfo; + + IVMRSurfaceAllocatorNotify9 = interface; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IVMRSurfaceAllocator9;'} + {$EXTERNALSYM IVMRSurfaceAllocator9} + IVMRSurfaceAllocator9 = interface(IUnknown) + ['{8d5148ea-3f5d-46cf-9df1-d1b896eedb1f}'] + (*** IVMRSurfaceAllocator9 methods ***) + function InitializeDevice(dwUserID: DWORD; lpAllocInfo: PVMR9AllocationInfo; + var lpNumBuffers: DWORD): HResult; stdcall; + function TerminateDevice(dwID: DWORD): HResult; stdcall; + function GetSurface(dwUserID: DWORD; SurfaceIndex: DWORD; SurfaceFlags: DWORD; + out lplpSurface: IDirect3DSurface9): HResult; stdcall; + function AdviseNotify(lpIVMRSurfAllocNotify: IVMRSurfaceAllocatorNotify9): HResult; stdcall; + end; + +//===================================================================== +// +// IVMRSurfaceAllocatorNotify9 +// +//===================================================================== + + {$HPPEMIT 'typedef System::DelphiInterface _di_IVMRSurfaceAllocatorNotify9;'} + {$EXTERNALSYM IVMRSurfaceAllocatorNotify9} + IVMRSurfaceAllocatorNotify9 = interface(IUnknown) + ['{dca3f5df-bb3a-4d03-bd81-84614bfbfa0c}'] + (*** IVMRSurfaceAllocatorNotify9 methods ***) + function AdviseSurfaceAllocator(dwUserID: DWORD; + lpIVRMSurfaceAllocator: IVMRSurfaceAllocator9): HResult; stdcall; + function SetD3DDevice(lpD3DDevice: IDirect3DDevice9; + hMonitor: HMONITOR): HResult; stdcall; + function ChangeD3DDevice(lpD3DDevice: IDirect3DDevice9; + hMonitor: HMONITOR): HResult; stdcall; + function AllocateSurfaceHelper(lpAllocInfo: PVMR9AllocationInfo; + var lpNumBuffers: DWORD; out lplpSurface: IDirect3DSurface9): HResult; stdcall; + function NotifyEvent(EventCode: LongInt; Param1, Param2: LongInt): HResult; stdcall; + end; + +/////////////////////////////////////////////////////////////////////////////// +// +// Application control and configuration interfaces +// +/////////////////////////////////////////////////////////////////////////////// + + +//===================================================================== +// +// IVMRWindowlessControl9 +// +//===================================================================== + VMR9AspectRatioMode= ( + VMR9ARMode_None, + VMR9ARMode_LetterBox + ); + {$EXTERNALSYM VMR9AspectRatioMode} + TVMR9AspectRatioMode = VMR9AspectRatioMode; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IVMRWindowlessControl9;'} + {$EXTERNALSYM IVMRWindowlessControl9} + IVMRWindowlessControl9 = interface(IUnknown) + ['{8f537d09-f85e-4414-b23b-502e54c79927}'] + (*** IVMRWindowlessControl9 methods ***) + ////////////////////////////////////////////////////////// + // Video size and position information + ////////////////////////////////////////////////////////// + function GetNativeVideoSize(out lpWidth, lpHeight, lpARWidth, lpARHeigh: LongInt): HResult; stdcall; + function GetMinIdealVideoSize(out lpWidth, lpHeight: LongInt): HResult; stdcall; + function GetMaxIdealVideoSize(out lpWidth, lpHeight: LongInt): HResult; stdcall; + function SetVideoPosition(lpSRCRect, lpDSTRect: PRECT): HResult; stdcall; + function GetVideoPosition(out lpSRCRect, lpDSTRect: TRECT): HResult; stdcall; + function GetAspectRatioMode(out lpAspectRatioMode: TVMR9AspectRatioMode): HResult; stdcall; + function SetAspectRatioMode(AspectRatioMode: TVMR9AspectRatioMode): HResult; stdcall; + + ////////////////////////////////////////////////////////// + // Display and clipping management + ////////////////////////////////////////////////////////// + function SetVideoClippingWindow(hwnd: HWND): HResult; stdcall; + function RepaintVideo(hwnd: HWND; hdc: HDC): HResult; stdcall; + function DisplayModeChanged: HResult; stdcall; + + ////////////////////////////////////////////////////////// + // GetCurrentImage + // + // Returns the current image being displayed. This images + // is returned in the form of packed Windows DIB. + // + // GetCurrentImage can be called at any time, also + // the caller is responsible for free the returned memory + // by calling CoTaskMemFree. + // + // Excessive use of this function will degrade video + // playback performed. + ////////////////////////////////////////////////////////// + function GetCurrentImage(out lpDib: PBYTE): HResult; stdcall; + + ////////////////////////////////////////////////////////// + // Border Color control + // + // The border color is color used to fill any area of the + // the destination rectangle that does not contain video. + // It is typically used in two instances. When the video + // straddles two monitors and when the VMR is trying + // to maintain the aspect ratio of the movies by letter + // boxing the video to fit within the specified destination + // rectangle. See SetAspectRatioMode above. + ////////////////////////////////////////////////////////// + function SetBorderColor(Clr: COLORREF): HResult; stdcall; + function GetBorderColor(out lpClr: COLORREF): HResult; stdcall; + end; + +//===================================================================== +// +// IVMRMixerControl9 +// +//===================================================================== + + VMR9MixerPrefs = {$IFDEF TYPE_IDENTITY}type {$ENDIF} LongWord; + {$EXTERNALSYM VMR9MixerPrefs} + const + MixerPref9_NoDecimation = $00000001; // No decimation - full size + {$EXTERNALSYM MixerPref9_NoDecimation} + MixerPref9_DecimateOutput = $00000002; // decimate output by 2 in x & y + {$EXTERNALSYM MixerPref9_DecimateOutput} + MixerPref9_ARAdjustXorY = $00000004; // adjust the aspect ratio in x or y + {$EXTERNALSYM MixerPref9_ARAdjustXorY} + MixerPref9_NonSquareMixing = $00000008; // assume AP can handle non-square mixing, avoids intermediate scales + {$EXTERNALSYM MixerPref9_NonSquareMixing} + MixerPref9_DecimateMask = $0000000F; + {$EXTERNALSYM MixerPref9_DecimateMask} + + MixerPref9_BiLinearFiltering = $00000010; // use bi-linear filtering + {$EXTERNALSYM MixerPref9_BiLinearFiltering} + MixerPref9_PointFiltering = $00000020; // use point filtering + {$EXTERNALSYM MixerPref9_PointFiltering} + MixerPref9_AnisotropicFiltering = $00000040; // + {$EXTERNALSYM MixerPref9_AnisotropicFiltering} + MixerPref9_PyramidalQuadFiltering = $00000080; // 4-sample tent + {$EXTERNALSYM MixerPref9_PyramidalQuadFiltering} + MixerPref9_GaussianQuadFiltering = $00000100; // 4-sample gaussian + {$EXTERNALSYM MixerPref9_GaussianQuadFiltering} + MixerPref9_FilteringReserved = $00000E00; // bits reserved for future use. + {$EXTERNALSYM MixerPref9_FilteringReserved} + MixerPref9_FilteringMask = $00000FF0; // OR of all above flags + {$EXTERNALSYM MixerPref9_FilteringMask} + + MixerPref9_RenderTargetRGB = $00001000; + {$EXTERNALSYM MixerPref9_RenderTargetRGB} + MixerPref9_RenderTargetYUV = $00002000; // Uses DXVA to perform mixing + {$EXTERNALSYM MixerPref9_RenderTargetYUV} + MixerPref9_RenderTargetReserved = $000FC000; // bits reserved for future use. + {$EXTERNALSYM MixerPref9_RenderTargetReserved} + MixerPref9_RenderTargetMask = $000FF000; // OR of all above flags + {$EXTERNALSYM MixerPref9_RenderTargetMask} + + // + // Dynamic changes that can be performed when the VMR's mixer is + // configured to use the YUV Render target (see MixerPref_RenderTargetYUV) + // These preferences can be applied while the graph is running and take effect + // when the next frame is composed by the mixer. + // + MixerPref9_DynamicSwitchToBOB = $00100000; + {$EXTERNALSYM MixerPref9_DynamicSwitchToBOB} + MixerPref9_DynamicDecimateBy2 = $00200000; + {$EXTERNALSYM MixerPref9_DynamicDecimateBy2} + + MixerPref9_DynamicReserved = $00C00000; + {$EXTERNALSYM MixerPref9_DynamicReserved} + MixerPref9_DynamicMask = $00F00000; + {$EXTERNALSYM MixerPref9_DynamicMask} + + +type +// Normalized relative rectangle +// Coordinate ranges: x=[0...1) y=[0...1) +// Where the output window goes from 0,0 (closed inclusive lower bound) +// to 1,1 (open exclusive upper bound) + + PVMR9NormalizedRect = ^TVMR9NormalizedRect; + _VMR9NormalizedRect = record + left : Single; + top : Single; + right : Single; + bottom : Single; + end; + {$EXTERNALSYM _VMR9NormalizedRect} + VMR9NormalizedRect = _VMR9NormalizedRect; + {$EXTERNALSYM VMR9NormalizedRect} + TVMR9NormalizedRect = _VMR9NormalizedRect; + + VMR9ProcAmpControlFlags = {$IFDEF TYPE_IDENTITY}type {$ENDIF} LongWord; + {$EXTERNALSYM VMR9ProcAmpControlFlags} + const + ProcAmpControl9_Brightness = $00000001; + {$EXTERNALSYM ProcAmpControl9_Brightness} + ProcAmpControl9_Contrast = $00000002; + {$EXTERNALSYM ProcAmpControl9_Contrast} + ProcAmpControl9_Hue = $00000004; + {$EXTERNALSYM ProcAmpControl9_Hue} + ProcAmpControl9_Saturation = $00000008; + {$EXTERNALSYM ProcAmpControl9_Saturation} + ProcAmpControl9_Mask = $0000000F; + {$EXTERNALSYM ProcAmpControl9_Mask} + +type + PVMR9ProcAmpControl = ^TVMR9ProcAmpControl; + _VMR9ProcAmpControl = record + dwSize : DWORD; + dwFlags : DWORD; + Brightness : Single; + Contrast : Single; + Hue : Single; + Saturation : Single; + end; + {$EXTERNALSYM _VMR9ProcAmpControl} + VMR9ProcAmpControl = _VMR9ProcAmpControl; + {$EXTERNALSYM VMR9ProcAmpControl} + TVMR9ProcAmpControl = _VMR9ProcAmpControl; + + PVMR9ProcAmpControlRange = ^TVMR9ProcAmpControlRange; + _VMR9ProcAmpControlRange = record + dwSize : DWORD; + dwProperty : VMR9ProcAmpControlFlags; // see VMR9ProcAmpControlFlags above; + MinValue : Single; + MaxValue : Single; + DefaultValue : Single; + StepSize : Single; + end; + {$EXTERNALSYM _VMR9ProcAmpControlRange} + VMR9ProcAmpControlRange = _VMR9ProcAmpControlRange; + {$EXTERNALSYM VMR9ProcAmpControlRange} + TVMR9ProcAmpControlRange = _VMR9ProcAmpControlRange; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IVMRMixerControl9;'} + {$EXTERNALSYM IVMRMixerControl9} + IVMRMixerControl9 = interface(IUnknown) + ['{1a777eaa-47c8-4930-b2c9-8fee1c1b0f3b}'] + (*** IVMRMixerControl9 methods ***) + // Source alpha premultication factor (global alpha for source) + function SetAlpha(dwStreamID: DWORD; Alpha: Single): HResult; stdcall; + function GetAlpha(dwStreamID: DWORD; out pAlpha: Single): HResult; stdcall; + function SetZOrder(dwStreamID: DWORD; dwZ: DWORD): HResult; stdcall; + function GetZOrder(dwStreamID: DWORD; out pZ: DWORD): HResult; stdcall; + function SetOutputRect(dwStreamID: DWORD; pRect: PVMR9NormalizedRect): HResult; stdcall; + function GetOutputRect(dwStreamID: DWORD; {out} pRect: PVMR9NormalizedRect): HResult; stdcall; + function SetBackgroundClr(ClrBkg: COLORREF): HResult; stdcall; + function GetBackgroundClr(out lpClrBkg: COLORREF): HResult; stdcall; + // a combination of VMRMixingPrefFlags + function SetMixingPrefs(dwMixerPrefs: DWORD): HResult; stdcall; + function GetMixingPrefs(out pdwMixerPrefs: DWORD): HResult; stdcall; + function SetProcAmpControl(dwStreamID: DWORD; lpClrControl: PVMR9ProcAmpControl): HResult; stdcall; + function GetProcAmpControl(dwStreamID: DWORD; {in/out} lpClrControl: PVMR9ProcAmpControl): HResult; stdcall; + function GetProcAmpControlRange(dwStreamID: DWORD; {in/out} lpClrControl: PVMR9ProcAmpControlRange): HResult; stdcall; + end; + + +//===================================================================== +// +// IVMRMixerBitmap9 +// +//===================================================================== + + PVMR9AlphaBitmap = ^TVMR9AlphaBitmap; + _VMR9AlphaBitmap = record + dwFlags : DWORD; // flags word + hdc : HDC; // DC for the bitmap to copy + pDDS : IDirect3DSurface9; // D3D surface to copy + rSrc : TRECT; // rectangle to copy from the DC/DDS + rDest : TVMR9NormalizedRect; // output rectangle in composition space + fAlpha : Single; // opacity of the bitmap + clrSrcKey : COLORREF; // src color key + dwFilterMode : DWORD; // See "SetMixerPrefs" + end; + {$EXTERNALSYM _VMR9AlphaBitmap} + VMR9AlphaBitmap = _VMR9AlphaBitmap; + {$EXTERNALSYM VMR9AlphaBitmap} + TVMR9AlphaBitmap = _VMR9AlphaBitmap; + + VMR9AlphaBitmapFlags = {$IFDEF TYPE_IDENTITY}type {$ENDIF} LongWord; + {$EXTERNALSYM VMR9AlphaBitmapFlags} + const + // Disable the alpha bitmap for now + VMR9AlphaBitmap_Disable = $00000001; + {$EXTERNALSYM VMR9AlphaBitmap_Disable} + + // Take the bitmap from the HDC rather than the DirectDraw surface + VMR9AlphaBitmap_hDC = $00000002; + {$EXTERNALSYM VMR9AlphaBitmap_hDC} + + // Take the entire DDraw surface - rSrc is ignored + VMR9AlphaBitmap_EntireDDS = $00000004; + {$EXTERNALSYM VMR9AlphaBitmap_EntireDDS} + + // Indicates that the clrTrans value is valid and should be + // used when blending + VMR9AlphaBitmap_SrcColorKey = $00000008; + {$EXTERNALSYM VMR9AlphaBitmap_SrcColorKey} + + // Indicates that the rSrc rectangle is valid and specifies a + // sub-rectangle of the of original app image to be blended. + // Use of this parameter enables "Image Strips" + VMR9AlphaBitmap_SrcRect = $00000010; + {$EXTERNALSYM VMR9AlphaBitmap_SrcRect} + + // Indicates that dwFilterMode parameter is valid and should be + // used to overide the default filtering method used by the VMR. + // MixerPref_PointFiltering is particulaly useful for images that + // contain text and do not need to be stretch prior to blending with + // the video content. + VMR9AlphaBitmap_FilterMode = $00000020; + {$EXTERNALSYM VMR9AlphaBitmap_FilterMode} + +type + {$HPPEMIT 'typedef System::DelphiInterface _di_IVMRMixerBitmap9;'} + {$EXTERNALSYM IVMRMixerBitmap9} + IVMRMixerBitmap9 = interface(IUnknown) + ['{ced175e5-1935-4820-81bd-ff6ad00c9108}'] + (*** IVMRMixerBitmap9 methods ***) + // Set bitmap, location to blend it, and blending value + function SetAlphaBitmap(pBmpParms: PVMR9AlphaBitmap): HResult; stdcall; + + // Change bitmap location, size and blending value, + // graph must be running for change to take effect. + function UpdateAlphaBitmapParameters(pBmpParms: PVMR9AlphaBitmap): HResult; stdcall; + + // Get bitmap, location to blend it, and blending value + function GetAlphaBitmapParameters(out pBmpParms: TVMR9AlphaBitmap): HResult; stdcall; + end; + +//===================================================================== +// +// IVMRSurface9 +// +//===================================================================== + + {$HPPEMIT 'typedef System::DelphiInterface _di_IVMRSurface9;'} + {$EXTERNALSYM IVMRSurface9} + IVMRSurface9 = interface(IUnknown) + ['{dfc581a1-6e1f-4c3a-8d0a-5e9792ea2afc}'] + (*** IVMRSurface9 methods ***) + function IsSurfaceLocked: HResult; stdcall; + function LockSurface(out lpSurface: PBYTE): HResult; stdcall; + function UnlockSurface: HResult; stdcall; + function GetSurface(out lplpSurface: IDirect3DSurface9): HResult; stdcall; + end; + +//===================================================================== +// +// IID_IVMRImagePresenterConfig9 - this interface allows applications +// to configure the default Microsoft provided allocator-presenter +// inorder to simplify the implementation of their own +// allocator-presenter plug-in. +// +//===================================================================== + VMR9RenderPrefs = {$IFDEF TYPE_IDENTITY}type {$ENDIF} LongWord; + {$EXTERNALSYM VMR9RenderPrefs} + const + RenderPrefs9_DoNotRenderBorder = $00000001; // app paints color keys + {$EXTERNALSYM RenderPrefs9_DoNotRenderBorder} + RenderPrefs9_Mask = $00000001; // OR of all above flags + {$EXTERNALSYM RenderPrefs9_Mask} + +type + {$HPPEMIT 'typedef System::DelphiInterface _di_IVMRImagePresenterConfig9;'} + {$EXTERNALSYM IVMRImagePresenterConfig9} + IVMRImagePresenterConfig9 = interface(IUnknown) + ['{45c15cab-6e22-420a-8043-ae1f0ac02c7d}'] + (*** IVMRImagePresenterConfig9 methods ***) + function SetRenderingPrefs(dwRenderFlags: DWORD): HResult; stdcall; + function GetRenderingPrefs(out dwRenderFlags: DWORD): HResult; stdcall; + end; + +//===================================================================== +// +// IVMRDeinterlaceControl +// +// New interfaced introduced into the WindowsXP SP1 release of the VMR. +// This interface allows applications to control the DX-VA deinterlacing +// support provided by the VMR. +// +// The VMR needs to be set into "mixing" mode for this interface to work. +// +// SetDeinterlaceMode is only effective for new connections made to the +// VMR. It should be noted that the graphics device driver may refuse +// to use the specified deinterlace mode, in which case 3 fallback +// policies are offered by the VMR, these being: +// +// 1. Fallback to the next best mode offered by the driver. +// 2. Fallback to the BOB deinterlace mode. +// 3. Fallback to the WEAVE deinterlace mode (ie. turn deinterlacing off). +// +//===================================================================== + + VMR9DeinterlacePrefs = {$IFDEF TYPE_IDENTITY}type {$ENDIF} LongWord; + {$EXTERNALSYM VMR9DeinterlacePrefs} + const + DeinterlacePref9_NextBest = $01; + {$EXTERNALSYM DeinterlacePref9_NextBest} + DeinterlacePref9_BOB = $02; + {$EXTERNALSYM DeinterlacePref9_BOB} + DeinterlacePref9_Weave = $04; + {$EXTERNALSYM DeinterlacePref9_Weave} + DeinterlacePref9_Mask = $07; + {$EXTERNALSYM DeinterlacePref9_Mask} + +type + VMR9DeinterlaceTech = {$IFDEF TYPE_IDENTITY}type {$ENDIF} LongWord; + {$EXTERNALSYM VMR9DeinterlaceTech} + const + // the algorithm is unknown or proprietary + DeinterlaceTech9_Unknown = $0000; + {$EXTERNALSYM DeinterlaceTech9_Unknown} + + // the algorithm creates the missing lines by repeating + // the line either above or below it - this method will look very jaggy and + // isn't recommended + DeinterlaceTech9_BOBLineReplicate = $0001; + {$EXTERNALSYM DeinterlaceTech9_BOBLineReplicate} + + + // the algorithm creates the missing lines by vertically stretching each + // video field by a factor of two, for example by averaging two lines or + // using a [-1, 9, 9, -1]/16 filter across four lines. + // Slight vertical adjustments are made to ensure that the resulting image + // does not "bob" up and down. + DeinterlaceTech9_BOBVerticalStretch = $0002; + {$EXTERNALSYM DeinterlaceTech9_BOBVerticalStretch} + + // the pixels in the missing line are recreated by a median filtering operation + DeinterlaceTech9_MedianFiltering = $0004; + {$EXTERNALSYM DeinterlaceTech9_MedianFiltering} + + // the pixels in the missing line are recreated by an edge filter. + // In this process, spatial directional filters are applied to determine + // the orientation of edges in the picture content, and missing + // pixels are created by filtering along (rather than across) the + // detected edges. + DeinterlaceTech9_EdgeFiltering = $0010; + {$EXTERNALSYM DeinterlaceTech9_EdgeFiltering} + + // the pixels in the missing line are recreated by switching on a field by + // field basis between using either spatial or temporal interpolation + // depending on the amount of motion. + DeinterlaceTech9_FieldAdaptive = $0020; + {$EXTERNALSYM DeinterlaceTech9_FieldAdaptive} + + // the pixels in the missing line are recreated by switching on a pixel by pixel + // basis between using either spatial or temporal interpolation depending on + // the amount of motion.. + DeinterlaceTech9_PixelAdaptive = $0040; + {$EXTERNALSYM DeinterlaceTech9_PixelAdaptive} + + // Motion Vector Steering identifies objects within a sequence of video + // fields. The missing pixels are recreated after first aligning the + // movement axes of the individual objects in the scene to make them + // parallel with the time axis. + DeinterlaceTech9_MotionVectorSteered = $0080; + {$EXTERNALSYM DeinterlaceTech9_MotionVectorSteered} + +type + PVMR9Frequency = ^TVMR9Frequency; + _VMR9Frequency = record + dwNumerator : DWORD; + dwDenominator : DWORD; + end; + {$EXTERNALSYM _VMR9Frequency} + VMR9Frequency = _VMR9Frequency; + {$EXTERNALSYM VMR9Frequency} + TVMR9Frequency = _VMR9Frequency; + + _VMR9_SampleFormat = ( + {$IFNDEF COMPILER6_UP} + VMR9_Sample_INVALID_0, + VMR9_SampleReserved, + {$ELSE} + VMR9_SampleReserved = 1, + {$ENDIF} + VMR9_SampleProgressiveFrame, + VMR9_SampleFieldInterleavedEvenFirst, + VMR9_SampleFieldInterleavedOddFirst, + VMR9_SampleFieldSingleEven, + VMR9_SampleFieldSingleOdd + ); + {$EXTERNALSYM _VMR9_SampleFormat} + VMR9_SampleFormat = _VMR9_SampleFormat; + {$EXTERNALSYM VMR9_SampleFormat} + TVMR9SampleFormat = _VMR9_SampleFormat; + + PVMR9VideoDesc = ^TVMR9VideoDesc; + _VMR9VideoDesc = record + dwSize : DWORD; + dwSampleWidth : DWORD; + dwSampleHeight : DWORD; + SampleFormat : TVMR9SampleFormat; + dwFourCC : DWORD; + InputSampleFreq : TVMR9Frequency; + OutputFrameFreq : TVMR9Frequency; + end; + {$EXTERNALSYM _VMR9VideoDesc} + VMR9VideoDesc = _VMR9VideoDesc; + {$EXTERNALSYM VMR9VideoDesc} + TVMR9VideoDesc = _VMR9VideoDesc; + + PVMR9DeinterlaceCaps = ^TVMR9DeinterlaceCaps; + _VMR9DeinterlaceCaps = record + dwSize : DWORD; + dwNumPreviousOutputFrames : DWORD; + dwNumForwardRefSamples : DWORD; + dwNumBackwardRefSamples : DWORD; + DeinterlaceTechnology : VMR9DeinterlaceTech; + end; + {$EXTERNALSYM _VMR9DeinterlaceCaps} + VMR9DeinterlaceCaps = _VMR9DeinterlaceCaps; + {$EXTERNALSYM VMR9DeinterlaceCaps} + TVMR9DeinterlaceCaps = _VMR9DeinterlaceCaps; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IVMRDeinterlaceControl9;'} + {$EXTERNALSYM IVMRDeinterlaceControl9} + IVMRDeinterlaceControl9 = interface(IUnknown) + ['{a215fb8d-13c2-4f7f-993c-003d6271a459}'] + (*** IVMRDeinterlaceControl9 methods ***) + // For the specified video description returns the + // number of deinterlacing modes available to the VMR. + // The deinterlacing modes are returned in descending + // quality order ie. the best quality mode is at + // lpdwNumDeinterlaceModes[0], the next best at + // lpdwNumDeinterlaceModes[1] and so on. + // + // To determine how big an array of guids to pass to the + // GetNumberOfDeinterlaceModes method call + // GetNumberOfDeinterlaceModes(lpVideoDescription, &dwNumModes, NULL); + // + function GetNumberOfDeinterlaceModes(out lpVideoDescription: TVMR9VideoDesc; + var lpdwNumDeinterlaceModes: DWORD; lpDeinterlaceModes: PGUID): HResult; stdcall; + + // For the given video description get the capabilities of the + // specified de-interlace mode. + function GetDeinterlaceModeCaps(const lpDeinterlaceMode: TGUID; + lpVideoDescription: PVMR9VideoDesc; + out lpDeinterlaceCaps: TVMR9DeinterlaceCaps): HResult; stdcall; + + // Get/Set the deinterlace mode that you would like the + // VMR to use when de-interlacing the specified stream. + // It should be noted that the VMR may not actually be able + // to use the requested deinterlace mode, in which case the + // the VMR will fall back to other de-interlace modes as specified + // by the de-interlace preferences (see SetDeinterlacePrefs below). + + function GetDeinterlaceMode(dwStreamID: DWORD; + out lpDeinterlaceMode: TGUID // returns GUID_NULL if SetDeinterlaceMode + ): HResult; stdcall; // has not been called yet. + + function SetDeinterlaceMode( + dwStreamID: DWORD; // use 0xFFFFFFFF to set mode for all streams + const lpDeinterlaceMode: TGUID // GUID_NULL == turn deinterlacing off + ): HResult; stdcall; + + function GetDeinterlacePrefs(out lpdwDeinterlacePrefs: DWORD): HResult; stdcall; + + function SetDeinterlacePrefs(dwDeinterlacePrefs: DWORD): HResult; stdcall; + + // Get the DeinterlaceMode currently in use for the specified + // video stream (ie. pin). The returned GUID will be NULL if + // the de-interlacing h/w has not been created by the VMR at the + // time the function is called, or if the VMR determines that + // this stream should not or can be de-interlaced. + function GetActualDeinterlaceMode(dwStreamID: DWORD; + out lpDeinterlaceMode: TGUID): HResult; stdcall; + end; + +//===================================================================== +// +// IVMRImageCompositor9 +// +//===================================================================== + PVMR9VideoStreamInfo = ^TVMR9VideoStreamInfo; + _VMR9VideoStreamInfo = record + pddsVideoSurface : IDirect3DSurface9; + dwWidth, dwHeight : DWORD; + dwStrmID : DWORD; + fAlpha : Single; + rNormal : TVMR9NormalizedRect; + rtStart : TReferenceTime; + rtEnd : TReferenceTime; + SampleFormat : TVMR9SampleFormat; + end; + {$EXTERNALSYM _VMR9VideoStreamInfo} + VMR9VideoStreamInfo = _VMR9VideoStreamInfo; + {$EXTERNALSYM VMR9VideoStreamInfo} + TVMR9VideoStreamInfo = _VMR9VideoStreamInfo; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IVMRImageCompositor9;'} + {$EXTERNALSYM IVMRImageCompositor9} + IVMRImageCompositor9 = interface(IUnknown) + ['{4a5c89eb-df51-4654-ac2a-e48e02bbabf6}'] + (*** IVMRImageCompositor9 methods ***) + function InitCompositionDevice(pD3DDevice: IUnknown): HResult; stdcall; + function TermCompositionDevice(pD3DDevice: IUnknown): HResult; stdcall; + function SetStreamMediaType(dwStrmID: DWORD; pmt: PAMMediaType; + fTexture: BOOL): HResult; stdcall; + function CompositeImage(pD3DDevice: IUnknown; pddsRenderTarget: IDirect3DSurface9; + pmtRenderTarget: PAMMediaType; rtStart, rtEnd: TReferenceTime; + dwClrBkGnd: TD3DCOLOR; pVideoStreamInfo: PVMR9VideoStreamInfo; + cStreams: UINT): HResult; stdcall; + end; + +//===================================================================== +// +// IVMRVideoStreamControl9 +// +//===================================================================== + + {$HPPEMIT 'typedef System::DelphiInterface _di_IVMRVideoStreamControl9;'} + {$EXTERNALSYM IVMRVideoStreamControl9} + IVMRVideoStreamControl9 = interface(IUnknown) + ['{d0cfe38b-93e7-4772-8957-0400c49a4485}'] + (*** IVMRVideoStreamControl9 methods ***) + function SetStreamActiveState(fActive: BOOL): HResult; stdcall; + function GetStreamActiveState(out lpfActive: BOOL): HResult; stdcall; + end; + + VMR9Mode = {$IFDEF TYPE_IDENTITY}type {$ENDIF} LongWord; + {$EXTERNALSYM VMR9Mode} + const + VMR9Mode_Windowed = $00000001; + {$EXTERNALSYM VMR9Mode_Windowed} + VMR9Mode_Windowless = $00000002; + {$EXTERNALSYM VMR9Mode_Windowless} + VMR9Mode_Renderless = $00000004; + {$EXTERNALSYM VMR9Mode_Renderless} + // not a valid value to pass to SetRenderMode + VMR9Mode_Mask = $00000007; // OR of all above flags + {$EXTERNALSYM VMR9Mode_Mask} + +type + {$HPPEMIT 'typedef System::DelphiInterface _di_IVMRFilterConfig9;'} + {$EXTERNALSYM IVMRFilterConfig9} + IVMRFilterConfig9 = interface(IUnknown) + ['{5a804648-4f66-4867-9c43-4f5c822cf1b8}'] + (*** IVMRFilterConfig9 methods ***) + function SetImageCompositor(lpVMRImgCompositor: IVMRImageCompositor9): HResult; stdcall; + function SetNumberOfStreams(dwMaxStreams: DWORD): HResult; stdcall; + function GetNumberOfStreams(out pdwMaxStreams: DWORD): HResult; stdcall; + function SetRenderingPrefs(dwRenderFlags: DWORD): HResult; stdcall; + function GetRenderingPrefs(out pdwRenderFlags: DWORD): HResult; stdcall; + function SetRenderingMode(Mode: DWORD): HResult; stdcall; + function GetRenderingMode(out pMode: DWORD): HResult; stdcall; + end; + +//===================================================================== +// +// IVMRAspectRatioControl9 +// +//===================================================================== + + {$HPPEMIT 'typedef System::DelphiInterface _di_IVMRAspectRatioControl9;'} + {$EXTERNALSYM IVMRAspectRatioControl9} + IVMRAspectRatioControl9 = interface(IUnknown) + ['{00d96c29-bbde-4efc-9901-bb5036392146}'] + (*** IVMRAspectRatioControl9 methods ***) + function GetAspectRatioMode(out lpdwARMode: TVMRAspectRatioMode): HResult; stdcall; + function SetAspectRatioMode(dwARMode: TVMRAspectRatioMode): HResult; stdcall; + end; + +/////////////////////////////////////////////////////////////////////////////// +// +// VMR Multimon configuration interface +// +/////////////////////////////////////////////////////////////////////////////// +const + VMR9DEVICENAMELEN = 32; + {$EXTERNALSYM VMR9DEVICENAMELEN} + VMR9DEVICEDESCRIPTIONLEN = 512; + {$EXTERNALSYM VMR9DEVICEDESCRIPTIONLEN} + +type + PVMR9MonitorInfo = ^TVMR9MonitorInfo; + _VMR9MonitorInfo = record + uDevID : UINT; + rcMonitor : TRECT; + hMon : HMONITOR; + dwFlags : DWORD; // described in MONITORINFOEX, currently only MONITORINFOF_PRIMARY + szDevice: array[0..VMR9DEVICENAMELEN-1]of WideChar; + szDescription: array[0..VMR9DEVICEDESCRIPTIONLEN-1] of WideChar; + liDriverVersion : LARGE_INTEGER; + dwVendorId : DWORD; + dwDeviceId : DWORD; + dwSubSysId : DWORD; + dwRevision : DWORD; + end; + {$EXTERNALSYM _VMR9MonitorInfo} + VMR9MonitorInfo = _VMR9MonitorInfo; + {$EXTERNALSYM VMR9MonitorInfo} + TVMR9MonitorInfo = _VMR9MonitorInfo; + + {$HPPEMIT 'typedef System::DelphiInterface _di_IVMRMonitorConfig9;'} + {$EXTERNALSYM IVMRMonitorConfig9} + IVMRMonitorConfig9 = interface(IUnknown) + ['{46c2e457-8ba0-4eef-b80b-0680f0978749}'] + (*** IVMRMonitorConfig9 methods ***) + // Use this method on a Multi-Monitor system to specify to the + // mixer filter which Direct Draw driver should be used when connecting + // to an upstream decoder filter. + function SetMonitor(uDev: UINT): HResult; stdcall; + + // Use this method to determine the direct draw object that will be used when + // connecting the mixer filter to an upstream decoder filter. + function GetMonitor(out puDev: UINT): HResult; stdcall; + + // Use this method on a multi-monitor system to specify to the + // mixer filter the default Direct Draw device to use when + // connecting to an upstream filter. The default direct draw device + // can be overriden for a particular connection by SetMonitor method + // described above. + function SetDefaultMonitor(uDev: UINT): HResult; stdcall; + + // Use this method on a multi-monitor system to determine which + // is the default direct draw device the overlay mixer filter + // will use when connecting to an upstream filter. + function GetDefaultMonitor(out puDev: UINT): HResult; stdcall; + + // Use this method to get a list of Direct Draw device GUIDs and thier + // associated monitor information that the mixer can use when + // connecting to an upstream decoder filter. Passing down a NULL pInfo + // parameter allows the app to determine the required array size (returned + // in pdwNumDevices). Otherwise, dwNumDevices returns the actual + // number of devices retrieved. + function GetAvailableMonitors( + {out} pInfo: PVMR9MonitorInfo; + dwMaxInfoArraySize: DWORD; // in array members + out pdwNumDevices: DWORD // actual number of devices retrieved + ): HResult; stdcall; + end; + + +//------------------------------------------------------------------------------ +// File: DMOImpl.h +// +// Desc: Classes to implement a DMO. +// +// Copyright (c) 2000, Microsoft Corporation. All rights reserved. +//------------------------------------------------------------------------------ +{$IFDEF DELPHI4_UP} +type + TMOinplIOInfo = record + fTypeSet : DWORD; //:1; + fIncomplete : DWORD; //:1; + CurrentMediaType: TDMOMediaType; + end; + +// Class to implement a DMO +// +// +// Assumes the number of input and output streams is fixed +// (these are template parameters) +// +// Provides following services: +// +// Basic parameter checking and locking +// Fully implements : +// GetStreamCount +// SetInputType +// SetOutputType +// GetCurrentInputType +// GetCurrentOutputType +// +// Checks if all types are set before streaming +// Automatically calls AllocateStreamingResources before streaming +// if it's not been called already +// Prevents streaming until the types on all non-optional streams +// have been set +// +// +// Derived class implements the following methods : +// +{ + HResult InternalGetInputStreamInfo(DWORD dwInputStreamIndex, DWORD *pdwFlags); + HResult InternalGetOutputStreamInfo(DWORD dwOutputStreamIndex, DWORD *pdwFlags); + HResult InternalCheckInputType(DWORD dwInputStreamIndex, const DMO_MEDIA_TYPE *pmt); + HResult InternalCheckOutputType(DWORD dwOutputStreamIndex, const DMO_MEDIA_TYPE *pmt); + HResult InternalGetInputType(DWORD dwInputStreamIndex, DWORD dwTypeIndex, + DMO_MEDIA_TYPE *pmt); + HResult InternalGetOutputType(DWORD dwOutputStreamIndex, DWORD dwTypeIndex, + DMO_MEDIA_TYPE *pmt); + HResult InternalGetInputSizeInfo(DWORD dwInputStreamIndex, DWORD *pcbSize, + DWORD *pcbMaxLookahead, DWORD *pcbAlignment); + HResult InternalGetOutputSizeInfo(DWORD dwOutputStreamIndex, DWORD *pcbSize, + DWORD *pcbAlignment); + HResult InternalGetInputMaxLatency(DWORD dwInputStreamIndex, REFERENCE_TIME *prtMaxLatency); + HResult InternalSetInputMaxLatency(DWORD dwInputStreamIndex, REFERENCE_TIME rtMaxLatency); + HResult InternalFlush(); + HResult InternalDiscontinuity(DWORD dwInputStreamIndex); + HResult InternalAllocateStreamingResources(); + HResult InternalFreeStreamingResources(); + HResult InternalProcessInput(DWORD dwInputStreamIndex, IMediaBuffer *pBuffer, + DWORD dwFlags, REFERENCE_TIME rtTimestamp, + REFERENCE_TIME rtTimelength); + HResult InternalProcessOutput(DWORD dwFlags, DWORD cOutputBufferCount, + DMO_OUTPUT_DATA_BUFFER *pOutputBuffers, + DWORD *pdwStatus); + HResult InternalAcceptingInput(DWORD dwInputStreamIndex); + void Lock(); + void Unlock(); + + Notes: + The derived class is meant to do most work to initialize streaming + in AllocateStreamingResources rather than when types are set. + + This centralizes the work to one + clear place based on the types set for all streams. + + The derived class implements locking. + + The derived class implements the IUnknown methods + + Usage example (1 input and 1 output) : + class CMyDMO : public IMediaObjectImpl, + ... +} + +////////////////////////////////////////////////////////////////////// +///// Translator comments ///// +////////////////////////////////////////////////////////////////////// +{ + Delphi class tries to follow C++ template class as much as possible. + But in addition to original C++ template it's already implements + multi-threading support due to: + 1) AddRef, Release - realized as thread safe in TComObject + 2) Lock(), Unlock() - uses critical section. + + If you do not need support for thread-safe processing you can save some + system resources by not calling Windows functions (InterlockedInclerent, + InterlockedDecrement, EnterCriticalSection, LeaveCriticalSection). This + can be don by overriding these funtions in derived class: + ObjAddRef, ObjRelease, Lock(), Unlock() +} + + TMediaObjectImpl = class(TComObject, IMediaObject) + private + m_fTypesSet : Boolean; + m_fFlushed : Boolean; + m_fResourcesAllocated: Boolean; + // Syncronizing + fCritSection: TCriticalSection; + protected + // init this variables !! + NUMBEROFINPUTS : DWORD; + NUMBEROFOUTPUTS : DWORD; + // Member variables + m_InputInfo : array of TMOinplIOInfo;// [0..NUMBEROFINPUTS-1] + m_OutputInfo : array of TMOinplIOInfo;// [0..NUMBEROFOUTPUTS-1] + // Implement these functions !!! + function InternalGetInputStreamInfo(dwInputStreamIndex: DWORD; out pdwFlags: DWORD): HResult; virtual; abstract; + function InternalGetOutputStreamInfo(dwOutputStreamIndex: DWORD; out pdwFlags: DWORD): HResult; virtual; abstract; + function InternalCheckInputType(dwInputStreamIndex: DWORD; const pmt: PDMOMediaType): HResult; virtual; abstract; + function InternalCheckOutputType(dwOutputStreamIndex: DWORD; const pmt: PDMOMediaType): HResult; virtual; abstract; + function InternalGetInputType(dwInputStreamIndex, dwTypeIndex: DWORD; out pmt: TDMOMediaType): HResult; virtual; abstract; + function InternalGetOutputType(dwOutputStreamIndex, dwTypeIndex:DWORD; out pmt: TDMOMediaType): HResult; virtual; abstract; + function InternalGetInputSizeInfo(dwInputStreamIndex: DWORD; out pcbSize, pcbMaxLookahead, pcbAlignment: DWORD): HResult; virtual; abstract; + function InternalGetOutputSizeInfo(dwOutputStreamIndex: DWORD; out pcbSize, pcbAlignment: DWORD): HResult; virtual; abstract; + function InternalGetInputMaxLatency(dwInputStreamIndex: DWORD; out prtMaxLatency: TReferenceTime): HResult; virtual; abstract; + function InternalSetInputMaxLatency(dwInputStreamIndex: DWORD; rtMaxLatency: TReferenceTime): HResult; virtual; abstract; + function InternalFlush: HResult; virtual; abstract; + function InternalDiscontinuity(dwInputStreamIndex: DWORD): HResult; virtual; abstract; + function InternalAllocateStreamingResources: HResult; virtual; abstract; + function InternalFreeStreamingResources: HResult; virtual; abstract; + function InternalProcessInput(dwInputStreamIndex: DWORD; pBuffer: IMediaBuffer; dwFlags: DWORD; rtTimestamp, rtTimelength: TReferenceTime): HResult; virtual; abstract; + function InternalProcessOutput(dwFlags, cOutputBufferCount: DWORD; var pOutputBuffers: TDMOOutputDataBufferArray; out pdwStatus: DWORD): HResult; virtual; abstract; + function InternalAcceptingInput(dwInputStreamIndex: DWORD): HResult; virtual; abstract; + procedure Lock; overload; virtual; + procedure Unlock; virtual; + // Helpers + function InputTypeSet(ulInputStreamIndex: DWORD): BOOL; // const + function OutputTypeSet(ulOutputStreamIndex: DWORD): BOOL; // const + function InputType(ulInputStreamIndex: DWORD): PDMOMediaType;// const + function OutputType(ulOutputStreamIndex: DWORD): PDMOMediaType; // const + function CheckTypesSet: bool; + public + destructor Destroy; override; + procedure Initialize; override; + function GetStreamCount(out pulNumberOfInputStreams, pulNumberOfOutputStreams: DWORD): HResult; stdcall; + function GetInputStreamInfo(ulStreamIndex: DWORD; out pdwFlags: DWORD): HResult; stdcall; + function GetOutputStreamInfo(ulStreamIndex: DWORD; out pdwFlags: DWORD): HResult; stdcall; + function GetInputType(ulStreamIndex, ulTypeIndex: DWORD; out pmt: TDMOMediaType): HResult; stdcall; + function GetOutputType(ulStreamIndex, ulTypeIndex: DWORD; out pmt: TDMOMediaType): HResult; stdcall; + function GetInputCurrentType(ulStreamIndex: DWORD; out pmt: TDMOMediaType): HResult; stdcall; + function GetOutputCurrentType(ulStreamIndex: DWORD; out pmt: TDMOMediaType): HResult; stdcall; + function GetInputSizeInfo(ulStreamIndex: DWORD; out pcbSize, pcbMaxLookahead, pcbAlignment: DWORD): HResult; stdcall; + function GetOutputSizeInfo(ulStreamIndex: DWORD; out pcbSize, pcbAlignment: DWORD): HResult; stdcall; + function SetInputType(ulStreamIndex: DWORD; const pmt: PDMOMediaType; dwFlags: DWORD): HResult; stdcall; + function SetOutputType(ulStreamIndex: DWORD; const pmt: PDMOMediaType; dwFlags: DWORD): HResult; stdcall; + function GetInputStatus(ulStreamIndex: DWORD; out pdwStatus: DWORD): HResult; stdcall; + function GetInputMaxLatency(ulStreamIndex: DWORD; out prtLatency: TReferenceTime): HResult; stdcall; + function SetInputMaxLatency(ulStreamIndex: DWORD; rtLatency: TReferenceTime): HResult; stdcall; + function Flush: HResult; stdcall; + function Discontinuity(ulStreamIndex: DWORD): HResult; stdcall; + function AllocateStreamingResources: HResult; stdcall; + function FreeStreamingResources: HResult; stdcall; + function ProcessInput(ulStreamIndex: DWORD; pBuffer: IMediaBuffer; dwFlags: DWORD; rtTimestamp, rtTimelength: TReferenceTime): HResult; stdcall; + function ProcessOutput(dwFlags, cOutputBufferCount: DWORD; var pOutputBuffers: TDMOOutputDataBufferArray; out pdwStatus: DWORD): HResult; stdcall; + function Lock(bLock: Longint): HResult; overload; stdcall; + end; +{$ENDIF} + +//------------------------------------------------------------------------------ +// File: iwstdec.h +// +// Desc: WST Decoder related definitions and interfaces for ActiveMovie +// +// Copyright (c) 1999 - 2001, Microsoft Corporation. All rights reserved. +//------------------------------------------------------------------------------ +// +type + PAM_WST_PAGE = ^TAM_WST_PAGE; + _AM_WST_PAGE = record + dwPageNr : DWORD; + dwSubPageNr : DWORD; + pucPageData : PByte; + end; + {$EXTERNALSYM _AM_WST_PAGE} + AM_WST_PAGE = _AM_WST_PAGE; + {$EXTERNALSYM AM_WST_PAGE} + TAM_WST_PAGE = _AM_WST_PAGE; + + PAM_WST_LEVEL = ^TAM_WST_LEVEL; + _AM_WST_LEVEL = ( + AM_WST_LEVEL_1_5 + ); + {$EXTERNALSYM _AM_WST_PAGE} + AM_WST_LEVEL = _AM_WST_LEVEL; + {$EXTERNALSYM AM_WST_LEVEL} + TAM_WST_LEVEL = _AM_WST_LEVEL; + + PAM_WST_SERVICE = ^TAM_WST_SERVICE; + _AM_WST_SERVICE = ( + AM_WST_SERVICE_None, + AM_WST_SERVICE_Text, + AM_WST_SERVICE_IDS, + AM_WST_SERVICE_Invalid + ); + {$EXTERNALSYM _AM_WST_SERVICE} + AM_WST_SERVICE = _AM_WST_SERVICE; + {$EXTERNALSYM AM_WST_SERVICE} + TAM_WST_SERVICE = _AM_WST_SERVICE; + + PAM_WST_STATE = ^TAM_WST_STATE; + _AM_WST_STATE = ( + AM_WST_STATE_Off, + AM_WST_STATE_On + ); + {$EXTERNALSYM _AM_WST_STATE} + AM_WST_STATE = _AM_WST_STATE; + {$EXTERNALSYM AM_WST_STATE} + TAM_WST_STATE = _AM_WST_STATE; + + PAM_WST_STYLE = ^TAM_WST_STYLE; + _AM_WST_STYLE = ( + AM_WST_STYLE_None, + AM_WST_STYLE_Invers + ); + {$EXTERNALSYM _AM_WST_STYLE} + AM_WST_STYLE = _AM_WST_STYLE; + {$EXTERNALSYM AM_WST_STYLE} + TAM_WST_STYLE = _AM_WST_STYLE; + + PAM_WST_DRAWBGMODE = ^TAM_WST_DRAWBGMODE; + _AM_WST_DRAWBGMODE = ( + AM_WST_DRAWBGMODE_Opaque, + AM_WST_DRAWBGMODE_Transparent + ); + {$EXTERNALSYM _AM_WST_DRAWBGMODE} + AM_WST_DRAWBGMODE = _AM_WST_DRAWBGMODE; + {$EXTERNALSYM AM_WST_DRAWBGMODE} + TAM_WST_DRAWBGMODE = _AM_WST_DRAWBGMODE; + +// +// WST Decoder standard COM interface +// + + {$HPPEMIT 'typedef System::DelphiInterface _di_IAMWstDecoder;'} + {$EXTERNALSYM IAMWstDecoder} + IAMWstDecoder = interface(IUnknown) + ['{C056DE21-75C2-11d3-A184-00105AEF9F33}'] + // Decoder options to be used by apps + // What is the decoder's level + function GetDecoderLevel(out lpLevel : TAM_WST_LEVEL) : HRESULT; stdcall; + // function SetDecoderLevel(Level : TAM_WST_LEVEL) : HRESULT; stdcall; + // Which of the services is being currently used + function GetCurrentService(out lpService : TAM_WST_SERVICE) : HRESULT; stdcall; + // function SetCurrentService(Service : AM_WST_SERVICE) : HRESULT; stdcall; + // Query/Set the service state (On/Off) + // supported state values are AM_WSTState_On and AM_WSTState_Off + function GetServiceState(out lpState : TAM_WST_STATE) : HRESULT; stdcall; + function SetServiceState(State : TAM_WST_STATE) : HRESULT; stdcall; + // + // Output options to be used by downstream filters + // + // What size, bitdepth etc should the output video be + function GetOutputFormat(out lpbmih : TBITMAPINFOHEADER) : HRESULT; stdcall; + // GetOutputFormat() method, if successful, returns + // 1. S_FALSE if no output format has so far been defined by downstream filters + // 2. S_OK if an output format has already been defined by downstream filters + function SetOutputFormat(lpbmi : PBITMAPINFO) : HRESULT; stdcall; + // Specify physical color to be used in colorkeying the background + // for overlay mixing + function GetBackgroundColor(out pdwPhysColor : DWORD) : HRESULT; stdcall; + function SetBackgroundColor(dwPhysColor : DWORD) : HRESULT; stdcall; + // Specify if whole output bitmap should be redrawn for each sample + function GetRedrawAlways(out lpbOption : BOOL) : HRESULT; stdcall; + function SetRedrawAlways(bOption : BOOL) : HRESULT; stdcall; + // Specify if the caption text background should be opaque/transparent + function GetDrawBackgroundMode(out lpMode : TAM_WST_DRAWBGMODE) : HRESULT; stdcall; + function SetDrawBackgroundMode(Mode : TAM_WST_DRAWBGMODE) : HRESULT; stdcall; + // supported mode values are AM_WST_DrawBGMode_Opaque and + // AM_WST_DrawBGMode_Transparent + function SetAnswerMode(bAnswer : BOOL) : HRESULT; stdcall; + function GetAnswerMode(out pbAnswer : BOOL) : HRESULT; stdcall; + function SetHoldPage(bHoldPage : BOOL) : HRESULT; stdcall; + function GetHoldPage(out pbHoldPage : BOOL) : HRESULT; stdcall; + function GetCurrentPage(out pWstPage : TAM_WST_PAGE) : HRESULT; stdcall; + function SetCurrentPage(WstPage : AM_WST_PAGE) : HRESULT; stdcall; + end; + +implementation + +const + Ole32 = 'ole32.dll'; + Quartz = 'quartz.dll'; + MSDmo = 'msdmo.dll'; + ksUser = 'Ksuser.dll'; + ksProxy = 'Ksproxy.ax'; + +{$IFDEF DIRECTSHOW9_DYNAMIC_LINK} +var + Ole32Lib : THandle = 0; + QuartzLib : THandle = 0; + MSDmoLib : THandle = 0; + ksUserLib : THandle = 0; + ksProxyLib : THandle = 0; + + { Ole32 } + _QzInitialize : function(pvReserved: Pointer): HResult; stdcall; + _QzUninitialize : procedure; stdcall; + _QzFreeUnusedLibraries : procedure; stdcall; + _QzGetMalloc : function(dwMemContext: Longint; out malloc: IMalloc): HResult; stdcall; + _QzTaskMemAlloc : function(cb: Longint): Pointer; stdcall; + _QzTaskMemRealloc : function(pv: Pointer; cb: Longint): Pointer; stdcall; + _QzTaskMemFree : procedure(pv: Pointer); stdcall; + _QzCreateFilterObject : function(const clsid: TCLSID; unkOuter: IUnknown; dwClsContext: Longint; const iid: TIID; out pv): HResult; stdcall; + _QzCLSIDFromString : function(psz: POleStr; out clsid: TCLSID): HResult; stdcall; + _QzStringFromGUID2 : function(const guid: TGUID; psz: POleStr; cbMax: Integer): Integer; stdcall; + + { Quartz } + _AMGetErrorTextA: function(hr: HResult; pbuffer: PChar; MaxLen: DWORD): DWORD; stdcall; + _AMGetErrorTextW: function(hr: HResult; pbuffer: PWideChar; MaxLen: DWORD): DWORD; stdcall; + // [pjh, 2003-07-14] ANSI and UNICODE declaration exchange + {$IFDEF UNICODE} + _AMGetErrorText: function(hr: HResult; pbuffer: PWideChar; MaxLen: DWORD): DWORD; stdcall; + {$ELSE} + _AMGetErrorText: function(hr: HResult; pbuffer: PChar; MaxLen: DWORD): DWORD; stdcall; + {$ENDIF} + + { MSDmo } + + _DMORegister : function(szName: PWideChar; const clsidDMO, guidCategory: TGUID; dwFlags: DWORD; cInTypes: DWORD; const pInTypes: PDMO_PARTIAL_MEDIATYPE; cOutTypes: DWORD; const pOutTypes: PDMO_PARTIAL_MEDIATYPE): HResult; stdcall; + _DMOUnregister : function(const clsidDMO, guidCategory: TGUID): HResult; stdcall; + _DMOEnum : function(const guidCategory: TGUID; dwFlags: DWORD; cInTypes: DWORD; pInTypes: PDMO_PARTIAL_MEDIATYPE; cOutTypes: DWORD; pOutTypes: PDMO_PARTIAL_MEDIATYPE; out ppEnum: IEnumDMO): HResult; stdcall; + _DMOGetTypes : function(const clsidDMO: TGUID; ulInputTypesRequested: ULONG; pulInputTypesSupplied: PULONG; pInputTypes: PDMO_PARTIAL_MEDIATYPE; ulOutputTypesRequested: ULONG; pulOutputTypesSupplied: PULONG; pOutputTypes: PDMO_PARTIAL_MEDIATYPE): HResult; stdcall; + _DMOGetName : function(const clsidDMO: TGUID; szName: TDMOName): HResult; stdcall; + _MoInitMediaType : function(pmt: PDMOMediaType; cbFormat: DWORD): HResult; stdcall; + _MoFreeMediaType : function(pmt: PDMOMediaType): HResult; stdcall; + _MoCopyMediaType : function(out pmtDest: TDMOMediaType; const pmtSrc: PDMOMediaType): HResult; stdcall; + _MoCreateMediaType : function(out ppmt: PDMOMediaType; cbFormat: DWORD): HResult; stdcall; + _MoDeleteMediaType : function(pmt: PDMOMediaType): HResult; stdcall; + _MoDuplicateMediaType : function(out ppmtDest: PDMOMediaType; const pmtSrc: PDMOMediaType): HResult; stdcall; + + { KsUser } + + _KsCreateAllocator : function(ConnectionHandle: THandle; AllocatorFraming: PKSAllocatorFraming; out AllocatorHandle: PHandle): DWORD; stdcall; + _KsCreateClock : function(ConnectionHandle: THandle; ClockCreate: PKSClockCreate; out ClockHandle: PHandle): DWORD; stdcall; + _KsCreatePin : function(FilterHandle: THandle; Connect: PKSPinConnect; DesiredAccess: ACCESS_MASK; out ConnectionHandle: PHandle): DWORD; stdcall; + _KsCreateTopologyNode : function(ParentHandle: THandle; NodeCreate: PKSNodeCreate; DesiredAccess: ACCESS_MASK; out NodeHandle: PHandle): DWORD; stdcall; + + { KsProxy } + + _KsResolveRequiredAttributes : function(DataRange: PKSDATARANGE; Attributes: PKSMULTIPLE_ITEM): HResult; stdcall; + _KsOpenDefaultDevice : function(Category: TGUID; Access: ACCESS_MASK; DeviceHandle: PHANDLE): HResult; stdcall; + _KsSynchronousDeviceControl : function(Handle: THandle; IoControl: ULONG; InBuffer: Pointer; InLength: ULONG; OutBuffer: Pointer; OutLength: ULONG; BytesReturned: PULONG): HResult; stdcall; + _KsGetMultiplePinFactoryItems : function(FilterHandle: THandle; PinFactoryId: ULONG; PropertyId: ULONG; Items: Pointer): HResult; stdcall; + _KsGetMediaTypeCount : function(FilterHandle: THandle; PinFactoryId: ULONG; out MediaTypeCount: ULONG): HResult; stdcall; + _KsGetMediaType : function(Position: integer; out AmMediaType: TAMMediaType; FilterHandle: THandle; PinFactoryId: ULONG): HResult; stdcall; + + { Ole32 } + + function Ole32Loaded: Boolean; + begin + Result := ole32Lib <> 0; + end; + + function UnLoadOle32: Boolean; + begin + Result:= True; + if Ole32Loaded then + begin + Result := FreeLibrary(Ole32Lib); + _QzInitialize := nil; + _QzUninitialize := nil; + _QzFreeUnusedLibraries := nil; + _QzGetMalloc := nil; + _QzTaskMemAlloc := nil; + _QzTaskMemRealloc := nil; + _QzTaskMemFree := nil; + _QzCreateFilterObject := nil; + _QzCLSIDFromString := nil; + _QzStringFromGUID2 := nil; + Ole32Lib := 0; + end; + end; + + function LoadOle32: Boolean; + begin + Result := Ole32Loaded; + if (not Result) then + begin + Ole32Lib := LoadLibrary(Ole32); + if Ole32Loaded then + begin + _QzInitialize := GetProcAddress(Ole32Lib, 'CoInitialize'); + _QzUninitialize := GetProcAddress(Ole32Lib, 'CoUninitialize'); + _QzFreeUnusedLibraries := GetProcAddress(Ole32Lib, 'CoFreeUnusedLibraries'); + _QzGetMalloc := GetProcAddress(Ole32Lib, 'CoGetMalloc'); + _QzTaskMemAlloc := GetProcAddress(Ole32Lib, 'CoTaskMemAlloc'); + _QzTaskMemRealloc := GetProcAddress(Ole32Lib, 'CoTaskMemRealloc'); + _QzTaskMemFree := GetProcAddress(Ole32Lib, 'CoTaskMemFree'); + _QzCreateFilterObject := GetProcAddress(Ole32Lib, 'CoCreateInstance'); + _QzCLSIDFromString := GetProcAddress(Ole32Lib, 'CLSIDFromString'); + _QzStringFromGUID2 := GetProcAddress(Ole32Lib, 'StringFromGUID2'); + Result:= Assigned(_QzInitialize) and Assigned(_QzUninitialize) and + Assigned(_QzFreeUnusedLibraries) and Assigned(_QzGetMalloc) and + Assigned(_QzTaskMemAlloc) and Assigned(_QzTaskMemRealloc) and + Assigned(_QzTaskMemFree) and Assigned(_QzCreateFilterObject) and + Assigned(_QzCLSIDFromString) and Assigned(_QzStringFromGUID2); + if not Result then UnLoadOle32; + end; + end; + end; + + function QzInitialize(pvReserved: Pointer): HResult; stdcall; + begin + LoadOle32; + Result := _QzInitialize(pvReserved); + end; + + procedure QzUninitialize; stdcall; + begin + LoadOle32; + _QzUninitialize; + end; + + procedure QzFreeUnusedLibraries; stdcall; + begin + LoadOle32; + _QzFreeUnusedLibraries; + end; + + function QzGetMalloc(dwMemContext: Longint; out malloc: IMalloc): HResult; stdcall; + begin + LoadOle32; + Result := _QzGetMalloc(dwMemContext, malloc); + end; + + function QzTaskMemAlloc(cb: Longint): Pointer; stdcall; + begin + LoadOle32; + Result := _QzTaskMemAlloc(cb); + end; + + function QzTaskMemRealloc(pv: Pointer; cb: Longint): Pointer; stdcall; + begin + LoadOle32; + Result := _QzTaskMemRealloc(pv, cb); + end; + + procedure QzTaskMemFree(pv: Pointer); stdcall; + begin + LoadOle32; + _QzTaskMemFree(pv); + end; + + function QzCreateFilterObject(const clsid: TCLSID; unkOuter: IUnknown; + dwClsContext: Longint; const iid: TIID; out pv): HResult; stdcall; + begin + LoadOle32; + Result := _QzCreateFilterObject(clsid, unkOuter, dwClsContext, iid, pv); + end; + + function QzCLSIDFromString(psz: POleStr; out clsid: TCLSID): HResult; stdcall; + begin + LoadOle32; + Result := _QzCLSIDFromString(psz, clsid); + end; + + function QzStringFromGUID2(const guid: TGUID; psz: POleStr; cbMax: Integer): Integer; stdcall; + begin + LoadOle32; + Result := _QzStringFromGUID2(guid, psz, cbMax); + end; + + { Quartz } + + function QuartzLoaded: Boolean; + begin + Result := QuartzLib <> 0; + end; + + function UnLoadQuartz: Boolean; + begin + Result:= True; + if QuartzLoaded then + begin + Result := FreeLibrary(QuartzLib); + _AMGetErrorTextA := nil; + _AMGetErrorTextW := nil; + _AMGetErrorText := nil; + QuartzLib := 0; + end; + end; + + function LoadQuartz: Boolean; + begin + Result := QuartzLoaded; + if (not Result) then + begin + QuartzLib := LoadLibrary(Quartz); + if QuartzLoaded then + begin + _AMGetErrorTextA := GetProcAddress(QuartzLib, 'AMGetErrorTextA'); + _AMGetErrorTextW := GetProcAddress(QuartzLib, 'AMGetErrorTextW'); + // [pjh, 2003-07-14] ANSI and UNICODE declaration exchange + {$IFDEF UNICODE} + _AMGetErrorText := _AMGetErrorTextW; + {$ELSE} + _AMGetErrorText := _AMGetErrorTextA; + {$ENDIF} + Result:= Assigned(_AMGetErrorTextA) and Assigned(_AMGetErrorTextW); + if not Result then UnLoadQuartz; + end; + end; + end; + + function AMGetErrorTextA(hr: HResult; pbuffer: PChar; MaxLen: DWORD): DWORD; stdcall; + begin + LoadQuartz; + Result := _AMGetErrorTextA(hr, pbuffer, MaxLen); + end; + + function AMGetErrorTextW(hr: HResult; pbuffer: PWideChar; MaxLen: DWORD): DWORD; stdcall; + begin + LoadQuartz; + Result := _AMGetErrorTextW(hr, pbuffer, MaxLen); + end; + + // [pjh, 2003-07-14] ANSI and UNICODE declaration exchange + {$IFDEF UNICODE} + function AMGetErrorText(hr: HResult; pbuffer: PWideChar; MaxLen: DWORD): DWORD; stdcall; + {$ELSE} + function AMGetErrorText(hr: HResult; pbuffer: PChar; MaxLen: DWORD): DWORD; stdcall; + {$ENDIF} + begin + LoadQuartz; + Result := _AMGetErrorText(hr, pbuffer, MaxLen); + end; + + { MSDmo } + + function MSDmoLoaded: Boolean; + begin + Result := MSDmoLib <> 0; + end; + + function UnLoadMSDmo: Boolean; + begin + Result:= True; + if MSDmoLoaded then + begin + Result := FreeLibrary(MSDmoLib); + _DMORegister := nil; + _DMOEnum := nil; + _DMOUnregister := nil; + _DMOGetTypes := nil; + _DMOGetName := nil; + _MoInitMediaType := nil; + _MoFreeMediaType := nil; + _MoCopyMediaType := nil; + _MoCreateMediaType := nil; + _MoDeleteMediaType := nil; + _MoDuplicateMediaType := nil; + MSDmoLib := 0; + end; + end; + + function LoadMSDmo: Boolean; + begin + Result := MSDmoLoaded; + if (not Result) then + begin + MSDmoLib := LoadLibrary(MSDmo); + if MSDmoLoaded then + begin + _DMORegister := GetProcAddress(MSDmoLib, 'DMORegister'); + _DMOEnum := GetProcAddress(MSDmoLib, 'DMOEnum'); + _DMOUnregister := GetProcAddress(MSDmoLib, 'DMOUnregister'); + _DMOGetTypes := GetProcAddress(MSDmoLib, 'DMOGetTypes'); + _DMOGetName := GetProcAddress(MSDmoLib, 'DMOGetName'); + _MoInitMediaType := GetProcAddress(MSDmoLib, 'MoInitMediaType'); + _MoFreeMediaType := GetProcAddress(MSDmoLib, 'MoFreeMediaType'); + _MoCopyMediaType := GetProcAddress(MSDmoLib, 'MoCopyMediaType'); + _MoCreateMediaType := GetProcAddress(MSDmoLib, 'MoCreateMediaType'); + _MoDeleteMediaType := GetProcAddress(MSDmoLib, 'MoDeleteMediaType'); + _MoDuplicateMediaType := GetProcAddress(MSDmoLib, 'MoDuplicateMediaType'); + Result:= Assigned(_DMORegister) and Assigned(_DMOEnum) and + Assigned(_DMOUnregister) and Assigned(_DMOGetTypes) and + Assigned(_DMOGetName) and Assigned(_MoInitMediaType) and + Assigned(_MoFreeMediaType) and Assigned(_MoCopyMediaType) and + Assigned(_MoCreateMediaType) and Assigned(_MoDeleteMediaType) and + Assigned(_MoDuplicateMediaType); + if not Result then UnLoadMSDmo; + end; + end; + end; + + function DMORegister(szName: PWideChar; const clsidDMO, guidCategory: TGUID; dwFlags: DWORD; + cInTypes: DWORD; const pInTypes: PDMO_PARTIAL_MEDIATYPE; cOutTypes: DWORD; + const pOutTypes: PDMO_PARTIAL_MEDIATYPE): HResult; stdcall; + begin + LoadMSDmo; + Result := _DMORegister(szName, clsidDMO, guidCategory, dwFlags, cInTypes, + pInTypes, cOutTypes, pOutTypes); + end; + + function DMOUnregister(const clsidDMO, guidCategory: TGUID): HResult; stdcall; + begin + LoadMSDmo; + Result := _DMOUnregister(clsidDMO, guidCategory); + end; + + function DMOEnum(const guidCategory: TGUID; dwFlags: DWORD; cInTypes: DWORD; + pInTypes: PDMO_PARTIAL_MEDIATYPE; cOutTypes: DWORD; + pOutTypes: PDMO_PARTIAL_MEDIATYPE; out ppEnum: IEnumDMO): HResult; stdcall; + begin + LoadMSDmo; + Result := _DMOEnum(guidCategory, dwFlags, cInTypes, pInTypes, cOutTypes, pOutTypes, ppEnum); + end; + + function DMOGetTypes(const clsidDMO: TGUID; ulInputTypesRequested: ULONG; + pulInputTypesSupplied: PULONG; pInputTypes: PDMO_PARTIAL_MEDIATYPE; + ulOutputTypesRequested: ULONG; pulOutputTypesSupplied: PULONG; + pOutputTypes: PDMO_PARTIAL_MEDIATYPE): HResult; stdcall; + begin + LoadMSDmo; + Result := _DMOGetTypes(clsidDMO, ulInputTypesRequested, pulInputTypesSupplied, + pInputTypes, ulOutputTypesRequested, pulOutputTypesSupplied, pOutputTypes); + end; + + function DMOGetName(const clsidDMO: TGUID; szName: TDMOName): HResult; stdcall; + begin + LoadMSDmo; + Result := _DMOGetName(clsidDMO, szName); + end; + + function MoInitMediaType(pmt: PDMOMediaType; cbFormat: DWORD): HResult; stdcall; + begin + LoadMSDmo; + Result := _MoInitMediaType(pmt, cbFormat); + end; + + function MoFreeMediaType(pmt: PDMOMediaType): HResult; stdcall; + begin + LoadMSDmo; + Result := _MoFreeMediaType(pmt); + end; + + function MoCopyMediaType(out pmtDest: TDMOMediaType; const pmtSrc: PDMOMediaType): HResult; stdcall; + begin + LoadMSDmo; + Result := _MoCopyMediaType(pmtDest, pmtSrc); + end; + + function MoCreateMediaType(out ppmt: PDMOMediaType; cbFormat: DWORD): HResult; stdcall; + begin + LoadMSDmo; + Result := _MoCreateMediaType(ppmt, cbFormat); + end; + + function MoDeleteMediaType(pmt: PDMOMediaType): HResult; stdcall; + begin + LoadMSDmo; + Result := _MoDeleteMediaType(pmt); + end; + + function MoDuplicateMediaType(out ppmtDest: PDMOMediaType; const pmtSrc: PDMOMediaType): HResult; stdcall; + begin + LoadMSDmo; + Result := _MoDuplicateMediaType(ppmtDest, pmtSrc); + end; + + { ksUser } + + function ksUserLoaded: Boolean; + begin + Result := ksUserLib <> 0; + end; + + function UnLoadksUser: Boolean; + begin + Result:= True; + if ksUserLoaded then + begin + Result := FreeLibrary(ksUserLib); + _KsCreateAllocator := nil; + _KsCreateClock := nil; + _KsCreatePin := nil; + _KsCreateTopologyNode := nil; + ksUserLib := 0; + end; + end; + + function LoadksUser: Boolean; + begin + Result := ksUserLoaded; + if (not Result) then + begin + ksUserLib := LoadLibrary(ksUser); + if ksUserLoaded then + begin + _KsCreateAllocator := GetProcAddress(ksUserLib, 'KsCreateAllocator'); + _KsCreateClock := GetProcAddress(ksUserLib, 'KsCreateClock'); + _KsCreatePin := GetProcAddress(ksUserLib, 'KsCreatePin'); + _KsCreateTopologyNode := GetProcAddress(ksUserLib, 'KsCreateTopologyNode'); + Result:= + Assigned(_KsCreateAllocator) and Assigned(_KsCreateClock) and + Assigned(_KsCreatePin) and Assigned(_KsCreateTopologyNode); + if not Result then UnLoadksUser; + end; + end; + end; + + function KsCreateAllocator(ConnectionHandle: THandle; AllocatorFraming: PKSAllocatorFraming; out AllocatorHandle: PHandle): DWORD; stdcall; + begin + LoadksUser; + Result := _KsCreateAllocator(ConnectionHandle, AllocatorFraming, AllocatorHandle); + end; + + function KsCreateClock(ConnectionHandle: THandle; ClockCreate: PKSClockCreate; out ClockHandle: PHandle): DWORD; stdcall; + begin + LoadksUser; + Result := _KsCreateClock(ConnectionHandle, ClockCreate, ClockHandle); + end; + + function KsCreatePin(FilterHandle: THandle; Connect: PKSPinConnect; DesiredAccess: ACCESS_MASK; out ConnectionHandle: PHandle): DWORD; stdcall; + begin + LoadksUser; + Result := _KsCreatePin(FilterHandle, Connect, DesiredAccess, ConnectionHandle); + end; + + function KsCreateTopologyNode(ParentHandle: THandle; NodeCreate: PKSNodeCreate; DesiredAccess: ACCESS_MASK; out NodeHandle: PHandle): DWORD; stdcall; + begin + LoadksUser; + Result := _KsCreateTopologyNode(ParentHandle, NodeCreate, DesiredAccess, NodeHandle); + end; + + { KsProxy } + + function KsProxyLoaded: Boolean; + begin + Result := ksProxyLib <> 0; + end; + + function UnLoadKsProxy: Boolean; + begin + Result:= True; + if KsProxyLoaded then + begin + Result := FreeLibrary(KsProxyLib); + _KsResolveRequiredAttributes := nil; + _KsOpenDefaultDevice := nil; + _KsSynchronousDeviceControl := nil; + _KsGetMultiplePinFactoryItems := nil; + _KsGetMediaTypeCount := nil; + _KsGetMediaType := nil; + KsProxyLib := 0; + end; + end; + + function LoadKsProxy: Boolean; + begin + Result := KsProxyLoaded; + if (not Result) then + begin + KsProxyLib := LoadLibrary(KsProxy); + if KsProxyLoaded then + begin + _KsResolveRequiredAttributes := GetProcAddress(KsProxyLib, 'KsResolveRequiredAttributes'); + _KsOpenDefaultDevice := GetProcAddress(KsProxyLib, 'KsOpenDefaultDevice'); + _KsSynchronousDeviceControl := GetProcAddress(KsProxyLib, 'KsSynchronousDeviceControl'); + _KsGetMultiplePinFactoryItems := GetProcAddress(KsProxyLib, 'KsGetMultiplePinFactoryItems'); + _KsGetMediaTypeCount := GetProcAddress(KsProxyLib, 'KsGetMediaTypeCount'); + _KsGetMediaType := GetProcAddress(KsProxyLib, 'KsGetMediaType'); + Result:= Assigned(_KsResolveRequiredAttributes) and Assigned(_KsOpenDefaultDevice) and + Assigned(_KsSynchronousDeviceControl) and Assigned(_KsGetMultiplePinFactoryItems) and + Assigned(_KsGetMediaTypeCount) and Assigned(_KsGetMediaType); + if not Result then UnLoadKsProxy; + end; + end; + end; + + function KsResolveRequiredAttributes(DataRange: PKSDATARANGE; Attributes: PKSMULTIPLE_ITEM): HResult; stdcall; + begin + LoadKsProxy; + Result := _KsResolveRequiredAttributes(DataRange, Attributes); + end; + + function KsOpenDefaultDevice(Category: TGUID; Access: ACCESS_MASK; DeviceHandle: PHANDLE): HResult; stdcall; + begin + LoadKsProxy; + Result := _KsOpenDefaultDevice(Category, Access, DeviceHandle); + end; + + function KsSynchronousDeviceControl(Handle: THandle; IoControl: ULONG; InBuffer: Pointer; InLength: ULONG; OutBuffer: Pointer; OutLength: ULONG; BytesReturned: PULONG): HResult; stdcall; + begin + LoadKsProxy; + Result := _KsSynchronousDeviceControl(Handle, IoControl, InBuffer, InLength, OutBuffer, OutLength, BytesReturned); + end; + + function KsGetMultiplePinFactoryItems(FilterHandle: THandle; PinFactoryId: ULONG; PropertyId: ULONG; Items: Pointer): HResult; stdcall; + begin + LoadKsProxy; + Result := _KsGetMultiplePinFactoryItems(FilterHandle, PinFactoryId, PropertyId, Items); + end; + + function KsGetMediaTypeCount(FilterHandle: THandle; PinFactoryId: ULONG; out MediaTypeCount: ULONG): HResult; stdcall; + begin + LoadKsProxy; + Result := _KsGetMediaTypeCount(FilterHandle, PinFactoryId, MediaTypeCount); + end; + + function KsGetMediaType(Position: integer; out AmMediaType: TAMMediaType; FilterHandle: THandle; PinFactoryId: ULONG): HResult; stdcall; + begin + LoadKsProxy; + Result := _KsGetMediaType(Position, AmMediaType, FilterHandle, PinFactoryId); + end; + +{$ELSE} + function QzInitialize; external ole32 name 'CoInitialize'; + procedure QzUninitialize; external ole32 name 'CoUninitialize'; + procedure QzFreeUnusedLibraries; external ole32 name 'CoFreeUnusedLibraries'; + + function QzGetMalloc; external ole32 name 'CoGetMalloc'; + function QzTaskMemAlloc; external ole32 name 'CoTaskMemAlloc'; + function QzTaskMemRealloc; external ole32 name 'CoTaskMemRealloc'; + procedure QzTaskMemFree; external ole32 name 'CoTaskMemFree'; + + function QzCreateFilterObject; external ole32 name 'CoCreateInstance'; + function QzCLSIDFromString; external ole32 name 'CLSIDFromString'; + function QzStringFromGUID2; external ole32 name 'StringFromGUID2'; + + function AMGetErrorTextA; external quartz name 'AMGetErrorTextA'; + function AMGetErrorTextW; external quartz name 'AMGetErrorTextW'; + function AMGetErrorText; external quartz name {$IFDEF UNICODE}'AMGetErrorTextW'{$ELSE}'AMGetErrorTextA'{$ENDIF}; + + function DMORegister ; external msdmo name 'DMORegister'; + function DMOUnregister ; external msdmo name 'DMOUnregister'; + function DMOEnum ; external msdmo name 'DMOEnum'; + function DMOGetTypes ; external msdmo name 'DMOGetTypes'; + function DMOGetName ; external msdmo name 'DMOGetName'; + + function MoInitMediaType ; external msdmo name 'MoInitMediaType'; + function MoFreeMediaType ; external msdmo name 'MoFreeMediaType'; + function MoCopyMediaType ; external msdmo name 'MoCopyMediaType'; + function MoCreateMediaType ; external msdmo name 'MoCreateMediaType'; + function MoDeleteMediaType ; external msdmo name 'MoDeleteMediaType'; + function MoDuplicateMediaType; external msdmo name 'MoDuplicateMediaType'; + + function KsCreateAllocator ; external ksuser name 'KsCreateAllocator'; + function KsCreateClock ; external ksuser name 'KsCreateClock'; + function KsCreatePin ; external ksuser name 'KsCreatePin'; + function KsCreateTopologyNode; external ksuser name 'KsCreateTopologyNode'; + + function KsGetMediaType ; external ksproxy name 'KsGetMediaType'; + function KsGetMediaTypeCount ; external ksproxy name 'KsGetMediaTypeCount'; + function KsGetMultiplePinFactoryItems; external ksproxy name 'KsGetMultiplePinFactoryItems'; + function KsOpenDefaultDevice ; external ksproxy name 'KsOpenDefaultDevice'; + function KsResolveRequiredAttributes ; external ksproxy name 'KsResolveRequiredAttributes'; + function KsSynchronousDeviceControl ; external ksproxy name 'KsSynchronousDeviceControl'; +{$ENDIF} + +{$IFDEF DELPHI4_UP} +//////////////////////////////////////////////////////////////////////////////// +// +// TMediaObjectImpl +// +/////////////////////////////////////////////////////////////////////////////// + +type + ILockIt = interface + end; + + TLockIt = class(TInterfacedObject, ILockIt) + private + FMOI: TMediaObjectImpl; + public + constructor Create(MOI: TMediaObjectImpl); + destructor Destroy; override; + end; + +constructor TLockIt.Create(MOI: TMediaObjectImpl); +begin + FMOI := MOI; + FMOI.Lock; +end; + +destructor TLockIt.Destroy; +begin + FMOI.Unlock; + FMOI := nil; +end; + +//=================================================================== + +// Helpers +function TMediaObjectImpl.InputTypeSet(ulInputStreamIndex: DWORD): BOOL; +begin + ASSERT(ulInputStreamIndex < NUMBEROFINPUTS); + Result := (0 <> m_InputInfo[ulInputStreamIndex].fTypeSet); +end; + +function TMediaObjectImpl.OutputTypeSet(ulOutputStreamIndex: DWORD): BOOL; +begin + ASSERT(ulOutputStreamIndex < NUMBEROFOUTPUTS); + Result := (0 <> m_OutputInfo[ulOutputStreamIndex].fTypeSet); +end; + +function TMediaObjectImpl.InputType(ulInputStreamIndex: DWORD): PDMOMediaType; +begin + if (not InputTypeSet(ulInputStreamIndex)) then Result := nil + else Result := @m_InputInfo[ulInputStreamIndex].CurrentMediaType; +end; + +function TMediaObjectImpl.OutputType(ulOutputStreamIndex: DWORD): PDMOMediaType; +begin + if (not OutputTypeSet(ulOutputStreamIndex)) then Result := nil + else Result := @m_OutputInfo[ulOutputStreamIndex].CurrentMediaType; +end; + +function TMediaObjectImpl.CheckTypesSet: bool; +var + dw: Integer; + dwFlags: DWORD; +begin + m_fTypesSet := False; + for dw := 0 to (NUMBEROFINPUTS - 1) do + begin + if (not InputTypeSet(dw)) then + begin + Result := False; + Exit; + end; + end; + for dw := 0 to (NUMBEROFOUTPUTS - 1) do + begin + if (not OutputTypeSet(dw)) then + begin + // Check if it's optional + {$IFDEF DEBUG} + dwFlags := $FFFFFFFF; + {$ENDIF} + InternalGetOutputStreamInfo(dw, dwFlags); + ASSERT(0 = (dwFlags and not (DMO_OUTPUT_STREAMF_WHOLE_SAMPLES or + DMO_OUTPUT_STREAMF_SINGLE_SAMPLE_PER_BUFFER or + DMO_OUTPUT_STREAMF_FIXED_SAMPLE_SIZE or + DMO_OUTPUT_STREAMF_DISCARDABLE or + DMO_OUTPUT_STREAMF_OPTIONAL))); + if not ((dwFlags and DMO_OUTPUT_STREAMF_OPTIONAL) <> 0) then + begin + Result := False; + Exit; + end; + end; + end; + m_fTypesSet := True; + Result := True; +end; + +procedure TMediaObjectImpl.Initialize; +begin + inherited; + Assert((NUMBEROFINPUTS <> 0) or (NUMBEROFOUTPUTS <> 0),'NUMBEROFINPUTS or NUMBEROFOUTPUTS = 0'); + m_fTypesSet := False; + m_fFlushed := True; + m_fResourcesAllocated := False; + SetLength(m_InputInfo, NUMBEROFINPUTS); + SetLength(m_OutputInfo, NUMBEROFOUTPUTS); + ZeroMemory(m_InputInfo, SizeOf(TMOinplIOInfo)*NUMBEROFINPUTS); + ZeroMemory(m_OutputInfo, SizeOf(TMOinplIOInfo)*NUMBEROFOUTPUTS); + fCritSection:= TCriticalSection.Create; +end; + +destructor TMediaObjectImpl.Destroy; +var + dwCurrentType: Integer; +begin + for dwCurrentType := 0 to (NUMBEROFINPUTS - 1) do + begin + if (InputTypeSet(dwCurrentType)) then + MoFreeMediaType(@m_InputInfo[dwCurrentType].CurrentMediaType); + end; + + for dwCurrentType := 0 to (NUMBEROFOUTPUTS - 1) do + begin + if (OutputTypeSet(dwCurrentType)) then + MoFreeMediaType(@m_OutputInfo[dwCurrentType].CurrentMediaType); + end; + + fCritSection.Free; + inherited Destroy; +end; + +// +// IMediaObject methods +// +function TMediaObjectImpl.GetStreamCount(out pulNumberOfInputStreams, pulNumberOfOutputStreams: DWORD): HResult; +var + lck: ILockIt; +begin + lck := TLockIt.Create(Self); + pulNumberOfInputStreams := NUMBEROFINPUTS; + pulNumberOfOutputStreams := NUMBEROFOUTPUTS; + Result := S_OK; +end; + +function TMediaObjectImpl.GetInputStreamInfo(ulStreamIndex: DWORD; out pdwFlags: DWORD): HResult; +var + lck: ILockIt; +begin + lck := TLockIt.Create(Self); + if (ulStreamIndex >= NUMBEROFINPUTS) then + begin +{$IFDEF VER120} + Result := DMO_E_INVALIDSTREAMINDEX; +{$ELSE} + Result := Longint(DMO_E_INVALIDSTREAMINDEX); +{$ENDIF} + Exit; + end; + if (@pdwFlags = nil) then + begin + Result := E_POINTER; + Exit; + end; + Result := InternalGetInputStreamInfo(ulStreamIndex, pdwFlags); + ASSERT(0 = (pdwFlags and not (DMO_INPUT_STREAMF_WHOLE_SAMPLES or + DMO_INPUT_STREAMF_SINGLE_SAMPLE_PER_BUFFER or + DMO_INPUT_STREAMF_FIXED_SAMPLE_SIZE or + DMO_INPUT_STREAMF_HOLDS_BUFFERS))); +end; + +function TMediaObjectImpl.GetOutputStreamInfo(ulStreamIndex: DWORD; out pdwFlags: DWORD): HResult; +var + lck: ILockIt; +begin + lck:= TLockIt.Create(Self); + if (ulStreamIndex >= NUMBEROFOUTPUTS) then + begin +{$IFDEF VER120} + Result := DMO_E_INVALIDSTREAMINDEX; +{$ELSE} + Result := Longint(DMO_E_INVALIDSTREAMINDEX); +{$ENDIF} + Exit; + end; + if (@pdwFlags = nil) then + begin + Result := E_POINTER; + Exit; + end; + + Result := InternalGetOutputStreamInfo(ulStreamIndex, pdwFlags); + ASSERT(0 = (pdwFlags and not(DMO_OUTPUT_STREAMF_WHOLE_SAMPLES or + DMO_OUTPUT_STREAMF_SINGLE_SAMPLE_PER_BUFFER or + DMO_OUTPUT_STREAMF_FIXED_SAMPLE_SIZE or + DMO_OUTPUT_STREAMF_DISCARDABLE or + DMO_OUTPUT_STREAMF_OPTIONAL))); +end; + +function TMediaObjectImpl.GetInputType(ulStreamIndex, ulTypeIndex: DWORD; + out pmt: TDMOMediaType): HResult; +var + lck: ILockIt; +begin + if (ulStreamIndex >= NUMBEROFINPUTS) then + begin +{$IFDEF VER120} + Result := DMO_E_INVALIDSTREAMINDEX; +{$ELSE} + Result := Longint(DMO_E_INVALIDSTREAMINDEX); +{$ENDIF} + Exit; + end; + lck:= TLockIt.Create(Self); + Result := InternalGetInputType(ulStreamIndex, ulTypeIndex, pmt); +end; + +function TMediaObjectImpl.GetOutputType(ulStreamIndex, ulTypeIndex: DWORD; + out pmt: TDMOMediaType): HResult; stdcall; +var + lck: ILockIt; +begin + if (ulStreamIndex >= NUMBEROFOUTPUTS) then + begin +{$IFDEF VER120} + Result := DMO_E_INVALIDSTREAMINDEX; +{$ELSE} + Result := Longint(DMO_E_INVALIDSTREAMINDEX); +{$ENDIF} + Exit; + end; + lck := TLockIt.Create(Self); + Result := InternalGetOutputType(ulStreamIndex, ulTypeIndex, pmt); +end; + +function TMediaObjectImpl.GetInputCurrentType(ulStreamIndex: DWORD; + out pmt: TDMOMediaType): HResult; stdcall; +var + lck: ILockIt; +begin + if (ulStreamIndex >= NUMBEROFINPUTS) then + begin +{$IFDEF VER120} + Result := DMO_E_INVALIDSTREAMINDEX; +{$ELSE} + Result := Longint(DMO_E_INVALIDSTREAMINDEX); +{$ENDIF} + Exit; + end; + if (nil = @pmt) then + begin + Result:= E_POINTER; + Exit; + end; + lck := TLockIt.Create(Self); + if (InputTypeSet(ulStreamIndex)) + then Result := MoCopyMediaType(pmt, @m_InputInfo[ulStreamIndex].CurrentMediaType) + else +{$IFDEF VER120} + Result := DMO_E_TYPE_NOT_SET; +{$ELSE} + Result := Longint(DMO_E_TYPE_NOT_SET); +{$ENDIF} + +end; + +function TMediaObjectImpl.GetOutputCurrentType(ulStreamIndex: DWORD; + out pmt: TDMOMediaType): HResult; +var + lck: ILockIt; +begin + if (ulStreamIndex >= NUMBEROFOUTPUTS) then + begin +{$IFDEF VER120} + Result := DMO_E_INVALIDSTREAMINDEX; +{$ELSE} + Result := Longint(DMO_E_INVALIDSTREAMINDEX); +{$ENDIF} + Exit; + end; + if (nil = @pmt) then + begin + Result:= E_POINTER; + Exit; + end; + + lck := TLockIt.Create(Self); + if (OutputTypeSet(ulStreamIndex)) + then Result := MoCopyMediaType(pmt, @m_OutputInfo[ulStreamIndex].CurrentMediaType) +{$IFDEF VER120} + else Result := DMO_E_TYPE_NOT_SET; +{$ELSE} + else Result := Longint(DMO_E_TYPE_NOT_SET); +{$ENDIF} +end; + +function TMediaObjectImpl.GetInputSizeInfo(ulStreamIndex: DWORD; out pcbSize, pcbMaxLookahead, pcbAlignment: DWORD): HResult; +var + lck: ILockIt; +begin + if (ulStreamIndex >= NUMBEROFINPUTS) then + begin +{$IFDEF VER120} + Result := DMO_E_INVALIDSTREAMINDEX; +{$ELSE} + Result := Longint(DMO_E_INVALIDSTREAMINDEX); +{$ENDIF} + Exit; + end; + if (nil = @pcbSize) or (nil = @pcbMaxLookahead) or (nil = @pcbAlignment) then + begin + Result:= E_POINTER; + Exit; + end; + + lck := TLockIt.Create(Self); + if (not InputTypeSet(ulStreamIndex)) then + begin +{$IFDEF VER120} + Result := DMO_E_TYPE_NOT_SET; +{$ELSE} + Result := Longint(DMO_E_TYPE_NOT_SET); +{$ENDIF} + Exit; + end; + Result := InternalGetInputSizeInfo(ulStreamIndex, pcbSize, pcbMaxLookahead, pcbAlignment); +end; + +function TMediaObjectImpl.GetOutputSizeInfo(ulStreamIndex: DWORD; out pcbSize, pcbAlignment: DWORD): HResult; +var + lck: ILockIt; +begin + if (ulStreamIndex >= NUMBEROFOUTPUTS) then + begin +{$IFDEF VER120} + Result := DMO_E_INVALIDSTREAMINDEX; +{$ELSE} + Result := Longint(DMO_E_INVALIDSTREAMINDEX); +{$ENDIF} + Exit; + end; + if (nil = @pcbSize) or (nil = @pcbAlignment) then + begin + Result:= E_POINTER; + Exit; + end; + + lck := TLockIt.Create(Self); + if ((not m_fTypesSet) or (not OutputTypeSet(ulStreamIndex))) then + begin +{$IFDEF VER120} + Result := DMO_E_TYPE_NOT_SET; +{$ELSE} + Result := Longint(DMO_E_TYPE_NOT_SET); +{$ENDIF} + Exit; + end; + Result := InternalGetOutputSizeInfo(ulStreamIndex, pcbSize, pcbAlignment); +end; + +function TMediaObjectImpl.SetInputType(ulStreamIndex: DWORD; const pmt: PDMOMediaType; dwFlags: DWORD): HResult; +var + lck: ILockIt; + mtTemp: TDMOMediaType; +begin + if (ulStreamIndex >= NUMBEROFINPUTS) then + begin +{$IFDEF VER120} + Result := DMO_E_INVALIDSTREAMINDEX; +{$ELSE} + Result := Longint(DMO_E_INVALIDSTREAMINDEX); +{$ENDIF} + Exit; + end; + if ((dwFlags and not(DMO_SET_TYPEF_CLEAR or DMO_SET_TYPEF_TEST_ONLY)) <> 0) then + begin + Result := E_INVALIDARG; + Exit; + end; + lck := TLockIt.Create(Self); + if ((dwFlags and DMO_SET_TYPEF_CLEAR) <> 0) then + begin + MoFreeMediaType(@m_InputInfo[ulStreamIndex].CurrentMediaType); + m_InputInfo[ulStreamIndex].fTypeSet := Integer(False); + if (not CheckTypesSet) then + begin + Flush; + FreeStreamingResources; + end; + Result := NOERROR; + Exit; + end; + if (nil = pmt) then + begin + Result := E_POINTER; + Exit; + end; + Result := InternalCheckInputType(ulStreamIndex, pmt); // DMO_E_TYPE_NOT_ACCEPTED, S_FALSE + if FAILED(Result) or (Result = S_FALSE) then Exit; + + if ((dwFlags and DMO_SET_TYPEF_TEST_ONLY) <> 0) then + begin + Result := NOERROR; + Exit; + end; + // actually set the type + if (S_OK = MoCopyMediaType(mtTemp, pmt)) then + begin + // Free any previous mediatype + if (InputTypeSet(ulStreamIndex)) then + MoFreeMediaType(@m_InputInfo[ulStreamIndex].CurrentMediaType); + m_InputInfo[ulStreamIndex].CurrentMediaType := mtTemp; + m_InputInfo[ulStreamIndex].fTypeSet := Integer(True); + CheckTypesSet; + end else + begin + Result := E_OUTOFMEMORY; + Exit; + end; + Result := NOERROR; +end; + +function TMediaObjectImpl.SetOutputType(ulStreamIndex: DWORD; const pmt: PDMOMediaType; dwFlags: DWORD): HResult; +var + lck: ILockIt; + mtTemp: TDMOMediaType; +begin + if (ulStreamIndex >= NUMBEROFOUTPUTS) then + begin +{$IFDEF VER120} + Result := DMO_E_INVALIDSTREAMINDEX; +{$ELSE} + Result := Longint(DMO_E_INVALIDSTREAMINDEX); +{$ENDIF} + Exit; + end; + if (dwFlags and not(DMO_SET_TYPEF_CLEAR or DMO_SET_TYPEF_TEST_ONLY) <> 0) then + begin + Result := E_INVALIDARG; + Exit; + end; + lck := TLockIt.Create(Self); + if ((dwFlags and DMO_SET_TYPEF_CLEAR) <> 0) then + begin + MoFreeMediaType(@m_OutputInfo[ulStreamIndex].CurrentMediaType); + m_OutputInfo[ulStreamIndex].fTypeSet := 0; + if (not CheckTypesSet) then + begin + Flush; + FreeStreamingResources; + end; + Result := NOERROR; + Exit; + end; + if (nil = pmt) then + begin + Result := E_POINTER; + Exit; + end; + + Result := InternalCheckOutputType(ulStreamIndex, pmt); + if FAILED(Result) or (Result = S_FALSE) then Exit; + + if ((dwFlags and DMO_SET_TYPEF_TEST_ONLY) <> 0) then + begin + Result := NOERROR; + Exit; + end; + // actually set the type + if (S_OK = MoCopyMediaType(mtTemp, pmt)) then + begin + // Free any previous mediatype + if (OutputTypeSet(ulStreamIndex)) then + MoFreeMediaType(@m_OutputInfo[ulStreamIndex].CurrentMediaType); + m_OutputInfo[ulStreamIndex].CurrentMediaType := mtTemp; + m_OutputInfo[ulStreamIndex].fTypeSet := Integer(True); + CheckTypesSet; + end + else + begin + Result := E_OUTOFMEMORY; + Exit; + end; + Result := NOERROR; +end; + +function TMediaObjectImpl.GetInputStatus(ulStreamIndex: DWORD; out pdwStatus: DWORD): HResult; +var + lck: ILockIt; +begin + if (ulStreamIndex >= NUMBEROFINPUTS) then + begin +{$IFDEF VER120} + Result := DMO_E_INVALIDSTREAMINDEX; +{$ELSE} + Result := Longint(DMO_E_INVALIDSTREAMINDEX); +{$ENDIF} + Exit; + end; + if (nil = @pdwStatus) then + begin + Result := E_POINTER; + Exit; + end; + + pdwStatus := 0; + + lck := TLockIt.Create(Self); + if (not m_fTypesSet) then + begin +{$IFDEF VER120} + Result := DMO_E_TYPE_NOT_SET; +{$ELSE} + Result := Longint(DMO_E_TYPE_NOT_SET); +{$ENDIF} + Exit; + end; + if (InternalAcceptingInput(ulStreamIndex) = S_OK) then + pdwStatus := pdwStatus or DMO_INPUT_STATUSF_ACCEPT_DATA; + Result := NOERROR; +end; + +function TMediaObjectImpl.GetInputMaxLatency(ulStreamIndex: DWORD; out prtLatency: TReferenceTime): HResult; +var + lck: ILockIt; +begin + if (@prtLatency = nil) then + begin + Result := E_POINTER; + Exit; + end; + if (ulStreamIndex >= NUMBEROFINPUTS) then + begin +{$IFDEF VER120} + Result := DMO_E_INVALIDSTREAMINDEX; +{$ELSE} + Result := Longint(DMO_E_INVALIDSTREAMINDEX); +{$ENDIF} + Exit; + end; + lck := TLockIt.Create(Self); + Result := InternalGetInputMaxLatency(ulStreamIndex, prtLatency); +end; + +function TMediaObjectImpl.SetInputMaxLatency(ulStreamIndex: DWORD; rtLatency: TReferenceTime): HResult; +var + lck: ILockIt; +begin + if (ulStreamIndex >= NUMBEROFINPUTS) then + begin +{$IFDEF VER120} + Result := DMO_E_INVALIDSTREAMINDEX; +{$ELSE} + Result := Longint(DMO_E_INVALIDSTREAMINDEX); +{$ENDIF} + Exit; + end; + lck := TLockIt.Create(Self); + Result := InternalSetInputMaxLatency(ulStreamIndex, rtLatency); +end; + +function TMediaObjectImpl.Discontinuity(ulStreamIndex: DWORD): HResult; +var + lck: ILockIt; +begin + if (ulStreamIndex >= NUMBEROFINPUTS) then + begin +{$IFDEF VER120} + Result := DMO_E_INVALIDSTREAMINDEX; +{$ELSE} + Result := Longint(DMO_E_INVALIDSTREAMINDEX); +{$ENDIF} + Exit; + end; + lck := TLockIt.Create(Self); + if (not m_fTypesSet) then + begin +{$IFDEF VER120} + Result := DMO_E_TYPE_NOT_SET; +{$ELSE} + Result := Longint(DMO_E_TYPE_NOT_SET); +{$ENDIF} + Exit; + end; + if (S_OK <> InternalAcceptingInput(ulStreamIndex)) then + begin +{$IFDEF VER120} + Result := DMO_E_NOTACCEPTING; +{$ELSE} + Result := Longint(DMO_E_NOTACCEPTING); +{$ENDIF} + Exit; + end; + Result := InternalDiscontinuity(ulStreamIndex); +end; + +function TMediaObjectImpl.Flush: HResult; +var + lck: ILockIt; +begin + lck := TLockIt.Create(Self); + if (not m_fTypesSet) then + begin + Result := S_OK; + Exit; + end; + if (m_fFlushed) then + begin + Result := S_OK; + Exit; + end; + Result := InternalFlush; + m_fFlushed := True; +end; + +function TMediaObjectImpl.AllocateStreamingResources: HResult; +var + lck: ILockIt; +begin + lck := TLockIt.Create(Self); + if (not m_fTypesSet) then + begin +{$IFDEF VER120} + Result := DMO_E_TYPE_NOT_SET; +{$ELSE} + Result := Longint(DMO_E_TYPE_NOT_SET); +{$ENDIF} + Exit; + end; + if (m_fResourcesAllocated) then + begin + Result := S_OK; + Exit; + end; + Result := InternalAllocateStreamingResources; + if SUCCEEDED(Result) then m_fResourcesAllocated := True; +end; + +function TMediaObjectImpl.FreeStreamingResources: HResult; +var + lck: ILockIt; +begin + lck := TLockIt.Create(Self); + if (m_fResourcesAllocated) then + begin + m_fResourcesAllocated := False; + InternalFlush; + Result := InternalFreeStreamingResources; + Exit; + end; + Result := S_OK; +end; + +// +// Processing methods - public entry points +// +function TMediaObjectImpl.ProcessInput(ulStreamIndex: DWORD; pBuffer: IMediaBuffer; dwFlags: DWORD; + rtTimestamp, rtTimelength: TReferenceTime): HResult; stdcall; +var + lck: ILockIt; +begin + if (nil = pBuffer) then + begin + Result := E_POINTER; + Exit; + end; + if (ulStreamIndex >= NUMBEROFINPUTS) then + begin +{$IFDEF VER120} + Result := DMO_E_INVALIDSTREAMINDEX; +{$ELSE} + Result := Longint(DMO_E_INVALIDSTREAMINDEX); +{$ENDIF} + Exit; + end; + if ((dwFlags and not (DMO_INPUT_DATA_BUFFERF_SYNCPOINT or + DMO_INPUT_DATA_BUFFERF_TIME or + DMO_INPUT_DATA_BUFFERF_TIMELENGTH)) <> 0) then + begin + Result := E_INVALIDARG; + Exit; + end; + + lck := TLockIt.Create(Self); + + // Make sure all streams have media types set and resources are allocated + Result := AllocateStreamingResources; + if FAILED(Result) then Exit; + + if (InternalAcceptingInput(ulStreamIndex) <> S_OK) then + begin +{$IFDEF VER120} + Result := DMO_E_NOTACCEPTING; +{$ELSE} + Result := Longint(DMO_E_NOTACCEPTING); +{$ENDIF} + Exit; + end; + m_fFlushed := False; + Result := InternalProcessInput(ulStreamIndex, pBuffer, dwFlags, rtTimestamp, rtTimelength); +end; + +function TMediaObjectImpl.ProcessOutput(dwFlags, cOutputBufferCount: DWORD; var pOutputBuffers: TDMOOutputDataBufferArray; + out pdwStatus: DWORD): HResult; stdcall; +var + dw: Integer; + lck: ILockIt; +begin + if (@pdwStatus = nil) then + begin + Result:= E_POINTER; + Exit; + end; + if (cOutputBufferCount <> NUMBEROFOUTPUTS) or + ((dwFlags and not DMO_PROCESS_OUTPUT_DISCARD_WHEN_NO_BUFFER) <> 0) then + begin + Result := E_INVALIDARG; + Exit; + end; + if ((NUMBEROFOUTPUTS <> 0) and (@pOutputBuffers = nil)) then + begin + Result := E_POINTER; + Exit; + end; + + pdwStatus := 0; + + lck := TLockIt.Create(Self); + + Result := AllocateStreamingResources; + if (FAILED(Result)) then Exit; + + for dw := 0 to NUMBEROFOUTPUTS - 1 do pOutputBuffers[dw].dwStatus := 0; + + Result := InternalProcessOutput(dwFlags, cOutputBufferCount, pOutputBuffers, pdwStatus); + + // remember the DMO's incomplete status + for dw := 0 to NUMBEROFOUTPUTS - 1 do + begin + if ((pOutputBuffers[dw].dwStatus and DMO_OUTPUT_DATA_BUFFERF_INCOMPLETE) <> 0) + then m_OutputInfo[dw].fIncomplete := Integer(True) + else m_OutputInfo[dw].fIncomplete := Integer(False); + end; +end; + +function TMediaObjectImpl.Lock(bLock: Longint): HResult; stdcall; +begin + if (bLock <> 0) then Lock else Unlock; + Result := S_Ok; +end; + +procedure TMediaObjectImpl.Lock; +begin + fCritSection.Enter; +end; + +procedure TMediaObjectImpl.Unlock; +begin + fCritSection.Leave; +end; +{$ENDIF} + +initialization +{$IFDEF DIRECTSHOW9_DYNAMIC_LINK} + _QzInitialize := nil; + _QzUninitialize := nil; + _QzFreeUnusedLibraries := nil; + _QzGetMalloc := nil; + _QzTaskMemAlloc := nil; + _QzTaskMemRealloc := nil; + _QzTaskMemFree := nil; + _QzCreateFilterObject := nil; + _QzCLSIDFromString := nil; + _QzStringFromGUID2 := nil; +{$ENDIF} + +finalization +{$IFDEF DIRECTSHOW9_DYNAMIC_LINK} + UnLoadOle32; + UnLoadQuartz; + UnLoadMSDmo; + UnLoadksUser; + UnLoadKsProxy; +{$ENDIF} + +end. -- cgit v1.2.3