模拟服务器

开发平台：

C/C++

KsMedia.h：源码内容

// bit field definitions for MPEG2 VIDEO mode
//
#define KSMPEGVIDMODE_PANSCAN 0x0001
#define KSMPEGVIDMODE_LTRBOX 0x0002
#define KSMPEGVIDMODE_SCALE 0x0004
//
// rectangle definitions for the 4/3 and 16/9 cropping properties of
// the MPEG2Video decoder
//
typedef struct _KSMPEGVID_RECT {
ULONG StartX;
ULONG StartY;
ULONG EndX;
ULONG EndY;
} KSMPEGVID_RECT, *PKSMPEGVID_RECT;
//
// Params for pan / scan
//
//
// MPEG2 Audio definition
//
#define STATIC_KSDATAFORMAT_SUBTYPE_MPEG2_AUDIO
0xe06d802bL, 0xdb46, 0x11cf, 0xb4, 0xd1, 0x00, 0x80, 0x5f, 0x6c, 0xbb, 0xea
DEFINE_GUIDSTRUCT("e06d802b-db46-11cf-b4d1-00805f6cbbea", KSDATAFORMAT_SUBTYPE_MPEG2_AUDIO);
#define KSDATAFORMAT_SUBTYPE_MPEG2_AUDIO DEFINE_GUIDNAMED(KSDATAFORMAT_SUBTYPE_MPEG2_AUDIO)
#define STATIC_KSDATAFORMAT_SPECIFIER_MPEG2_AUDIO
0xe06d80e5L, 0xdb46, 0x11cf, 0xb4, 0xd1, 0x00, 0x80, 0x5f, 0x6c, 0xbb, 0xea
DEFINE_GUIDSTRUCT("e06d80e5-db46-11cf-b4d1-00805f6cbbea", KSDATAFORMAT_SPECIFIER_MPEG2_AUDIO);
#define KSDATAFORMAT_SPECIFIER_MPEG2_AUDIO DEFINE_GUIDNAMED(KSDATAFORMAT_SPECIFIER_MPEG2_AUDIO)
//
// DVD LPCM Audio definition
//
#define STATIC_KSDATAFORMAT_SUBTYPE_LPCM_AUDIO
0xe06d8032L, 0xdb46, 0x11cf, 0xb4, 0xd1, 0x00, 0x80, 0x5f, 0x6c, 0xbb, 0xea
DEFINE_GUIDSTRUCT("e06d8032-db46-11cf-b4d1-00805f6cbbea", KSDATAFORMAT_SUBTYPE_LPCM_AUDIO);
#define KSDATAFORMAT_SUBTYPE_LPCM_AUDIO DEFINE_GUIDNAMED(KSDATAFORMAT_SUBTYPE_LPCM_AUDIO)
#define STATIC_KSDATAFORMAT_SPECIFIER_LPCM_AUDIO
0xe06d80e6L, 0xdb46, 0x11cf, 0xb4, 0xd1, 0x00, 0x80, 0x5f, 0x6c, 0xbb, 0xea
DEFINE_GUIDSTRUCT("e06d80e6-db46-11cf-b4d1-00805f6cbbea", KSDATAFORMAT_SPECIFIER_LPCM_AUDIO);
#define KSDATAFORMAT_SPECIFIER_LPCM_AUDIO DEFINE_GUIDNAMED(KSDATAFORMAT_SPECIFIER_LPCM_AUDIO)
//
// AC-3 definition
//
#define STATIC_KSDATAFORMAT_SUBTYPE_AC3_AUDIO
0xe06d802cL, 0xdb46, 0x11cf, 0xb4, 0xd1, 0x00, 0x80, 0x5f, 0x6c, 0xbb, 0xea
DEFINE_GUIDSTRUCT("e06d802c-db46-11cf-b4d1-00805f6cbbea", KSDATAFORMAT_SUBTYPE_AC3_AUDIO);
#define KSDATAFORMAT_SUBTYPE_AC3_AUDIO DEFINE_GUIDNAMED(KSDATAFORMAT_SUBTYPE_AC3_AUDIO)
#define STATIC_KSDATAFORMAT_SPECIFIER_AC3_AUDIO
0xe06d80e4L, 0xdb46, 0x11cf, 0xb4, 0xd1, 0x00, 0x80, 0x5f, 0x6c, 0xbb, 0xea
DEFINE_GUIDSTRUCT("e06d80e4-db46-11cf-b4d1-00805f6cbbea", KSDATAFORMAT_SPECIFIER_AC3_AUDIO);
#define KSDATAFORMAT_SPECIFIER_AC3_AUDIO DEFINE_GUIDNAMED(KSDATAFORMAT_SPECIFIER_AC3_AUDIO)
#define STATIC_KSPROPSETID_AC3
0xBFABE720L, 0x6E1F, 0x11D0, 0xBC, 0xF2, 0x44, 0x45, 0x53, 0x54, 0x00, 0x00
DEFINE_GUIDSTRUCT("BFABE720-6E1F-11D0-BCF2-444553540000", KSPROPSETID_AC3);
#define KSPROPSETID_AC3 DEFINE_GUIDNAMED(KSPROPSETID_AC3)
typedef enum {
KSPROPERTY_AC3_ERROR_CONCEALMENT = 1,
KSPROPERTY_AC3_ALTERNATE_AUDIO,
KSPROPERTY_AC3_DOWNMIX,
KSPROPERTY_AC3_BIT_STREAM_MODE,
KSPROPERTY_AC3_DIALOGUE_LEVEL,
KSPROPERTY_AC3_LANGUAGE_CODE,
KSPROPERTY_AC3_ROOM_TYPE
} KSPROPERTY_AC3;
typedef struct {
BOOL fRepeatPreviousBlock;
BOOL fErrorInCurrentBlock;
} KSAC3_ERROR_CONCEALMENT, *PKSAC3_ERROR_CONCEALMENT;
typedef struct {
BOOL fStereo;
ULONG DualMode;
} KSAC3_ALTERNATE_AUDIO, *PKSAC3_ALTERNATE_AUDIO;
#define KSAC3_ALTERNATE_AUDIO_1 1
#define KSAC3_ALTERNATE_AUDIO_2 2
#define KSAC3_ALTERNATE_AUDIO_BOTH 3
typedef struct {
BOOL fDownMix;
BOOL fDolbySurround;
} KSAC3_DOWNMIX, *PKSAC3_DOWNMIX;
typedef struct {
LONG BitStreamMode;
} KSAC3_BIT_STREAM_MODE, *PKSAC3_BIT_STREAM_MODE;
#define KSAC3_SERVICE_MAIN_AUDIO 0
#define KSAC3_SERVICE_NO_DIALOG 1
#define KSAC3_SERVICE_VISUALLY_IMPAIRED 2
#define KSAC3_SERVICE_HEARING_IMPAIRED 3
#define KSAC3_SERVICE_DIALOG_ONLY 4
#define KSAC3_SERVICE_COMMENTARY 5
#define KSAC3_SERVICE_EMERGENCY_FLASH 6
#define KSAC3_SERVICE_VOICE_OVER 7
typedef struct {
ULONG DialogueLevel;
} KSAC3_DIALOGUE_LEVEL, *PKSAC3_DIALOGUE_LEVEL;
typedef struct {
BOOL fLargeRoom;
} KSAC3_ROOM_TYPE, *PKSAC3_ROOM_TYPE;
//
// DTS and SDDS definitions (media subtype GUIDs)
//
#define STATIC_KSDATAFORMAT_SUBTYPE_DTS_AUDIO
0xe06d8033L, 0xdb46, 0x11cf, 0xb4, 0xd1, 0x00, 0x80, 0x5f, 0x6c, 0xbb, 0xea
DEFINE_GUIDSTRUCT("e06d8033-db46-11cf-b4d1-00805f6cbbea", KSDATAFORMAT_SUBTYPE_DTS_AUDIO);
#define KSDATAFORMAT_SUBTYPE_DTS_AUDIO DEFINE_GUIDNAMED(KSDATAFORMAT_SUBTYPE_DTS_AUDIO)
#define STATIC_KSDATAFORMAT_SUBTYPE_SDDS_AUDIO
0xe06d8034L, 0xdb46, 0x11cf, 0xb4, 0xd1, 0x00, 0x80, 0x5f, 0x6c, 0xbb, 0xea
DEFINE_GUIDSTRUCT("e06d8034-db46-11cf-b4d1-00805f6cbbea", KSDATAFORMAT_SUBTYPE_SDDS_AUDIO);
#define KSDATAFORMAT_SUBTYPE_SDDS_AUDIO DEFINE_GUIDNAMED(KSDATAFORMAT_SUBTYPE_SDDS_AUDIO)
//
// audio decoder output properties
//
#define STATIC_KSPROPSETID_AudioDecoderOut
0x6ca6e020L, 0x43bd, 0x11d0, 0xbd, 0x6a, 0x00, 0x35, 0x05, 0xc1, 0x03, 0xa9
DEFINE_GUIDSTRUCT("6ca6e020-43bd-11d0-bd6a-003505c103a9", KSPROPSETID_AudioDecoderOut);
#define KSPROPSETID_AudioDecoderOut DEFINE_GUIDNAMED(KSPROPSETID_AudioDecoderOut)
typedef enum {
KSPROPERTY_AUDDECOUT_MODES, // available output modes of decoder
KSPROPERTY_AUDDECOUT_CUR_MODE, // current mode of the decoder
} KSPROPERTY_AUDDECOUT;
#define KSAUDDECOUTMODE_STEREO_ANALOG 0x0001
#define KSAUDDECOUTMODE_PCM_51 0x0002
#define KSAUDDECOUTMODE_SPDIFF 0x0004
//
// subpicture definition
//
#define STATIC_KSDATAFORMAT_SUBTYPE_SUBPICTURE
0xe06d802dL, 0xdb46, 0x11cf, 0xb4, 0xd1, 0x00, 0x80, 0x5f, 0x6c, 0xbb, 0xea
DEFINE_GUIDSTRUCT("e06d802d-db46-11cf-b4d1-00805f6cbbea", KSDATAFORMAT_SUBTYPE_SUBPICTURE);
#define KSDATAFORMAT_SUBTYPE_SUBPICTURE DEFINE_GUIDNAMED(KSDATAFORMAT_SUBTYPE_SUBPICTURE)
#define STATIC_KSPROPSETID_DvdSubPic
0xac390460L, 0x43af, 0x11d0, 0xbd, 0x6a, 0x00, 0x35, 0x05, 0xc1, 0x03, 0xa9
DEFINE_GUIDSTRUCT("ac390460-43af-11d0-bd6a-003505c103a9", KSPROPSETID_DvdSubPic);
#define KSPROPSETID_DvdSubPic DEFINE_GUIDNAMED(KSPROPSETID_DvdSubPic)
typedef enum {
KSPROPERTY_DVDSUBPIC_PALETTE,
KSPROPERTY_DVDSUBPIC_HLI,
KSPROPERTY_DVDSUBPIC_COMPOSIT_ON, // TRUE for subpicture is displayed
} KSPROPERTY_DVDSUBPIC;
typedef struct _KS_DVD_YCrCb {
UCHAR Reserved;
UCHAR Y;
UCHAR Cr;
UCHAR Cb;
} KS_DVD_YCrCb, *PKS_DVD_YCrCb;
/* The KS_DVD_YUV structure is now superseded by KS_DVD_YCrCb above and is
here for backward compatibility only */
typedef struct _KS_DVD_YUV {
UCHAR Reserved;
UCHAR Y;
UCHAR V;
UCHAR U;
} KS_DVD_YUV, *PKS_DVD_YUV;
typedef struct _KSPROPERTY_SPPAL {
KS_DVD_YUV sppal[16];
} KSPROPERTY_SPPAL, *PKSPROPERTY_SPPAL;
typedef struct _KS_COLCON {
UCHAR emph1col:4;
UCHAR emph2col:4;
UCHAR backcol:4;
UCHAR patcol:4;
UCHAR emph1con:4;
UCHAR emph2con:4;
UCHAR backcon:4;
UCHAR patcon:4;
} KS_COLCON, *PKS_COLCON;
typedef struct _KSPROPERTY_SPHLI {
USHORT HLISS;
USHORT Reserved;
ULONG StartPTM; // start presentation time in x/90000
ULONG EndPTM; // end PTM in x/90000
USHORT StartX;
USHORT StartY;
USHORT StopX;
USHORT StopY;
KS_COLCON ColCon; // color contrast description (4 bytes as given in HLI)
} KSPROPERTY_SPHLI, *PKSPROPERTY_SPHLI;
typedef BOOL KSPROPERTY_COMPOSIT_ON, *PKSPROPERTY_COMPOSIT_ON;
#define STATIC_KSPROPSETID_CopyProt
0x0E8A0A40L, 0x6AEF, 0x11D0, 0x9E, 0xD0, 0x00, 0xA0, 0x24, 0xCA, 0x19, 0xB3
DEFINE_GUIDSTRUCT("0E8A0A40-6AEF-11D0-9ED0-00A024CA19B3", KSPROPSETID_CopyProt);
#define KSPROPSETID_CopyProt DEFINE_GUIDNAMED(KSPROPSETID_CopyProt)
typedef enum {
KSPROPERTY_DVDCOPY_CHLG_KEY = 0x01,
KSPROPERTY_DVDCOPY_DVD_KEY1,
KSPROPERTY_DVDCOPY_DEC_KEY2,
KSPROPERTY_DVDCOPY_TITLE_KEY,
KSPROPERTY_COPY_MACROVISION,
KSPROPERTY_DVDCOPY_REGION,
KSPROPERTY_DVDCOPY_SET_COPY_STATE,
KSPROPERTY_DVDCOPY_DISC_KEY = 0x80
} KSPROPERTY_COPYPROT;
typedef struct _KS_DVDCOPY_CHLGKEY {
BYTE ChlgKey[10];
BYTE Reserved[2];
} KS_DVDCOPY_CHLGKEY, *PKS_DVDCOPY_CHLGKEY;
typedef struct _KS_DVDCOPY_BUSKEY {
BYTE BusKey[5];
BYTE Reserved[1];
} KS_DVDCOPY_BUSKEY, *PKS_DVDCOPY_BUSKEY;
typedef struct _KS_DVDCOPY_DISCKEY {
BYTE DiscKey[2048];
} KS_DVDCOPY_DISCKEY, *PKS_DVDCOPY_DISCKEY;
typedef struct _KS_DVDCOPY_REGION {
UCHAR Reserved;
UCHAR RegionData;
UCHAR Reserved2[2];
} KS_DVDCOPY_REGION, *PKS_DVDCOPY_REGION;
typedef struct _KS_DVDCOPY_TITLEKEY {
ULONG KeyFlags;
ULONG ReservedNT[2];
UCHAR TitleKey[6];
UCHAR Reserved[2];
} KS_DVDCOPY_TITLEKEY, *PKS_DVDCOPY_TITLEKEY;
typedef struct _KS_COPY_MACROVISION {
ULONG MACROVISIONLevel;
} KS_COPY_MACROVISION, *PKS_COPY_MACROVISION;
typedef struct _KS_DVDCOPY_SET_COPY_STATE {
ULONG DVDCopyState;
} KS_DVDCOPY_SET_COPY_STATE, *PKS_DVDCOPY_SET_COPY_STATE;
typedef enum {
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,
} KS_DVDCOPYSTATE;
typedef enum {
KS_MACROVISION_DISABLED,
KS_MACROVISION_LEVEL1,
KS_MACROVISION_LEVEL2,
KS_MACROVISION_LEVEL3
} KS_COPY_MACROVISION_LEVEL, *PKS_COPY_MACROVISION_LEVEL;
//
// CGMS Copy Protection Flags
//
#define KS_DVD_CGMS_RESERVED_MASK 0x00000078
#define KS_DVD_CGMS_COPY_PROTECT_MASK 0x00000018
#define KS_DVD_CGMS_COPY_PERMITTED 0x00000000
#define KS_DVD_CGMS_COPY_ONCE 0x00000010
#define KS_DVD_CGMS_NO_COPY 0x00000018
#define KS_DVD_COPYRIGHT_MASK 0x00000040
#define KS_DVD_NOT_COPYRIGHTED 0x00000000
#define KS_DVD_COPYRIGHTED 0x00000040
#define KS_DVD_SECTOR_PROTECT_MASK 0x00000020
#define KS_DVD_SECTOR_NOT_PROTECTED 0x00000000
#define KS_DVD_SECTOR_PROTECTED 0x00000020
//===========================================================================
// The following MUST match the structures in WinGDI.h and AMVideo.h
//===========================================================================
#define STATIC_KSCATEGORY_TVTUNER
0xa799a800L, 0xa46d, 0x11d0, 0xa1, 0x8c, 0x00, 0xa0, 0x24, 0x01, 0xdc, 0xd4
DEFINE_GUIDSTRUCT("a799a800-a46d-11d0-a18c-00a02401dcd4", KSCATEGORY_TVTUNER);
#define KSCATEGORY_TVTUNER DEFINE_GUIDNAMED(KSCATEGORY_TVTUNER)
#define STATIC_KSCATEGORY_CROSSBAR
0xa799a801L, 0xa46d, 0x11d0, 0xa1, 0x8c, 0x00, 0xa0, 0x24, 0x01, 0xdc, 0xd4
DEFINE_GUIDSTRUCT("a799a801-a46d-11d0-a18c-00a02401dcd4", KSCATEGORY_CROSSBAR);
#define KSCATEGORY_CROSSBAR DEFINE_GUIDNAMED(KSCATEGORY_CROSSBAR)
#define STATIC_KSCATEGORY_TVAUDIO
0xa799a802L, 0xa46d, 0x11d0, 0xa1, 0x8c, 0x00, 0xa0, 0x24, 0x01, 0xdc, 0xd4
DEFINE_GUIDSTRUCT("a799a802-a46d-11d0-a18c-00a02401dcd4", KSCATEGORY_TVAUDIO);
#define KSCATEGORY_TVAUDIO DEFINE_GUIDNAMED(KSCATEGORY_TVAUDIO)
#define STATIC_KSCATEGORY_VPMUX
0xa799a803L, 0xa46d, 0x11d0, 0xa1, 0x8c, 0x00, 0xa0, 0x24, 0x01, 0xdc, 0xd4
DEFINE_GUIDSTRUCT("a799a803-a46d-11d0-a18c-00a02401dcd4", KSCATEGORY_VPMUX);
#define KSCATEGORY_VPMUX DEFINE_GUIDNAMED(KSCATEGORY_VPMUX)
#define STATIC_KSCATEGORY_VBICODEC
0x07dad660L, 0x22f1, 0x11d1, 0xa9, 0xf4, 0x00, 0xc0, 0x4f, 0xbb, 0xde, 0x8f
DEFINE_GUIDSTRUCT("07dad660-22f1-11d1-a9f4-00c04fbbde8f", KSCATEGORY_VBICODEC);
#define KSCATEGORY_VBICODEC DEFINE_GUIDNAMED(KSCATEGORY_VBICODEC)
// SUBTYPE_VPVideo
#define STATIC_KSDATAFORMAT_SUBTYPE_VPVideo
0x5a9b6a40L, 0x1a22, 0x11d1, 0xba, 0xd9, 0x0, 0x60, 0x97, 0x44, 0x11, 0x1a
DEFINE_GUIDSTRUCT("5a9b6a40-1a22-11d1-bad9-00609744111a", KSDATAFORMAT_SUBTYPE_VPVideo);
#define KSDATAFORMAT_SUBTYPE_VPVideo DEFINE_GUIDNAMED(KSDATAFORMAT_SUBTYPE_VPVideo)
// SUBTYPE_VPVBI
#define STATIC_KSDATAFORMAT_SUBTYPE_VPVBI
0x5a9b6a41L, 0x1a22, 0x11d1, 0xba, 0xd9, 0x0, 0x60, 0x97, 0x44, 0x11, 0x1a
DEFINE_GUIDSTRUCT("5a9b6a41-1a22-11d1-bad9-00609744111a", KSDATAFORMAT_SUBTYPE_VPVBI);
#define KSDATAFORMAT_SUBTYPE_VPVBI DEFINE_GUIDNAMED(KSDATAFORMAT_SUBTYPE_VPVBI)
// FORMAT_VideoInfo
#define STATIC_KSDATAFORMAT_SPECIFIER_VIDEOINFO
0x05589f80L, 0xc356, 0x11ce, 0xbf, 0x01, 0x00, 0xaa, 0x00, 0x55, 0x59, 0x5a
DEFINE_GUIDSTRUCT("05589f80-c356-11ce-bf01-00aa0055595a", KSDATAFORMAT_SPECIFIER_VIDEOINFO);
#define KSDATAFORMAT_SPECIFIER_VIDEOINFO DEFINE_GUIDNAMED(KSDATAFORMAT_SPECIFIER_VIDEOINFO)
// FORMAT_VideoInfo2
#define STATIC_KSDATAFORMAT_SPECIFIER_VIDEOINFO2
0xf72a76A0L, 0xeb0a, 0x11d0, 0xac, 0xe4, 0x00, 0x00, 0xc0, 0xcc, 0x16, 0xba
DEFINE_GUIDSTRUCT("f72a76A0-eb0a-11d0-ace4-0000c0cc16ba", KSDATAFORMAT_SPECIFIER_VIDEOINFO2);
#define KSDATAFORMAT_SPECIFIER_VIDEOINFO2 DEFINE_GUIDNAMED(KSDATAFORMAT_SPECIFIER_VIDEOINFO2)
// MEDIATYPE_AnalogVideo
#define STATIC_KSDATAFORMAT_TYPE_ANALOGVIDEO
0x0482dde1L, 0x7817, 0x11cf, 0x8a, 0x03, 0x00, 0xaa, 0x00, 0x6e, 0xcb, 0x65
DEFINE_GUIDSTRUCT("0482dde1-7817-11cf-8a03-00aa006ecb65", KSDATAFORMAT_TYPE_ANALOGVIDEO);
#define KSDATAFORMAT_TYPE_ANALOGVIDEO DEFINE_GUIDNAMED(KSDATAFORMAT_TYPE_ANALOGVIDEO)
// FORMAT_AnalogVideo
#define STATIC_KSDATAFORMAT_SPECIFIER_ANALOGVIDEO
0x0482dde0L, 0x7817, 0x11cf, 0x8a, 0x03, 0x00, 0xaa, 0x00, 0x6e, 0xcb, 0x65
DEFINE_GUIDSTRUCT("0482dde0-7817-11cf-8a03-00aa006ecb65", KSDATAFORMAT_SPECIFIER_ANALOGVIDEO);
#define KSDATAFORMAT_SPECIFIER_ANALOGVIDEO DEFINE_GUIDNAMED(KSDATAFORMAT_SPECIFIER_ANALOGVIDEO)
// FORMAT_VBI
#define STATIC_KSDATAFORMAT_SPECIFIER_VBI
0xf72a76e0L, 0xeb0a, 0x11d0, 0xac, 0xe4, 0x00, 0x00, 0xc0, 0xcc, 0x16, 0xba
DEFINE_GUIDSTRUCT("f72a76e0-eb0a-11d0-ace4-0000c0cc16ba", KSDATAFORMAT_SPECIFIER_VBI);
#define KSDATAFORMAT_SPECIFIER_VBI DEFINE_GUIDNAMED(KSDATAFORMAT_SPECIFIER_VBI)
// MEDIATYPE_VBI
#define STATIC_KSDATAFORMAT_TYPE_VBI
0xf72a76e1L, 0xeb0a, 0x11d0, 0xac, 0xe4, 0x00, 0x00, 0xc0, 0xcc, 0x16, 0xba
DEFINE_GUIDSTRUCT("f72a76e1-eb0a-11d0-ace4-0000c0cc16ba", KSDATAFORMAT_TYPE_VBI);
#define KSDATAFORMAT_TYPE_VBI DEFINE_GUIDNAMED(KSDATAFORMAT_TYPE_VBI)
// SUBTYPE_RAW8
#define STATIC_KSDATAFORMAT_SUBTYPE_RAW8
0xca20d9a0, 0x3e3e, 0x11d1, 0x9b, 0xf9, 0x0, 0xc0, 0x4f, 0xbb, 0xde, 0xbf
DEFINE_GUIDSTRUCT("ca20d9a0-3e3e-11d1-9bf9-00c04fbbdebf", KSDATAFORMAT_SUBTYPE_RAW8);
#define KSDATAFORMAT_SUBTYPE_RAW8 DEFINE_GUIDNAMED(KSDATAFORMAT_SUBTYPE_RAW8)
// MEDIASUBTYPE_CC
#define STATIC_KSDATAFORMAT_SUBTYPE_CC
0x33214cc1, 0x11f, 0x11d2, 0xb4, 0xb1, 0x0, 0xa0, 0xd1, 0x2, 0xcf, 0xbe
DEFINE_GUIDSTRUCT("33214CC1-011F-11D2-B4B1-00A0D102CFBE", KSDATAFORMAT_SUBTYPE_CC);
#define KSDATAFORMAT_SUBTYPE_CC DEFINE_GUIDNAMED(KSDATAFORMAT_SUBTYPE_CC)
// MEDIASUBTYPE_NABTS
#define STATIC_KSDATAFORMAT_SUBTYPE_NABTS
0xf72a76e2L, 0xeb0a, 0x11d0, 0xac, 0xe4, 0x00, 0x00, 0xc0, 0xcc, 0x16, 0xba
DEFINE_GUIDSTRUCT("f72a76e2-eb0a-11d0-ace4-0000c0cc16ba", KSDATAFORMAT_SUBTYPE_NABTS);
#define KSDATAFORMAT_SUBTYPE_NABTS DEFINE_GUIDNAMED(KSDATAFORMAT_SUBTYPE_NABTS)
// MEDIASUBTYPE_TELETEXT
#define STATIC_KSDATAFORMAT_SUBTYPE_TELETEXT
0xf72a76e3L, 0xeb0a, 0x11d0, 0xac, 0xe4, 0x00, 0x00, 0xc0, 0xcc, 0x16, 0xba
DEFINE_GUIDSTRUCT("f72a76e3-eb0a-11d0-ace4-0000c0cc16ba", KSDATAFORMAT_SUBTYPE_TELETEXT);
#define KSDATAFORMAT_SUBTYPE_TELETEXT DEFINE_GUIDNAMED(KSDATAFORMAT_SUBTYPE_TELETEXT)
/* constants for the biCompression field */
#define KS_BI_RGB 0L
#define KS_BI_RLE8 1L
#define KS_BI_RLE4 2L
#define KS_BI_BITFIELDS 3L
typedef struct tagKS_RGBQUAD { // rgbq
BYTE rgbBlue;
BYTE rgbGreen;
BYTE rgbRed;
BYTE rgbReserved;
} KS_RGBQUAD, *PKS_RGBQUAD;
/* constants for palettes */
#define KS_iPALETTE_COLORS 256 // Maximum colours in palette
#define KS_iEGA_COLORS 16 // Number colours in EGA palette
#define KS_iMASK_COLORS 3 // Maximum three components
#define KS_iTRUECOLOR 16 // Minimum true colour device
#define KS_iRED 0 // Index position for RED mask
#define KS_iGREEN 1 // Index position for GREEN mask
#define KS_iBLUE 2 // Index position for BLUE mask
#define KS_iPALETTE 8 // Maximum colour depth using a palette
#define KS_iMAXBITS 8 // Maximum bits per colour component
#define KS_SIZE_EGA_PALETTE (KS_iEGA_COLORS * sizeof(KS_RGBQUAD))
#define KS_SIZE_PALETTE (KS_iPALETTE_COLORS * sizeof(KS_RGBQUAD))
typedef struct tagKS_BITMAPINFOHEADER{
DWORD biSize;
LONG biWidth;
LONG biHeight;
WORD biPlanes;
WORD biBitCount;
DWORD biCompression;
DWORD biSizeImage;
LONG biXPelsPerMeter;
LONG biYPelsPerMeter;
DWORD biClrUsed;
DWORD biClrImportant;
} KS_BITMAPINFOHEADER, *PKS_BITMAPINFOHEADER;
// Used for true colour images that also have a palette
typedef struct tag_KS_TRUECOLORINFO {
DWORD dwBitMasks[KS_iMASK_COLORS];
KS_RGBQUAD bmiColors[KS_iPALETTE_COLORS];
} KS_TRUECOLORINFO, *PKS_TRUECOLORINFO;
#define KS_WIDTHBYTES(bits) ((DWORD)(((bits)+31) & (~31)) / 8)
#define KS_DIBWIDTHBYTES(bi) (DWORD)KS_WIDTHBYTES((DWORD)(bi).biWidth * (DWORD)(bi).biBitCount)
#define KS__DIBSIZE(bi) (KS_DIBWIDTHBYTES(bi) * (DWORD)(bi).biHeight)
#define KS_DIBSIZE(bi) ((bi).biHeight < 0 ? (-1)*(KS__DIBSIZE(bi)) : KS__DIBSIZE(bi))
typedef LONGLONG REFERENCE_TIME;
// 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
typedef struct tagKS_VIDEOINFOHEADER {
RECT rcSource; // The bit we really want to use
RECT rcTarget; // Where the video should go
DWORD dwBitRate; // Approximate bit data rate
DWORD dwBitErrorRate; // Bit error rate for this stream
REFERENCE_TIME AvgTimePerFrame; // Average time per frame (100ns units)
KS_BITMAPINFOHEADER bmiHeader;
} KS_VIDEOINFOHEADER, *PKS_VIDEOINFOHEADER;
// !!! WARNING !!!
// DO NOT use the following structure unless you are sure that the BITMAPINFOHEADER
// has a normal biSize == sizeof(BITMAPINFOHEADER) !
// !!! WARNING !!!
typedef struct tagKS_VIDEOINFO {
RECT rcSource; // The bit we really want to use
RECT rcTarget; // Where the video should go
DWORD dwBitRate; // Approximate bit data rate
DWORD dwBitErrorRate; // Bit error rate for this stream
REFERENCE_TIME AvgTimePerFrame; // Average time per frame (100ns units)
KS_BITMAPINFOHEADER bmiHeader;
union {
KS_RGBQUAD bmiColors[KS_iPALETTE_COLORS]; // Colour palette
DWORD dwBitMasks[KS_iMASK_COLORS]; // True colour masks
KS_TRUECOLORINFO TrueColorInfo; // Both of the above
};
} KS_VIDEOINFO, *PKS_VIDEOINFO;
#define KS_SIZE_MASKS (KS_iMASK_COLORS * sizeof(DWORD))
#define 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, WST
typedef struct tagKS_VBIINFOHEADER {
ULONG StartLine; // inclusive
ULONG EndLine; // inclusive
ULONG SamplingFrequency; // Hz.
ULONG MinLineStartTime; // microSec * 100 from HSync LE
ULONG MaxLineStartTime; // microSec * 100 from HSync LE
ULONG ActualLineStartTime; // microSec * 100 from HSync LE
ULONG ActualLineEndTime; // microSec * 100 from HSync LE
ULONG VideoStandard; // KS_AnalogVideoStandard*
ULONG SamplesPerLine;
ULONG StrideInBytes; // May be > SamplesPerLine
ULONG BufferSize; // Bytes
} KS_VBIINFOHEADER, *PKS_VBIINFOHEADER;
// VBI Sampling Rates
#define KS_VBIDATARATE_NABTS (5727272L)
#define KS_VBIDATARATE_CC ( 503493L) // ~= 1/1.986125e-6
#define KS_VBISAMPLINGRATE_4X_NABTS ((long)(4*KS_VBIDATARATE_NABTS))
#define KS_VBISAMPLINGRATE_47X_NABTS ((long)(27000000))
#define KS_VBISAMPLINGRATE_5X_NABTS ((long)(5*KS_VBIDATARATE_NABTS))
#define KS_47NABTS_SCALER (KS_VBISAMPLINGRATE_47X_NABTS/(double)KS_VBIDATARATE_NABTS)
// 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)
typedef struct tagKS_AnalogVideoInfo {
RECT rcSource; // Width max is 720, height varies w/ TransmissionStd
RECT rcTarget; // Where the video should go
DWORD dwActiveWidth; // Always 720 (CCIR-601 active samples per line)
DWORD dwActiveHeight; // 483 for NTSC, 575 for PAL/SECAM
REFERENCE_TIME AvgTimePerFrame; // Normal ActiveMovie units (100 nS)
} KS_ANALOGVIDEOINFO, *PKS_ANALOGVIDEOINFO;
//===========================================================================
// Data packet passed on Analog video stream channel change
//===========================================================================
#define KS_TVTUNER_CHANGE_BEGIN_TUNE 0x0001L // Starting a tuning operation
#define KS_TVTUNER_CHANGE_END_TUNE 0x0002L // Ending a tuning operation
typedef struct tagKS_TVTUNER_CHANGE_INFO {
DWORD dwFlags; // KS_TVTUNER_CHANGE_*
DWORD dwCountryCode;
DWORD dwAnalogVideoStandard; // KS_AnalogVideoStandard
DWORD dwChannel;
} KS_TVTUNER_CHANGE_INFO, *PKS_TVTUNER_CHANGE_INFO;
//===========================================================================
// Video format blocks
//===========================================================================
typedef enum {
KS_MPEG2Level_Low,
KS_MPEG2Level_Main,
KS_MPEG2Level_High1440,
KS_MPEG2Level_High
} KS_MPEG2Level;
typedef enum {
KS_MPEG2Profile_Simple,
KS_MPEG2Profile_Main,
KS_MPEG2Profile_SNRScalable,
KS_MPEG2Profile_SpatiallyScalable,
KS_MPEG2Profile_High
} KS_MPEG2Profile;
#define KS_INTERLACE_IsInterlaced 0x00000001 // if 0, other interlace bits are irrelevent
#define KS_INTERLACE_1FieldPerSample 0x00000002 // else 2 fields per media sample
#define KS_INTERLACE_Field1First 0x00000004 // else Field 2 is first; top field in PAL is field 1, top field in NTSC is field 2?
#define KS_INTERLACE_UNUSED 0x00000008 //
#define KS_INTERLACE_FieldPatternMask 0x00000030 // use this mask with AMINTERLACE_FieldPat*
#define KS_INTERLACE_FieldPatField1Only 0x00000000 // Data never contains a Field2
#define KS_INTERLACE_FieldPatField2Only 0x00000010 // Data never contains a Field1
#define KS_INTERLACE_FieldPatBothRegular 0x00000020 // There will be a Field2 for every Field1 (required for Weave?)
#define KS_INTERLACE_FieldPatBothIrregular 0x00000030 // Random pattern of Field1s and Field2s
#define KS_INTERLACE_DisplayModeMask 0x000000c0
#define KS_INTERLACE_DisplayModeBobOnly 0x00000000
#define KS_INTERLACE_DisplayModeWeaveOnly 0x00000040
#define KS_INTERLACE_DisplayModeBobOrWeave 0x00000080
#define KS_MPEG2_DoPanScan 0x00000001 //if set, the MPEG-2 video decoder should crop output image
// based on pan-scan vectors in picture_display_extension
// and change the picture aspect ratio accordingly.
#define KS_MPEG2_DVDLine21Field1 0x00000002 //if set, the MPEG-2 decoder must be able to produce an output
// pin for DVD style closed caption data found in GOP layer of field 1
#define KS_MPEG2_DVDLine21Field2 0x00000004 //if set, the MPEG-2 decoder must be able to produce an output
// pin for DVD style closed caption data found in GOP layer of field 2
#define KS_MPEG2_SourceIsLetterboxed 0x00000008 //if set, indicates that black bars have been encoded in the top
// and bottom of the video.
#define KS_MPEG2_FilmCameraMode 0x00000010 //if set, indicates "film mode" used for 625/50 content. If cleared,
// indicates that "camera mode" was used.
#define KS_MPEG2_LetterboxAnalogOut 0x00000020 //if set and this stream is sent to an analog output, it should
// be letterboxed. Streams sent to VGA should be letterboxed only by renderers.
#define KS_MPEG2_DSS_UserData 0x00000040 //if set, the MPEG-2 decoder must process DSS style user data
#define KS_MPEG2_DVB_UserData 0x00000080 //if set, the MPEG-2 decoder must process DVB style user data
#define KS_MPEG2_27MhzTimebase 0x00000100 //if set, the PTS,DTS timestamps advance at 27MHz rather than 90KHz
typedef struct tagKS_VIDEOINFOHEADER2 {
RECT rcSource;
RECT rcTarget;
DWORD dwBitRate;
DWORD dwBitErrorRate;
REFERENCE_TIME AvgTimePerFrame;
DWORD dwInterlaceFlags; // use AMINTERLACE_* defines. Reject connection if undefined bits are not 0
DWORD dwCopyProtectFlags; // use AMCOPYPROTECT_* defines. Reject connection if undefined bits are not 0
DWORD dwPictAspectRatioX; // X dimension of picture aspect ratio, e.g. 16 for 16x9 display
DWORD dwPictAspectRatioY; // Y dimension of picture aspect ratio, e.g. 9 for 16x9 display
DWORD dwReserved1; // must be 0; reject connection otherwise
DWORD dwReserved2; // must be 0; reject connection otherwise
KS_BITMAPINFOHEADER bmiHeader;
} KS_VIDEOINFOHEADER2, *PKS_VIDEOINFOHEADER2;
typedef struct tagKS_MPEG1VIDEOINFO {
KS_VIDEOINFOHEADER hdr; // Compatible with VIDEOINFO
DWORD dwStartTimeCode; // 25-bit Group of pictures time code at start of data
DWORD cbSequenceHeader; // Length in bytes of bSequenceHeader
BYTE bSequenceHeader[1]; // Sequence header including quantization matrices if any
} KS_MPEG1VIDEOINFO, *PKS_MPEG1VIDEOINFO;
#define KS_MAX_SIZE_MPEG1_SEQUENCE_INFO 140
#define KS_SIZE_MPEG1VIDEOINFO(pv) (FIELD_OFFSET(KS_MPEG1VIDEOINFO, bSequenceHeader[0]) + (pv)->cbSequenceHeader)
#define KS_MPEG1_SEQUENCE_INFO(pv) ((const BYTE *)(pv)->bSequenceHeader)
typedef struct tagKS_MPEGVIDEOINFO2 {
KS_VIDEOINFOHEADER2 hdr;
DWORD dwStartTimeCode; // ?? not used for DVD ??
DWORD cbSequenceHeader; // is 0 for DVD (no sequence header)
DWORD dwProfile; // use enum MPEG2Profile
DWORD dwLevel; // use enum MPEG2Level
DWORD dwFlags; // use AMMPEG2_* defines. Reject connection if undefined bits are not 0
DWORD bSequenceHeader[1]; // DWORD instead of Byte for alignment purposes
// For MPEG-2, if a sequence_header is included, the sequence_extension
// should also be included
} KS_MPEGVIDEOINFO2, *PKS_MPEGVIDEOINFO2;
#define KS_SIZE_MPEGVIDEOINFO2(pv) (FIELD_OFFSET(KS_MPEGVIDEOINFO2, bSequenceHeader[0]) + (pv)->cbSequenceHeader)
#define KS_MPEG1_SEQUENCE_INFO(pv) ((const BYTE *)(pv)->bSequenceHeader)
//===========================================================================
// Audio format blocks
//===========================================================================
//if set, the PTS,DTS timestamps advance at 27MHz rather than 90KHz
#define KS_MPEGAUDIOINFO_27MhzTimebase 0x00000001
typedef struct tagKS_MPEAUDIOINFO {
DWORD dwFlags; // use KS_MPEGAUDIOINFO_* defines. Reject connection if undefined bits are not 0
DWORD dwReserved1; // must be 0; reject connection otherwise
DWORD dwReserved2; // must be 0; reject connection otherwise
DWORD dwReserved3; // must be 0; reject connection otherwise
} KS_MPEGAUDIOINFO, *PKS_MPEGAUDIOINFO;
//===========================================================================
// Video DATAFORMATs
//===========================================================================
typedef struct tagKS_DATAFORMAT_VIDEOINFOHEADER {
KSDATAFORMAT DataFormat;
KS_VIDEOINFOHEADER VideoInfoHeader;
} KS_DATAFORMAT_VIDEOINFOHEADER, *PKS_DATAFORMAT_VIDEOINFOHEADER;
typedef struct tagKS_DATAFORMAT_VIDEOINFOHEADER2 {
KSDATAFORMAT DataFormat;
KS_VIDEOINFOHEADER2 VideoInfoHeader2;
} KS_DATAFORMAT_VIDEOINFOHEADER2, *PKS_DATAFORMAT_VIDEOINFOHEADER2;
typedef struct tagKS_DATAFORMAT_VIDEOINFO_PALETTE {
KSDATAFORMAT DataFormat;
KS_VIDEOINFO VideoInfo;
} KS_DATAFORMAT_VIDEOINFO_PALETTE, *PKS_DATAFORMAT_VIDEOINFO_PALETTE;
typedef struct tagKS_DATAFORMAT_VBIINFOHEADER {
KSDATAFORMAT DataFormat;
KS_VBIINFOHEADER VBIInfoHeader;
} KS_DATAFORMAT_VBIINFOHEADER, *PKS_DATAFORMAT_VBIINFOHEADER;
typedef struct _KS_VIDEO_STREAM_CONFIG_CAPS {
GUID guid; // will be MEDIATYPE_Video
ULONG VideoStandard; // logical OR of all AnalogVideoStandards
// supported
SIZE InputSize; // the inherent size of the incoming signal
// (every pixel unique)
SIZE MinCroppingSize; // smallest rcSrc cropping rect allowed
SIZE MaxCroppingSize; // largest rcSrc cropping rect allowed
int CropGranularityX; // granularity of cropping size
int CropGranularityY;
int CropAlignX; // alignment of cropping rect
int CropAlignY;
SIZE MinOutputSize; // smallest bitmap stream can produce
SIZE MaxOutputSize; // largest bitmap stream can produce
int OutputGranularityX; // granularity of output bitmap size
int OutputGranularityY;
int StretchTapsX; // 0, no stretch, 1 pix dup, 2 interp, ...
int StretchTapsY; // Describes quality of hardware scaler
int ShrinkTapsX; //
int ShrinkTapsY; //
LONGLONG MinFrameInterval; // 100 nS units
LONGLONG MaxFrameInterval;
LONG MinBitsPerSecond;
LONG MaxBitsPerSecond;
} KS_VIDEO_STREAM_CONFIG_CAPS, *PKS_VIDEO_STREAM_CONFIG_CAPS;
//===========================================================================
// Video DATARANGEs
//===========================================================================
typedef struct tagKS_DATARANGE_VIDEO {
KSDATARANGE DataRange;
BOOL bFixedSizeSamples; // all samples same size?
BOOL bTemporalCompression; // all I frames?
DWORD StreamDescriptionFlags; // KS_VIDEO_DESC_*
DWORD MemoryAllocationFlags; // KS_VIDEO_ALLOC_*
KS_VIDEO_STREAM_CONFIG_CAPS ConfigCaps;
KS_VIDEOINFOHEADER VideoInfoHeader; // default format
} KS_DATARANGE_VIDEO, *PKS_DATARANGE_VIDEO;
typedef struct tagKS_DATARANGE_VIDEO2 {
KSDATARANGE DataRange;
BOOL bFixedSizeSamples; // all samples same size?
BOOL bTemporalCompression; // all I frames?
DWORD StreamDescriptionFlags; // KS_VIDEO_DESC_*
DWORD MemoryAllocationFlags; // KS_VIDEO_ALLOC_*
KS_VIDEO_STREAM_CONFIG_CAPS ConfigCaps;
KS_VIDEOINFOHEADER2 VideoInfoHeader; // default format
} KS_DATARANGE_VIDEO2, *PKS_DATARANGE_VIDEO2;
typedef struct tagKS_DATARANGE_MPEG1_VIDEO {
KSDATARANGE DataRange;
BOOL bFixedSizeSamples; // all samples same size?
BOOL bTemporalCompression; // all I frames?
DWORD StreamDescriptionFlags; // KS_VIDEO_DESC_*
DWORD MemoryAllocationFlags; // KS_VIDEO_ALLOC_*
KS_VIDEO_STREAM_CONFIG_CAPS ConfigCaps;
KS_MPEG1VIDEOINFO VideoInfoHeader; // default format
} KS_DATARANGE_MPEG1_VIDEO, *PKS_DATARANGE_MPEG1_VIDEO;
typedef struct tagKS_DATARANGE_MPEG2_VIDEO {
KSDATARANGE DataRange;
BOOL bFixedSizeSamples; // all samples same size?
BOOL bTemporalCompression; // all I frames?
DWORD StreamDescriptionFlags; // KS_VIDEO_DESC_*
DWORD MemoryAllocationFlags; // KS_VIDEO_ALLOC_*
KS_VIDEO_STREAM_CONFIG_CAPS ConfigCaps;
KS_MPEGVIDEOINFO2 VideoInfoHeader; // default format
} KS_DATARANGE_MPEG2_VIDEO, *PKS_DATARANGE_MPEG2_VIDEO;
typedef struct tagKS_DATARANGE_VIDEO_PALETTE {
KSDATARANGE DataRange;
BOOL bFixedSizeSamples; // all samples same size?
BOOL bTemporalCompression; // all I frames?
DWORD StreamDescriptionFlags; // KS_VIDEO_DESC_*
DWORD MemoryAllocationFlags; // KS_VIDEO_ALLOC_*
KS_VIDEO_STREAM_CONFIG_CAPS ConfigCaps;
KS_VIDEOINFO VideoInfo; // default format
} KS_DATARANGE_VIDEO_PALETTE, *PKS_DATARANGE_VIDEO_PALETTE;
typedef struct tagKS_DATARANGE_VIDEO_VBI {
KSDATARANGE DataRange;
BOOL bFixedSizeSamples; // all samples same size?
BOOL bTemporalCompression; // all I frames?
DWORD StreamDescriptionFlags; // KS_VIDEO_DESC_*
DWORD MemoryAllocationFlags; // KS_VIDEO_ALLOC_*
KS_VIDEO_STREAM_CONFIG_CAPS ConfigCaps;
KS_VBIINFOHEADER VBIInfoHeader; // default format
} KS_DATARANGE_VIDEO_VBI, *PKS_DATARANGE_VIDEO_VBI;
typedef struct tagKS_DATARANGE_ANALOGVIDEO {
KSDATARANGE DataRange;
KS_ANALOGVIDEOINFO AnalogVideoInfo;
} KS_DATARANGE_ANALOGVIDEO, *PKS_DATARANGE_ANALOGVIDEO;
//===========================================================================
// StreamDescriptionFlags
//
// These define the "purpose" of each video stream
//===========================================================================
#define KS_VIDEOSTREAM_PREVIEW 0x0001 // Preview stream
#define KS_VIDEOSTREAM_CAPTURE 0x0002 // Capture stream
#define KS_VIDEOSTREAM_VBI 0x0010 // Field1 VBI
#define KS_VIDEOSTREAM_NABTS 0x0020 // Field1 NABTS
#define KS_VIDEOSTREAM_CC 0x0100 // Closed Captioning
#define KS_VIDEOSTREAM_EDS 0x0200 // Extended Data Services
#define KS_VIDEOSTREAM_TELETEXT 0x0400 // Field1 Teletext only
#define KS_VIDEOSTREAM_STILL 0x1000 // Still image input
#define KS_VIDEOSTREAM_IS_VPE 0x8000 // Is a VPE based stream?
// MemoryAllocationFlags
#define KS_VIDEO_ALLOC_VPE_SYSTEM 0x0001 // VPE surface in system memory
#define KS_VIDEO_ALLOC_VPE_DISPLAY 0x0002 // VPE surface in display memory
#define KS_VIDEO_ALLOC_VPE_AGP 0x0004 // VPE surface in AGP memory
//////////////////////////////////////////////////////////////
// Capture driver VBI property sets
//////////////////////////////////////////////////////////////
// {F162C607-7B35-496f-AD7F-2DCA3B46B718}
#define STATIC_KSPROPSETID_VBICAP_PROPERTIES
0xf162c607, 0x7b35, 0x496f, 0xad, 0x7f, 0x2d, 0xca, 0x3b, 0x46, 0xb7, 0x18
DEFINE_GUIDSTRUCT("F162C607-7B35-496f-AD7F-2DCA3B46B718", KSPROPSETID_VBICAP_PROPERTIES);
#define KSPROPSETID_VBICAP_PROPERTIES DEFINE_GUIDNAMED(KSPROPSETID_VBICAP_PROPERTIES)
typedef enum {
KSPROPERTY_VBICAP_PROPERTIES_PROTECTION = 0x01,
} KSPROPERTY_VBICAP;
typedef struct _VBICAP_PROPERTIES_PROTECTION_S {
KSPROPERTY Property;
ULONG StreamIndex; // Index of stream
ULONG Status;
} VBICAP_PROPERTIES_PROTECTION_S, *PVBICAP_PROPERTIES_PROTECTION_S;
#define KS_VBICAP_PROTECTION_MV_PRESENT 0x0001L
#define KS_VBICAP_PROTECTION_MV_HARDWARE 0x0002L
#define KS_VBICAP_PROTECTION_MV_DETECTED 0x0004L
/***************************************************************************/
/* 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
#define KS_NABTS_GROUPID_ORIGINAL_CONTENT_BASE 0x800
#define KS_NABTS_GROUPID_ORIGINAL_CONTENT_ADVERTISER_BASE 0x810
// Used by production company in finished show data
#define KS_NABTS_GROUPID_PRODUCTION_COMPANY_CONTENT_BASE 0x820
#define KS_NABTS_GROUPID_PRODUCTION_COMPANY_ADVERTISER_BASE 0x830
// Used by broadcast syndicates in syndicated show data
#define KS_NABTS_GROUPID_SYNDICATED_SHOW_CONTENT_BASE 0x840
#define KS_NABTS_GROUPID_SYNDICATED_SHOW_ADVERTISER_BASE 0x850
// Used by tv networks in network television data
#define KS_NABTS_GROUPID_NETWORK_WIDE_CONTENT_BASE 0x860
#define KS_NABTS_GROUPID_NETWORK_WIDE_ADVERTISER_BASE 0x870
// Used by telvision stations in local programming data
#define KS_NABTS_GROUPID_TELEVISION_STATION_CONTENT_BASE 0x880
#define KS_NABTS_GROUPID_TELEVISION_STATION_ADVERTISER_BASE 0x890
// Used by cable system in cable head-end originated data
#define KS_NABTS_GROUPID_LOCAL_CABLE_SYSTEM_CONTENT_BASE 0x8A0
#define KS_NABTS_GROUPID_LOCAL_CABLE_SYSTEM_ADVERTISER_BASE 0x8B0
// The values between 0x8C0 - 0x8EF are reserved for future expansion
// Used by Microsoft for Testing purposes (0x8F0 - 0x8FF)
#define KS_NABTS_GROUPID_MICROSOFT_RESERVED_TEST_DATA_BASE 0x8F0
//////////////////////////////////////////////////////////////
// Stream Format FEC-corrected NABTS bundles
//////////////////////////////////////////////////////////////
#define STATIC_KSDATAFORMAT_TYPE_NABTS
0xe757bca0, 0x39ac, 0x11d1, 0xa9, 0xf5, 0x0, 0xc0, 0x4f, 0xbb, 0xde, 0x8f
DEFINE_GUIDSTRUCT("E757BCA0-39AC-11d1-A9F5-00C04FBBDE8F", KSDATAFORMAT_TYPE_NABTS);
#define KSDATAFORMAT_TYPE_NABTS DEFINE_GUIDNAMED(KSDATAFORMAT_TYPE_NABTS)
#define STATIC_KSDATAFORMAT_SUBTYPE_NABTS_FEC
0xe757bca1, 0x39ac, 0x11d1, 0xa9, 0xf5, 0x0, 0xc0, 0x4f, 0xbb, 0xde, 0x8f
DEFINE_GUIDSTRUCT("E757BCA1-39AC-11d1-A9F5-00C04FBBDE8F", KSDATAFORMAT_SUBTYPE_NABTS_FEC);
#define KSDATAFORMAT_SUBTYPE_NABTS_FEC DEFINE_GUIDNAMED(KSDATAFORMAT_SUBTYPE_NABTS_FEC)
//////////////////////////////////////////////////////////////
// NABTS Bundle data structure definition
//////////////////////////////////////////////////////////////
#define MAX_NABTS_VBI_LINES_PER_FIELD 11
#define NABTS_LINES_PER_BUNDLE 16
#define NABTS_PAYLOAD_PER_LINE 28
#define NABTS_BYTES_PER_LINE 36
typedef struct _NABTSFEC_BUFFER {
ULONG dataSize;
USHORT groupID;
USHORT Reserved;
UCHAR data[NABTS_LINES_PER_BUNDLE * NABTS_PAYLOAD_PER_LINE];
} NABTSFEC_BUFFER, *PNABTSFEC_BUFFER;
//////////////////////////////////////////////////////////////
// vbi codec filtering pin properties
//////////////////////////////////////////////////////////////
#define STATIC_KSPROPSETID_VBICodecFiltering
0xcafeb0caL, 0x8715, 0x11d0, 0xbd, 0x6a, 0x00, 0x35, 0xc0, 0xed, 0xba, 0xbe
DEFINE_GUIDSTRUCT("cafeb0ca-8715-11d0-bd6a-0035c0edbabe", KSPROPSETID_VBICodecFiltering);
#define KSPROPSETID_VBICodecFiltering DEFINE_GUIDNAMED(KSPROPSETID_VBICodecFiltering)
typedef enum {
KSPROPERTY_VBICODECFILTERING_SCANLINES_REQUESTED_BIT_ARRAY = 0x01,
KSPROPERTY_VBICODECFILTERING_SCANLINES_DISCOVERED_BIT_ARRAY,
KSPROPERTY_VBICODECFILTERING_SUBSTREAMS_REQUESTED_BIT_ARRAY,
KSPROPERTY_VBICODECFILTERING_SUBSTREAMS_DISCOVERED_BIT_ARRAY,
KSPROPERTY_VBICODECFILTERING_STATISTICS,
} KSPROPERTY_VBICODECFILTERING;
typedef struct _VBICODECFILTERING_SCANLINES {
DWORD DwordBitArray[32]; // An array of scanline bits 0..1024(32*32)
} VBICODECFILTERING_SCANLINES, *PVBICODECFILTERING_SCANLINES;
typedef struct _VBICODECFILTERING_NABTS_SUBSTREAMS {
DWORD SubstreamMask[128]; // An array of 4096 bits (one for each NABTS GroupID)
} VBICODECFILTERING_NABTS_SUBSTREAMS, *PVBICODECFILTERING_NABTS_SUBSTREAMS;
typedef struct _VBICODECFILTERING_CC_SUBSTREAMS {
DWORD SubstreamMask; // An array of 32 bits (see KS_CC_SUBSTREAM *)
} VBICODECFILTERING_CC_SUBSTREAMS, *PVBICODECFILTERING_CC_SUBSTREAMS;
// These KS_CC_SUBSTREAM_* bitmasks are used with VBICODECFILTERING_CC_SUBSTREAMS
#define KS_CC_SUBSTREAM_ODD 0x0001L // Unfiltered Field 1 Data
#define KS_CC_SUBSTREAM_EVEN 0x0002L // Unfiltered Field 2 Data
// The following flags describe CC field 1 substreams: CC1,CC2,TT1,TT2
#define KS_CC_SUBSTREAM_FIELD1_MASK 0x00F0L
#define KS_CC_SUBSTREAM_SERVICE_CC1 0x0010L
#define KS_CC_SUBSTREAM_SERVICE_CC2 0x0020L
#define KS_CC_SUBSTREAM_SERVICE_T1 0x0040L
#define KS_CC_SUBSTREAM_SERVICE_T2 0x0080L
// The following flags describe CC field 2 substreams: CC3,CC4,TT3,TT4,XDS
#define KS_CC_SUBSTREAM_FIELD2_MASK 0x1F00L
#define KS_CC_SUBSTREAM_SERVICE_CC3 0x0100L
#define KS_CC_SUBSTREAM_SERVICE_CC4 0x0200L
#define KS_CC_SUBSTREAM_SERVICE_T3 0x0400L
#define KS_CC_SUBSTREAM_SERVICE_T4 0x0800L
#define KS_CC_SUBSTREAM_SERVICE_XDS 0x1000L
// Special Note: field 1 or 2 substreams are usually on found on field 1 and 2 respectively
// If the VBI odd/even polarity is reversed, the correct filtered data will still be found.
///////////////////////////////////////////////////////////////////
// Hardware decoded CC stream format
///////////////////////////////////////////////////////////////////
#define CC_MAX_HW_DECODE_LINES 12
typedef struct _CC_BYTE_PAIR {
BYTE Decoded[2];
USHORT Reserved;
} CC_BYTE_PAIR, *PCC_BYTE_PAIR;
typedef struct _CC_HW_FIELD {
VBICODECFILTERING_SCANLINES ScanlinesRequested;
ULONG fieldFlags; // KS_VBI_FLAG_FIELD1,2
LONGLONG PictureNumber;
CC_BYTE_PAIR Lines[CC_MAX_HW_DECODE_LINES];
} CC_HW_FIELD, *PCC_HW_FIELD;
///////////////////////////////////////////////////////////////////
// Raw NABTS stream format (TYPE_NABTS, SUBTYPE_NABTS)
///////////////////////////////////////////////////////////////////
// These low-level structures are byte packed( -Zp1 )
#if !defined( PACK_PRAGMAS_NOT_SUPPORTED )
#include <pshpack1.h>
#endif
typedef struct _NABTS_BUFFER_LINE {
BYTE Confidence;
BYTE Bytes[NABTS_BYTES_PER_LINE];
} NABTS_BUFFER_LINE, *PNABTS_BUFFER_LINE;
#define NABTS_BUFFER_PICTURENUMBER_SUPPORT 1
typedef struct _NABTS_BUFFER {
VBICODECFILTERING_SCANLINES ScanlinesRequested;
LONGLONG PictureNumber;
NABTS_BUFFER_LINE NabtsLines[MAX_NABTS_VBI_LINES_PER_FIELD];
} NABTS_BUFFER, *PNABTS_BUFFER;
#if !defined( PACK_PRAGMAS_NOT_SUPPORTED )
#include <poppack.h>
#endif
//////////////////////////////////////////////////////////////
// WST Codec Teletext Media Sample Format
//////////////////////////////////////////////////////////////
#define WST_TVTUNER_CHANGE_BEGIN_TUNE 0x1000L // Starting a tuning operation
#define WST_TVTUNER_CHANGE_END_TUNE 0x2000L // Ending a tuning operation
#define MAX_WST_VBI_LINES_PER_FIELD 17
#define WST_BYTES_PER_LINE 42
typedef struct _WST_BUFFER_LINE {
BYTE Confidence;
BYTE Bytes[WST_BYTES_PER_LINE];
} WST_BUFFER_LINE, *PWST_BUFFER_LINE;
typedef struct _WST_BUFFER {
VBICODECFILTERING_SCANLINES ScanlinesRequested;
WST_BUFFER_LINE WstLines[MAX_WST_VBI_LINES_PER_FIELD];
} WST_BUFFER, *PWST_BUFFER;
//
// Common codec statistics
//
typedef struct _VBICODECFILTERING_STATISTICS_COMMON {
DWORD InputSRBsProcessed; // upstream SRBs received
DWORD OutputSRBsProcessed; // downstream SRBs sent
DWORD SRBsIgnored; // SRBs ignored due to no requests
DWORD InputSRBsMissing; // SRBs dropped upstream
DWORD OutputSRBsMissing; // Output dropped because no SRB pending
DWORD OutputFailures; // dropped because of other failure
DWORD InternalErrors; // could not process due to int. failure
DWORD ExternalErrors; // could not process due to ext. failure
DWORD InputDiscontinuities; // discontinuities received
DWORD DSPFailures; // DSP confidence failure
DWORD TvTunerChanges; // number of received KS_TVTUNER_CHANGE_BEGIN_TUNE and KS_TVTUNER_CHANGE_END_TUNE pairs.
DWORD VBIHeaderChanges; // number of received KS_VBI_FLAG_VBIINFOHEADER_CHANGE
DWORD LineConfidenceAvg; // Average of all DSP confidence results
DWORD BytesOutput; // Bytes sent downstream
} VBICODECFILTERING_STATISTICS_COMMON, *PVBICODECFILTERING_STATISTICS_COMMON;
typedef struct _VBICODECFILTERING_STATISTICS_COMMON_PIN {
DWORD SRBsProcessed; // SRBs sent/received
DWORD SRBsIgnored; // SRBs ignored due to filtering
DWORD SRBsMissing; // SRBs not sent/received
DWORD InternalErrors; // could not send/receive due to int. failure
DWORD ExternalErrors; // could not send/receive due to ext. failure
DWORD Discontinuities; // discontinuities received/sent
DWORD LineConfidenceAvg; // Average of all DSP confidence results for this pin
DWORD BytesOutput; // Bytes sent downstream
} VBICODECFILTERING_STATISTICS_COMMON_PIN, *PVBICODECFILTERING_STATISTICS_COMMON_PIN;
//
// Codec-specific statistics - NABTS
//
typedef struct _VBICODECFILTERING_STATISTICS_NABTS {
VBICODECFILTERING_STATISTICS_COMMON Common; // Generic VBI statistics
DWORD FECBundleBadLines; // Un-FEC-correctable lines
DWORD FECQueueOverflows; // Number of times FEC queue overflowed
DWORD FECCorrectedLines; // Lines CSUM corrected by FEC
DWORD FECUncorrectableLines; // FEC input lines not CSUM correctable
DWORD BundlesProcessed; // Bundles received from FEC
DWORD BundlesSent2IP; // Bundles sent to IP driver
DWORD FilteredLines; // Lines processed and then dropped
// because no one was interested
} VBICODECFILTERING_STATISTICS_NABTS, *PVBICODECFILTERING_STATISTICS_NABTS;
typedef struct _VBICODECFILTERING_STATISTICS_NABTS_PIN {
VBICODECFILTERING_STATISTICS_COMMON_PIN Common;// Generic VBI pin statistics
} VBICODECFILTERING_STATISTICS_NABTS_PIN, *PVBICODECFILTERING_STATISTICS_NABTS_PIN;
//
// Codec-specific statistics - Closed Caption
//
typedef struct _VBICODECFILTERING_STATISTICS_CC {
VBICODECFILTERING_STATISTICS_COMMON Common; // Generic VBI statistics
} VBICODECFILTERING_STATISTICS_CC, *PVBICODECFILTERING_STATISTICS_CC;
typedef struct _VBICODECFILTERING_STATISTICS_CC_PIN {
VBICODECFILTERING_STATISTICS_COMMON_PIN Common;// Generic VBI pin statistics
} VBICODECFILTERING_STATISTICS_CC_PIN, *PVBICODECFILTERING_STATISTICS_CC_PIN;
//
// Codec-specific statistics - Closed Caption
//
typedef struct _VBICODECFILTERING_STATISTICS_TELETEXT {
VBICODECFILTERING_STATISTICS_COMMON Common; // Generic VBI statistics
} VBICODECFILTERING_STATISTICS_TELETEXT, *PVBICODECFILTERING_STATISTICS_TELETEXT;
typedef struct _VBICODECFILTERING_STATISTICS_TELETEXT_PIN {
VBICODECFILTERING_STATISTICS_COMMON_PIN Common;// Generic VBI pin statistics
} VBICODECFILTERING_STATISTICS_TELETEXT_PIN, *PVBICODECFILTERING_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,
typedef struct {
KSPROPERTY Property;
VBICODECFILTERING_SCANLINES Scanlines;
} KSPROPERTY_VBICODECFILTERING_SCANLINES_S, *PKSPROPERTY_VBICODECFILTERING_SCANLINES_S;
// *** NABTS codecs support this property
// KSPROPERTY_VBICODECFILTERING_SUBSTREAMS_REQUESTED_BIT_ARRAY,
// KSPROPERTY_VBICODECFILTERING_SUBSTREAMS_DISCOVERED_BIT_ARRAY,
typedef struct {
KSPROPERTY Property;
VBICODECFILTERING_NABTS_SUBSTREAMS Substreams;
} KSPROPERTY_VBICODECFILTERING_NABTS_SUBSTREAMS_S, *PKSPROPERTY_VBICODECFILTERING_NABTS_SUBSTREAMS_S;
// *** Closed captioning codecs support this property
// KSPROPERTY_VBICODECFILTERING_SUBSTREAMS_REQUESTED_BIT_ARRAY,
// KSPROPERTY_VBICODECFILTERING_SUBSTREAMS_DISCOVERED_BIT_ARRAY,
typedef struct {
KSPROPERTY Property;
VBICODECFILTERING_CC_SUBSTREAMS Substreams;
} KSPROPERTY_VBICODECFILTERING_CC_SUBSTREAMS_S, *PKSPROPERTY_VBICODECFILTERING_CC_SUBSTREAMS_S;
// *** Most codecs support these versions of the global and pin properties
// KSPROPERTY_VBICODECFILTERING_STATISTICS
typedef struct {
KSPROPERTY Property;
VBICODECFILTERING_STATISTICS_COMMON Statistics;
} KSPROPERTY_VBICODECFILTERING_STATISTICS_COMMON_S, *PKSPROPERTY_VBICODECFILTERING_STATISTICS_COMMON_S;
typedef struct {
KSPROPERTY Property;
VBICODECFILTERING_STATISTICS_COMMON_PIN Statistics;
} KSPROPERTY_VBICODECFILTERING_STATISTICS_COMMON_PIN_S, *PKSPROPERTY_VBICODECFILTERING_STATISTICS_COMMON_PIN_S;
// *** NABTS codecs support this version of the global and pin properties
// KSPROPERTY_VBICODECFILTERING_STATISTICS
typedef struct {
KSPROPERTY Property;
VBICODECFILTERING_STATISTICS_NABTS Statistics;
} KSPROPERTY_VBICODECFILTERING_STATISTICS_NABTS_S, *PKSPROPERTY_VBICODECFILTERING_STATISTICS_NABTS_S;
typedef struct {
KSPROPERTY Property;
VBICODECFILTERING_STATISTICS_NABTS_PIN Statistics;
} KSPROPERTY_VBICODECFILTERING_STATISTICS_NABTS_PIN_S, *PKSPROPERTY_VBICODECFILTERING_STATISTICS_NABTS_PIN_S;
// *** Closed captioning codecs support this version of the global and pin properties
// KSPROPERTY_VBICODECFILTERING_STATISTICS
typedef struct {
KSPROPERTY Property;
VBICODECFILTERING_STATISTICS_CC Statistics;
} KSPROPERTY_VBICODECFILTERING_STATISTICS_CC_S, *PKSPROPERTY_VBICODECFILTERING_STATISTICS_CC_S;
typedef struct {
KSPROPERTY Property;
VBICODECFILTERING_STATISTICS_CC_PIN Statistics;
} KSPROPERTY_VBICODECFILTERING_STATISTICS_CC_PIN_S, *PKSPROPERTY_VBICODECFILTERING_STATISTICS_CC_PIN_S;
// Standard Pin Names for the video capture filter
//===========================================================================
#define STATIC_PINNAME_VIDEO_CAPTURE
0xfb6c4281, 0x353, 0x11d1, 0x90, 0x5f, 0x0, 0x0, 0xc0, 0xcc, 0x16, 0xba
#define STATIC_PINNAME_CAPTURE STATIC_PINNAME_VIDEO_CAPTURE
DEFINE_GUIDSTRUCT("FB6C4281-0353-11d1-905F-0000C0CC16BA", PINNAME_VIDEO_CAPTURE);
#define PINNAME_VIDEO_CAPTURE DEFINE_GUIDNAMED(PINNAME_VIDEO_CAPTURE)
#define PINNAME_CAPTURE PINNAME_VIDEO_CAPTURE
#define STATIC_PINNAME_VIDEO_CC_CAPTURE
0x1aad8061, 0x12d, 0x11d2, 0xb4, 0xb1, 0x0, 0xa0, 0xd1, 0x2, 0xcf, 0xbe
#define STATIC_PINNAME_CC_CAPTURE STATIC_PINNAME_VIDEO_CC_CAPTURE
DEFINE_GUIDSTRUCT("1AAD8061-012D-11d2-B4B1-00A0D102CFBE", PINNAME_VIDEO_CC_CAPTURE);
#define PINNAME_VIDEO_CC_CAPTURE DEFINE_GUIDNAMED(PINNAME_VIDEO_CC_CAPTURE)
#define STATIC_PINNAME_VIDEO_NABTS_CAPTURE
0x29703660, 0x498a, 0x11d2, 0xb4, 0xb1, 0x0, 0xa0, 0xd1, 0x2, 0xcf, 0xbe
#define STATIC_PINNAME_NABTS_CAPTURE STATIC_PINNAME_VIDEO_NABTS_CAPTURE
DEFINE_GUIDSTRUCT("29703660-498A-11d2-B4B1-00A0D102CFBE", PINNAME_VIDEO_NABTS_CAPTURE);
#define PINNAME_VIDEO_NABTS_CAPTURE DEFINE_GUIDNAMED(PINNAME_VIDEO_NABTS_CAPTURE)
#define STATIC_PINNAME_VIDEO_PREVIEW
0xfb6c4282, 0x353, 0x11d1, 0x90, 0x5f, 0x0, 0x0, 0xc0, 0xcc, 0x16, 0xba
#define STATIC_PINNAME_PREVIEW STATIC_PINNAME_VIDEO_PREVIEW
DEFINE_GUIDSTRUCT("FB6C4282-0353-11d1-905F-0000C0CC16BA", PINNAME_VIDEO_PREVIEW);
#define PINNAME_VIDEO_PREVIEW DEFINE_GUIDNAMED(PINNAME_VIDEO_PREVIEW)
#define PINNAME_PREVIEW PINNAME_VIDEO_PREVIEW
#define STATIC_PINNAME_VIDEO_ANALOGVIDEOIN
0xfb6c4283, 0x353, 0x11d1, 0x90, 0x5f, 0x0, 0x0, 0xc0, 0xcc, 0x16, 0xba
DEFINE_GUIDSTRUCT("FB6C4283-0353-11d1-905F-0000C0CC16BA", PINNAME_VIDEO_ANALOGVIDEOIN);
#define PINNAME_VIDEO_ANALOGVIDEOIN DEFINE_GUIDNAMED(PINNAME_VIDEO_ANALOGVIDEOIN)
#define STATIC_PINNAME_VIDEO_VBI
0xfb6c4284, 0x353, 0x11d1, 0x90, 0x5f, 0x0, 0x0, 0xc0, 0xcc, 0x16, 0xba
DEFINE_GUIDSTRUCT("FB6C4284-0353-11d1-905F-0000C0CC16BA", PINNAME_VIDEO_VBI);
#define PINNAME_VIDEO_VBI DEFINE_GUIDNAMED(PINNAME_VIDEO_VBI)
#define STATIC_PINNAME_VIDEO_VIDEOPORT
0xfb6c4285, 0x353, 0x11d1, 0x90, 0x5f, 0x0, 0x0, 0xc0, 0xcc, 0x16, 0xba
DEFINE_GUIDSTRUCT("FB6C4285-0353-11d1-905F-0000C0CC16BA", PINNAME_VIDEO_VIDEOPORT);
#define PINNAME_VIDEO_VIDEOPORT DEFINE_GUIDNAMED(PINNAME_VIDEO_VIDEOPORT)
#define STATIC_PINNAME_VIDEO_NABTS
0xfb6c4286, 0x353, 0x11d1, 0x90, 0x5f, 0x0, 0x0, 0xc0, 0xcc, 0x16, 0xba
DEFINE_GUIDSTRUCT("FB6C4286-0353-11d1-905F-0000C0CC16BA", PINNAME_VIDEO_NABTS);
#define PINNAME_VIDEO_NABTS DEFINE_GUIDNAMED(PINNAME_VIDEO_NABTS)
#define STATIC_PINNAME_VIDEO_EDS
0xfb6c4287, 0x353, 0x11d1, 0x90, 0x5f, 0x0, 0x0, 0xc0, 0xcc, 0x16, 0xba
DEFINE_GUIDSTRUCT("FB6C4287-0353-11d1-905F-0000C0CC16BA", PINNAME_VIDEO_EDS);
#define PINNAME_VIDEO_EDS DEFINE_GUIDNAMED(PINNAME_VIDEO_EDS)
#define STATIC_PINNAME_VIDEO_TELETEXT
0xfb6c4288, 0x353, 0x11d1, 0x90, 0x5f, 0x0, 0x0, 0xc0, 0xcc, 0x16, 0xba
DEFINE_GUIDSTRUCT("FB6C4288-0353-11d1-905F-0000C0CC16BA", PINNAME_VIDEO_TELETEXT);
#define PINNAME_VIDEO_TELETEXT DEFINE_GUIDNAMED(PINNAME_VIDEO_TELETEXT)
#define STATIC_PINNAME_VIDEO_CC
0xfb6c4289, 0x353, 0x11d1, 0x90, 0x5f, 0x0, 0x0, 0xc0, 0xcc, 0x16, 0xba
DEFINE_GUIDSTRUCT("FB6C4289-0353-11d1-905F-0000C0CC16BA", PINNAME_VIDEO_CC);
#define PINNAME_VIDEO_CC DEFINE_GUIDNAMED(PINNAME_VIDEO_CC)
#define STATIC_PINNAME_VIDEO_STILL
0xfb6c428A, 0x353, 0x11d1, 0x90, 0x5f, 0x0, 0x0, 0xc0, 0xcc, 0x16, 0xba
DEFINE_GUIDSTRUCT("FB6C428A-0353-11d1-905F-0000C0CC16BA", PINNAME_VIDEO_STILL);
#define PINNAME_VIDEO_STILL DEFINE_GUIDNAMED(PINNAME_VIDEO_STILL)
#define STATIC_PINNAME_VIDEO_TIMECODE
0xfb6c428B, 0x353, 0x11d1, 0x90, 0x5f, 0x0, 0x0, 0xc0, 0xcc, 0x16, 0xba
DEFINE_GUIDSTRUCT("FB6C428B-0353-11d1-905F-0000C0CC16BA", PINNAME_VIDEO_TIMECODE);
#define PINNAME_VIDEO_TIMECODE DEFINE_GUIDNAMED(PINNAME_VIDEO_TIMECODE)
#define STATIC_PINNAME_VIDEO_VIDEOPORT_VBI
0xfb6c428C, 0x353, 0x11d1, 0x90, 0x5f, 0x0, 0x0, 0xc0, 0xcc, 0x16, 0xba
DEFINE_GUIDSTRUCT("FB6C428C-0353-11d1-905F-0000C0CC16BA", PINNAME_VIDEO_VIDEOPORT_VBI);
#define PINNAME_VIDEO_VIDEOPORT_VBI DEFINE_GUIDNAMED(PINNAME_VIDEO_VIDEOPORT_VBI)
//===========================================================================
// KSSTREAM_HEADER extensions for digital video
//===========================================================================
#define KS_VIDEO_FLAG_FRAME 0x0000L // Frame or Field (default is frame)
#define KS_VIDEO_FLAG_FIELD1 0x0001L
#define KS_VIDEO_FLAG_FIELD2 0x0002L
#define KS_VIDEO_FLAG_I_FRAME 0x0000L // I, B, or P (default is I)
#define KS_VIDEO_FLAG_P_FRAME 0x0010L
#define KS_VIDEO_FLAG_B_FRAME 0x0020L
typedef struct tagKS_FRAME_INFO {
ULONG ExtendedHeaderSize; // Size of this extended header
DWORD dwFrameFlags; // Field1, Field2, or Frame
LONGLONG PictureNumber;
LONGLONG DropCount;
// The following are only set when using OverlayMixer
HANDLE hDirectDraw; // user mode DDraw handle
HANDLE hSurfaceHandle; // user mode surface handle
RECT DirectDrawRect; // portion of surface locked
// Reserved fields, never reference these
DWORD Reserved1;
DWORD Reserved2;
DWORD Reserved3;
DWORD Reserved4;
} KS_FRAME_INFO, *PKS_FRAME_INFO;
//===========================================================================
// KSSTREAM_HEADER extensions for VBI
//===========================================================================
#define KS_VBI_FLAG_FIELD1 0x0001L
#define KS_VBI_FLAG_FIELD2 0x0002L
#define KS_VBI_FLAG_MV_PRESENT 0x0100L
#define KS_VBI_FLAG_MV_HARDWARE 0x0200L
#define KS_VBI_FLAG_MV_DETECTED 0x0400L
#define KS_VBI_FLAG_TVTUNER_CHANGE 0x0010L // TvTunerChangeInfo is valid
#define KS_VBI_FLAG_VBIINFOHEADER_CHANGE 0x0020L // VBIInfoHeader is valid
typedef struct tagKS_VBI_FRAME_INFO {
ULONG ExtendedHeaderSize; // Size of this extended header
DWORD dwFrameFlags; // Field1, Field2, or Frame; & etc
LONGLONG PictureNumber; // Test only?
LONGLONG DropCount; // Test only?
DWORD dwSamplingFrequency;
KS_TVTUNER_CHANGE_INFO TvTunerChangeInfo;
KS_VBIINFOHEADER VBIInfoHeader;
} KS_VBI_FRAME_INFO, *PKS_VBI_FRAME_INFO;
//===========================================================================
// Analog video formats, used with:
// Analog Video Decoders
// TVTuners
// Analog Video Encoders
//
// XXX_STANDARDS_SUPPORTED returns a bitmask
//===========================================================================
typedef enum
{
KS_AnalogVideo_None = 0x00000000, // This is a digital sensor
KS_AnalogVideo_NTSC_M = 0x00000001, // 75 IRE Setup
KS_AnalogVideo_NTSC_M_J = 0x00000002, // Japan, 0 IRE Setup
KS_AnalogVideo_NTSC_433 = 0x00000004,
KS_AnalogVideo_PAL_B = 0x00000010,
KS_AnalogVideo_PAL_D = 0x00000020,
KS_AnalogVideo_PAL_G = 0x00000040,
KS_AnalogVideo_PAL_H = 0x00000080,
KS_AnalogVideo_PAL_I = 0x00000100,
KS_AnalogVideo_PAL_M = 0x00000200,
KS_AnalogVideo_PAL_N = 0x00000400,
KS_AnalogVideo_PAL_60 = 0x00000800,
KS_AnalogVideo_SECAM_B = 0x00001000,
KS_AnalogVideo_SECAM_D = 0x00002000,
KS_AnalogVideo_SECAM_G = 0x00004000,
KS_AnalogVideo_SECAM_H = 0x00008000,
KS_AnalogVideo_SECAM_K = 0x00010000,
KS_AnalogVideo_SECAM_K1 = 0x00020000,
KS_AnalogVideo_SECAM_L = 0x00040000,
KS_AnalogVideo_SECAM_L1 = 0x00080000,
KS_AnalogVideo_PAL_N_COMBO
= 0x00100000
} KS_AnalogVideoStandard;
#define KS_AnalogVideo_NTSC_Mask 0x00000007
#define KS_AnalogVideo_PAL_Mask 0x00100FF0
#define KS_AnalogVideo_SECAM_Mask 0x000FF000
//===========================================================================
// 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)
//===========================================================================
#define STATIC_PROPSETID_ALLOCATOR_CONTROL
0x53171960, 0x148e, 0x11d2, 0x99, 0x79, 0x0, 0x0, 0xc0, 0xcc, 0x16, 0xba
DEFINE_GUIDSTRUCT("53171960-148E-11d2-9979-0000C0CC16BA", PROPSETID_ALLOCATOR_CONTROL);
#define PROPSETID_ALLOCATOR_CONTROL DEFINE_GUIDNAMED(PROPSETID_ALLOCATOR_CONTROL)
typedef enum {
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)
// W I (informn a capture driver whether interleave capture is possible or
// not - a value of 1 means that interleaved capture is supported)
KSPROPERTY_ALLOCATOR_CONTROL_CAPTURE_CAPS,
// R O (if value == 1, then the ovmixer will turn on the DDVP_INTERLEAVE
// flag thus allowing interleaved capture of the video)
KSPROPERTY_ALLOCATOR_CONTROL_CAPTURE_INTERLEAVE,
} KSPROPERTY_ALLOCATOR_CONTROL;
typedef struct {
//KSPROPERTY Property;
ULONG CX;
ULONG CY;
} KSPROPERTY_ALLOCATOR_CONTROL_SURFACE_SIZE_S, *PKSPROPERTY_ALLOCATOR_CONTROL_SURFACE_SIZE_S;
typedef struct {
//KSPROPERTY Property;
ULONG InterleavedCapSupported;
} KSPROPERTY_ALLOCATOR_CONTROL_CAPTURE_CAPS_S, *PKSPROPERTY_ALLOCATOR_CONTROL_CAPTURE_CAPS_S;
typedef struct {
//KSPROPERTY Property;
ULONG InterleavedCapPossible;
} KSPROPERTY_ALLOCATOR_CONTROL_CAPTURE_INTERLEAVE_S, *PKSPROPERTY_ALLOCATOR_CONTROL_CAPTURE_INTERLEAVE_S;
//===========================================================================
#define STATIC_PROPSETID_VIDCAP_VIDEOPROCAMP
0xC6E13360L, 0x30AC, 0x11d0, 0xa1, 0x8c, 0x00, 0xA0, 0xC9, 0x11, 0x89, 0x56
DEFINE_GUIDSTRUCT("C6E13360-30AC-11d0-A18C-00A0C9118956", PROPSETID_VIDCAP_VIDEOPROCAMP);
#define PROPSETID_VIDCAP_VIDEOPROCAMP DEFINE_GUIDNAMED(PROPSETID_VIDCAP_VIDEOPROCAMP)
typedef enum {
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_VIDCAP_VIDEOPROCAMP;
typedef struct {
KSPROPERTY Property;
LONG Value; // Value to set or get
ULONG Flags; // KSPROPERTY_VIDEOPROCAMP_FLAGS_*
ULONG Capabilities; // KSPROPERTY_VIDEOPROCAMP_FLAGS_*
} KSPROPERTY_VIDEOPROCAMP_S, *PKSPROPERTY_VIDEOPROCAMP_S;
#define KSPROPERTY_VIDEOPROCAMP_FLAGS_AUTO 0X0001L
#define KSPROPERTY_VIDEOPROCAMP_FLAGS_MANUAL 0X0002L
//===========================================================================
#define STATIC_PROPSETID_TUNER
0x6a2e0605L, 0x28e4, 0x11d0, 0xa1, 0x8c, 0x00, 0xa0, 0xc9, 0x11, 0x89, 0x56
DEFINE_GUIDSTRUCT("6a2e0605-28e4-11d0-a18c-00a0c9118956", PROPSETID_TUNER);
#define PROPSETID_TUNER DEFINE_GUIDNAMED(PROPSETID_TUNER)
typedef enum {
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
} KSPROPERTY_TUNER;
typedef enum {
KSPROPERTY_TUNER_MODE_TV = 0X0001,
KSPROPERTY_TUNER_MODE_FM_RADIO = 0X0002,
KSPROPERTY_TUNER_MODE_AM_RADIO = 0X0004,
KSPROPERTY_TUNER_MODE_DSS = 0X0008,
KSPROPERTY_TUNER_MODE_ATSC = 0X0010, // also used for DVB-T, DVB-C
} KSPROPERTY_TUNER_MODES;
// 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
typedef enum {
KS_TUNER_TUNING_EXACT = 1, // No fine tuning
KS_TUNER_TUNING_FINE, // Fine grained search
KS_TUNER_TUNING_COARSE, // Coarse search
}KS_TUNER_TUNING_FLAGS;
typedef enum {
KS_TUNER_STRATEGY_PLL = 0X01, // Tune by PLL offset
KS_TUNER_STRATEGY_SIGNAL_STRENGTH = 0X02, // Tune by signal strength
KS_TUNER_STRATEGY_DRIVER_TUNES = 0X04, // Driver does fine tuning
}KS_TUNER_STRATEGY;
typedef struct {
KSPROPERTY Property;
ULONG ModesSupported; // KS_PROPERTY_TUNER_MODES_*
KSPIN_MEDIUM VideoMedium; // GUID_NULL (no pin), or GUID
KSPIN_MEDIUM TVAudioMedium; // GUID_NULL (no pin), or GUID
KSPIN_MEDIUM RadioAudioMedium; // GUID_NULL (no pin), or GUID
} KSPROPERTY_TUNER_CAPS_S, *PKSPROPERTY_TUNER_CAPS_S;
typedef struct {
KSPROPERTY Property;
KSPIN_MEDIUM IFMedium; // GUID_NULL (no pin), or GUID
} KSPROPERTY_TUNER_IF_MEDIUM_S, *PKSPROPERTY_TUNER_IF_MEDIUM_S;
typedef struct {
KSPROPERTY Property;
ULONG Mode; // IN: KSPROPERTY_TUNER_MODE
ULONG StandardsSupported; // KS_AnalogVideo_* (if TV or DSS)
ULONG MinFrequency; // Hz
ULONG MaxFrequency; // Hz
ULONG TuningGranularity; // Hz
ULONG NumberOfInputs; // count of inputs
ULONG SettlingTime; // milliSeconds
ULONG Strategy; // KS_TUNER_STRATEGY
} KSPROPERTY_TUNER_MODE_CAPS_S, *PKSPROPERTY_TUNER_MODE_CAPS_S;
typedef struct {
KSPROPERTY Property;
ULONG Mode; // IN: KSPROPERTY_TUNER_MODE
} KSPROPERTY_TUNER_MODE_S, *PKSPROPERTY_TUNER_MODE_S;
typedef struct {
KSPROPERTY Property;
ULONG Frequency; // Hz
ULONG LastFrequency; // Hz (last known good)
ULONG TuningFlags; // KS_TUNER_TUNING_FLAGS
ULONG VideoSubChannel; // DSS
ULONG AudioSubChannel; // DSS
ULONG Channel; // VBI decoders
ULONG Country; // VBI decoders
} KSPROPERTY_TUNER_FREQUENCY_S, *PKSPROPERTY_TUNER_FREQUENCY_S;
typedef struct {
KSPROPERTY Property;
ULONG Standard; // KS_AnalogVideo_*
} KSPROPERTY_TUNER_STANDARD_S, *PKSPROPERTY_TUNER_STANDARD_S;
typedef struct {
KSPROPERTY Property;
ULONG InputIndex; // 0 to (n-1) inputs
} KSPROPERTY_TUNER_INPUT_S, *PKSPROPERTY_TUNER_INPUT_S;
typedef struct {
KSPROPERTY Property;
ULONG CurrentFrequency; // Hz
ULONG PLLOffset; // if Strategy.KS_TUNER_STRATEGY_PLL
ULONG SignalStrength; // if Stretegy.KS_TUNER_STRATEGY_SIGNAL_STRENGTH
ULONG Busy; // TRUE if in the process of tuning
} KSPROPERTY_TUNER_STATUS_S, *PKSPROPERTY_TUNER_STATUS_S;
#define STATIC_EVENTSETID_TUNER
0x6a2e0606L, 0x28e4, 0x11d0, 0xa1, 0x8c, 0x00, 0xa0, 0xc9, 0x11, 0x89, 0x56
DEFINE_GUIDSTRUCT("6a2e0606-28e4-11d0-a18c-00a0c9118956", EVENTSETID_TUNER);
#define EVENTSETID_TUNER DEFINE_GUIDNAMED(EVENTSETID_TUNER)
typedef enum {
KSEVENT_TUNER_CHANGED
} KSEVENT_TUNER;
//===========================================================================
#define STATIC_PROPSETID_VIDCAP_VIDEOENCODER
0x6a2e0610L, 0x28e4, 0x11d0, 0xa1, 0x8c, 0x00, 0xa0, 0xc9, 0x11, 0x89, 0x56
DEFINE_GUIDSTRUCT("6a2e0610-28e4-11d0-a18c-00a0c9118956", PROPSETID_VIDCAP_VIDEOENCODER);
#define PROPSETID_VIDCAP_VIDEOENCODER DEFINE_GUIDNAMED(PROPSETID_VIDCAP_VIDEOENCODER)
typedef enum {
KSPROPERTY_VIDEOENCODER_CAPS, // R
KSPROPERTY_VIDEOENCODER_STANDARD, // RW
KSPROPERTY_VIDEOENCODER_COPYPROTECTION, // RW O
KSPROPERTY_VIDEOENCODER_CC_ENABLE, // RW O
} KSPROPERTY_VIDCAP_VIDEOENCODER;
typedef struct {
KSPROPERTY Property;
LONG Value; // value to get or set
ULONG Flags; //
ULONG Capabilities; //
} KSPROPERTY_VIDEOENCODER_S, *PKSPROPERTY_VIDEOENCODER_S;
//===========================================================================
#define STATIC_PROPSETID_VIDCAP_VIDEODECODER
0xC6E13350L, 0x30AC, 0x11d0, 0xA1, 0x8C, 0x00, 0xA0, 0xC9, 0x11, 0x89, 0x56
DEFINE_GUIDSTRUCT("C6E13350-30AC-11d0-A18C-00A0C9118956", PROPSETID_VIDCAP_VIDEODECODER);
#define PROPSETID_VIDCAP_VIDEODECODER DEFINE_GUIDNAMED(PROPSETID_VIDCAP_VIDEODECODER)
typedef enum {
KSPROPERTY_VIDEODECODER_CAPS, // R
KSPROPERTY_VIDEODECODER_STANDARD, // RW
KSPROPERTY_VIDEODECODER_STATUS, // R
KSPROPERTY_VIDEODECODER_OUTPUT_ENABLE, // Rw O
KSPROPERTY_VIDEODECODER_VCR_TIMING, // RW O
} KSPROPERTY_VIDCAP_VIDEODECODER;
typedef enum {
KS_VIDEODECODER_FLAGS_CAN_DISABLE_OUTPUT = 0X0001, // VP Output can tri-stae
KS_VIDEODECODER_FLAGS_CAN_USE_VCR_LOCKING = 0X0002, // VCR PLL timings
KS_VIDEODECODER_FLAGS_CAN_INDICATE_LOCKED = 0X0004, // Can indicate valid signal
}KS_VIDEODECODER_FLAGS;
typedef struct {
KSPROPERTY Property;
ULONG StandardsSupported; // KS_AnalogVideo_*
ULONG Capabilities; // KS_VIDEODECODER_FLAGS_*
ULONG SettlingTime; // milliseconds
ULONG HSyncPerVSync; // Number of HSync Pulses per VSync
} KSPROPERTY_VIDEODECODER_CAPS_S, *PKSPROPERTY_VIDEODECODER_CAPS_S;
typedef struct {
KSPROPERTY Property;
ULONG NumberOfLines; // 525 or 625 lines detected
ULONG SignalLocked; // TRUE if signal is locked
} KSPROPERTY_VIDEODECODER_STATUS_S, *PKSPROPERTY_VIDEODECODER_STATUS_S;
typedef struct {
KSPROPERTY Property;
ULONG Value; // Get or set a value
} KSPROPERTY_VIDEODECODER_S, *PKSPROPERTY_VIDEODECODER_S;
#define STATIC_EVENTSETID_VIDEODECODER
0x6a2e0621L, 0x28e4, 0x11d0, 0xa1, 0x8c, 0x00, 0xa0, 0xc9, 0x11, 0x89, 0x56
DEFINE_GUIDSTRUCT("6a2e0621-28e4-11d0-a18c-00a0c9118956", EVENTSETID_VIDEODECODER);
#define EVENTSETID_VIDEODECODER DEFINE_GUIDNAMED(EVENTSETID_VIDEODECODER)
typedef enum {
KSEVENT_VIDEODECODER_CHANGED
} KSEVENT_VIDEODECODER;
//===========================================================================
#define STATIC_PROPSETID_VIDCAP_CAMERACONTROL
0xC6E13370L, 0x30AC, 0x11d0, 0xa1, 0x8C, 0x00, 0xA0, 0xC9, 0x11, 0x89, 0x56
DEFINE_GUIDSTRUCT("C6E13370-30AC-11d0-A18C-00A0C9118956", PROPSETID_VIDCAP_CAMERACONTROL);
#define PROPSETID_VIDCAP_CAMERACONTROL DEFINE_GUIDNAMED(PROPSETID_VIDCAP_CAMERACONTROL)
typedef enum {
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_VIDCAP_CAMERACONTROL;
typedef struct {
KSPROPERTY Property;
LONG Value; // value to get or set
ULONG Flags; // KSPROPERTY_CAMERACONTROL_FLAGS_*
ULONG Capabilities; // KSPROPERTY_CAMERACONTROL_FLAGS_*
} KSPROPERTY_CAMERACONTROL_S, *PKSPROPERTY_CAMERACONTROL_S;
#define KSPROPERTY_CAMERACONTROL_FLAGS_AUTO 0X0001L
#define KSPROPERTY_CAMERACONTROL_FLAGS_MANUAL 0X0002L
#define KSPROPERTY_CAMERACONTROL_FLAGS_ABSOLUTE 0X0000L
#define KSPROPERTY_CAMERACONTROL_FLAGS_RELATIVE 0X0010L
//===========================================================================
#define STATIC_PROPSETID_VIDCAP_CROSSBAR
0x6a2e0640L, 0x28e4, 0x11d0, 0xa1, 0x8c, 0x00, 0xa0, 0xc9, 0x11, 0x89, 0x56
DEFINE_GUIDSTRUCT("6a2e0640-28e4-11d0-a18c-00a0c9118956", PROPSETID_VIDCAP_CROSSBAR);
#define PROPSETID_VIDCAP_CROSSBAR DEFINE_GUIDNAMED(PROPSETID_VIDCAP_CROSSBAR)
typedef enum {
KSPROPERTY_CROSSBAR_CAPS, // R
KSPROPERTY_CROSSBAR_PININFO, // R
KSPROPERTY_CROSSBAR_CAN_ROUTE, // R
KSPROPERTY_CROSSBAR_ROUTE, // RW
} KSPROPERTY_VIDCAP_CROSSBAR;
typedef struct {
KSPROPERTY Property;
ULONG NumberOfInputs; // the number of audio and video input pins
ULONG NumberOfOutputs; // the number of audio and video output pins
} KSPROPERTY_CROSSBAR_CAPS_S, *PKSPROPERTY_CROSSBAR_CAPS_S;
typedef struct {
KSPROPERTY Property;
KSPIN_DATAFLOW Direction; // KSPIN_DATAFLOW_IN or KSPIN_DATAFLOW_OUT?
ULONG Index; // Which pin to return data for?
ULONG PinType; // KS_PhysConn_Video_* or KS_PhysConn_Audio_*
ULONG RelatedPinIndex; // For video pins, this is the related audio pin
KSPIN_MEDIUM Medium; // Identifies the hardware connection
} KSPROPERTY_CROSSBAR_PININFO_S, *PKSPROPERTY_CROSSBAR_PININFO_S;
typedef struct {
KSPROPERTY Property;
ULONG IndexInputPin; // Zero based index of the input pin
ULONG IndexOutputPin; // Zero based index of the output pin
ULONG CanRoute; // returns non-zero on CAN_ROUTE if routing is possible
} KSPROPERTY_CROSSBAR_ROUTE_S, *PKSPROPERTY_CROSSBAR_ROUTE_S;
#define STATIC_EVENTSETID_CROSSBAR
0x6a2e0641L, 0x28e4, 0x11d0, 0xa1, 0x8c, 0x00, 0xa0, 0xc9, 0x11, 0x89, 0x56
DEFINE_GUIDSTRUCT("6a2e0641-28e4-11d0-a18c-00a0c9118956", EVENTSETID_CROSSBAR);
#define EVENTSETID_CROSSBAR DEFINE_GUIDNAMED(EVENTSETID_CROSSBAR)
typedef enum {
KSEVENT_CROSSBAR_CHANGED
} KSEVENT_CROSSBAR;
// The following IDs should match the AM equivalents
typedef enum {
KS_PhysConn_Video_Tuner = 1,
KS_PhysConn_Video_Composite,
KS_PhysConn_Video_SVideo,
KS_PhysConn_Video_RGB,
KS_PhysConn_Video_YRYBY,
KS_PhysConn_Video_SerialDigital,
KS_PhysConn_Video_ParallelDigital,
KS_PhysConn_Video_SCSI,
KS_PhysConn_Video_AUX,
KS_PhysConn_Video_1394,
KS_PhysConn_Video_USB,
KS_PhysConn_Video_VideoDecoder,
KS_PhysConn_Video_VideoEncoder,
KS_PhysConn_Video_SCART,
KS_PhysConn_Audio_Tuner = 4096,
KS_PhysConn_Audio_Line,
KS_PhysConn_Audio_Mic,
KS_PhysConn_Audio_AESDigital,
KS_PhysConn_Audio_SPDIFDigital,
KS_PhysConn_Audio_SCSI,
KS_PhysConn_Audio_AUX,
KS_PhysConn_Audio_1394,
KS_PhysConn_Audio_USB,
KS_PhysConn_Audio_AudioDecoder,
} KS_PhysicalConnectorType;
//===========================================================================
#define STATIC_PROPSETID_VIDCAP_TVAUDIO
0x6a2e0650L, 0x28e4, 0x11d0, 0xa1, 0x8c, 0x00, 0xa0, 0xc9, 0x11, 0x89, 0x56
DEFINE_GUIDSTRUCT("6a2e0650-28e4-11d0-a18c-00a0c9118956", PROPSETID_VIDCAP_TVAUDIO);
#define PROPSETID_VIDCAP_TVAUDIO DEFINE_GUIDNAMED(PROPSETID_VIDCAP_TVAUDIO)
typedef enum {
KSPROPERTY_TVAUDIO_CAPS, // R
KSPROPERTY_TVAUDIO_MODE, // RW
KSPROPERTY_TVAUDIO_CURRENTLY_AVAILABLE_MODES // R
} KSPROPERTY_VIDCAP_TVAUDIO;
#define KS_TVAUDIO_MODE_MONO 0x0001 // Mono
#define KS_TVAUDIO_MODE_STEREO 0x0002 // Stereo
#define KS_TVAUDIO_MODE_LANG_A 0x0010 // Primary language
#define KS_TVAUDIO_MODE_LANG_B 0x0020 // 2nd avail language
#define KS_TVAUDIO_MODE_LANG_C 0x0040 // 3rd avail language
typedef struct {
KSPROPERTY Property;
ULONG Capabilities; // Bitmask of KS_TVAUDIO_MODE_*
KSPIN_MEDIUM InputMedium;
KSPIN_MEDIUM OutputMedium;
} KSPROPERTY_TVAUDIO_CAPS_S, *PKSPROPERTY_TVAUDIO_CAPS_S;
typedef struct {
KSPROPERTY Property;
ULONG Mode; // KS_TVAUDIO_MODE_*
} KSPROPERTY_TVAUDIO_S, *PKSPROPERTY_TVAUDIO_S;
#define STATIC_KSEVENTSETID_VIDCAP_TVAUDIO
0x6a2e0651L, 0x28e4, 0x11d0, 0xa1, 0x8c, 0x00, 0xa0, 0xc9, 0x11, 0x89, 0x56
DEFINE_GUIDSTRUCT("6a2e0651-28e4-11d0-a18c-00a0c9118956", KSEVENTSETID_VIDCAP_TVAUDIO);
#define KSEVENTSETID_VIDCAP_TVAUDIO DEFINE_GUIDNAMED(KSEVENTSETID_VIDCAP_TVAUDIO)
typedef enum {
KSEVENT_TVAUDIO_CHANGED,
} KSEVENT_TVAUDIO;
//===========================================================================
#define STATIC_PROPSETID_VIDCAP_VIDEOCOMPRESSION
0xC6E13343L, 0x30AC, 0x11d0, 0xA1, 0x8C, 0x00, 0xA0, 0xC9, 0x11, 0x89, 0x56
DEFINE_GUIDSTRUCT("C6E13343-30AC-11d0-A18C-00A0C9118956", PROPSETID_VIDCAP_VIDEOCOMPRESSION);
#define PROPSETID_VIDCAP_VIDEOCOMPRESSION DEFINE_GUIDNAMED(PROPSETID_VIDCAP_VIDEOCOMPRESSION)
typedef enum {
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
} KSPROPERTY_VIDCAP_VIDEOCOMPRESSION;
typedef enum {
KS_CompressionCaps_CanQuality = 1,
KS_CompressionCaps_CanCrunch = 2,
KS_CompressionCaps_CanKeyFrame = 4,
KS_CompressionCaps_CanBFrame = 8,
KS_CompressionCaps_CanWindow = 0x10,
} KS_CompressionCaps;
typedef struct {
KSPROPERTY Property;
// Note, no VersionString!
// Note, no DescriptionString!
ULONG StreamIndex; // zero based index of stream
LONG DefaultKeyFrameRate; // Key frame rate
LONG DefaultPFrameRate; // Predeicted frames per Key frame
LONG DefaultQuality; // 0 to 10000
LONG NumberOfQualitySettings; // How many discreet quality settings?
LONG Capabilities; // KS_CompressionCaps_*
} KSPROPERTY_VIDEOCOMPRESSION_GETINFO_S, *PKSPROPERTY_VIDEOCOMPRESSION_GETINFO_S;
typedef struct {
KSPROPERTY Property;
ULONG StreamIndex; // zero based index of stream
LONG Value; // value to get or set
} KSPROPERTY_VIDEOCOMPRESSION_S, *PKSPROPERTY_VIDEOCOMPRESSION_S;
//===========================================================================
// MEDIASUBTYPE_Overlay
#define STATIC_KSDATAFORMAT_SUBTYPE_OVERLAY
0xe436eb7fL, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70
DEFINE_GUIDSTRUCT("e436eb7f-524f-11ce-9f53-0020af0ba770", KSDATAFORMAT_SUBTYPE_OVERLAY);
#define KSDATAFORMAT_SUBTYPE_OVERLAY DEFINE_GUIDNAMED(KSDATAFORMAT_SUBTYPE_OVERLAY)
#define STATIC_KSPROPSETID_OverlayUpdate
0x490EA5CFL, 0x7681, 0x11D1, 0xA2, 0x1C, 0x00, 0xA0, 0xC9, 0x22, 0x31, 0x96
DEFINE_GUIDSTRUCT("490EA5CF-7681-11D1-A21C-00A0C9223196", KSPROPSETID_OverlayUpdate);
#define KSPROPSETID_OverlayUpdate DEFINE_GUIDNAMED(KSPROPSETID_OverlayUpdate)
typedef enum {
KSPROPERTY_OVERLAYUPDATE_INTERESTS,
KSPROPERTY_OVERLAYUPDATE_CLIPLIST = 0x1,
KSPROPERTY_OVERLAYUPDATE_PALETTE = 0x2,
KSPROPERTY_OVERLAYUPDATE_COLORKEY = 0x4,
KSPROPERTY_OVERLAYUPDATE_VIDEOPOSITION = 0x8,
KSPROPERTY_OVERLAYUPDATE_DISPLAYCHANGE = 0x10,
KSPROPERTY_OVERLAYUPDATE_COLORREF = 0x10000000
} KSPROPERTY_OVERLAYUPDATE;
typedef struct {
ULONG PelsWidth;
ULONG PelsHeight;
ULONG BitsPerPel;
WCHAR DeviceID[1];
} KSDISPLAYCHANGE, *PKSDISPLAYCHANGE;
#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)
//===========================================================================
#define STATIC_PROPSETID_VIDCAP_VIDEOCONTROL
0x6a2e0670L, 0x28e4, 0x11d0, 0xa1, 0x8c, 0x00, 0xa0, 0xc9, 0x11, 0x89, 0x56
DEFINE_GUIDSTRUCT("6a2e0670-28e4-11d0-a18c-00a0c9118956", PROPSETID_VIDCAP_VIDEOCONTROL);
#define PROPSETID_VIDCAP_VIDEOCONTROL DEFINE_GUIDNAMED(PROPSETID_VIDCAP_VIDEOCONTROL)
typedef enum {
KSPROPERTY_VIDEOCONTROL_CAPS, // R
KSPROPERTY_VIDEOCONTROL_ACTUAL_FRAME_RATE, // R O
KSPROPERTY_VIDEOCONTROL_FRAME_RATES, // R O
KSPROPERTY_VIDEOCONTROL_MODE, // RWO
} KSPROPERTY_VIDCAP_VIDEOCONTROL;
typedef enum {
KS_VideoControlFlag_FlipHorizontal = 0x0001,
KS_VideoControlFlag_FlipVertical = 0x0002,
KS_Obsolete_VideoControlFlag_ExternalTriggerEnable = 0x0010, // ***WARNING *** Flag msimatch with DSHOW.
KS_Obsolete_VideoControlFlag_Trigger = 0x0020, // ***WARNING *** Flag msimatch with DSHOW.
KS_VideoControlFlag_ExternalTriggerEnable = 0x0004,
KS_VideoControlFlag_Trigger = 0x0008,
} KS_VideoControlFlags;
typedef struct {
KSPROPERTY Property;
ULONG StreamIndex;
ULONG VideoControlCaps; // KS_VideoControlFlags_*
} KSPROPERTY_VIDEOCONTROL_CAPS_S, *PKSPROPERTY_VIDEOCONTROL_CAPS_S;
typedef struct {
KSPROPERTY Property;
ULONG StreamIndex;
LONG Mode; // KS_VideoControlFlags_*
} KSPROPERTY_VIDEOCONTROL_MODE_S, *PKSPROPERTY_VIDEOCONTROL_MODE_S;
typedef struct {
KSPROPERTY Property;
ULONG StreamIndex; // Index of stream
ULONG RangeIndex; // Index of range
SIZE Dimensions; // Size of image
LONGLONG CurrentActualFrameRate; // Only correct if pin is open
LONGLONG CurrentMaxAvailableFrameRate; // Max Rate temporarily limited on USB or 1394?
} KSPROPERTY_VIDEOCONTROL_ACTUAL_FRAME_RATE_S, *PKSPROPERTY_VIDEOCONTROL_ACTUAL_FRAME_RATE_S;
// KSPROPERTY_VIDEOCONTROL_FRAME_RATES returns a list of available frame rates in 100 nS units
typedef struct {
KSPROPERTY Property;
ULONG StreamIndex; // Index of stream
ULONG RangeIndex; // Index of range
SIZE Dimensions; // Size of image
} KSPROPERTY_VIDEOCONTROL_FRAME_RATES_S, *PKSPROPERTY_VIDEOCONTROL_FRAME_RATES_S;
//===========================================================================
#define STATIC_PROPSETID_VIDCAP_DROPPEDFRAMES
0xC6E13344L, 0x30AC, 0x11d0, 0xa1, 0x8c, 0x00, 0xa0, 0xc9, 0x11, 0x89, 0x56
DEFINE_GUIDSTRUCT("C6E13344-30AC-11d0-A18C-00A0C9118956", PROPSETID_VIDCAP_DROPPEDFRAMES);
#define PROPSETID_VIDCAP_DROPPEDFRAMES DEFINE_GUIDNAMED(PROPSETID_VIDCAP_DROPPEDFRAMES)
typedef enum {
KSPROPERTY_DROPPEDFRAMES_CURRENT // R
} KSPROPERTY_VIDCAP_DROPPEDFRAMES;
typedef struct {
KSPROPERTY Property;
LONGLONG PictureNumber; // Current Picture Number
LONGLONG DropCount; // Count of frames dropped
ULONG AverageFrameSize; // Average size of frames captured
} KSPROPERTY_DROPPEDFRAMES_CURRENT_S, *PKSPROPERTY_DROPPEDFRAMES_CURRENT_S;
//===========================================================================
// VPE
#define STATIC_KSPROPSETID_VPConfig
0xbc29a660L, 0x30e3, 0x11d0, 0x9e, 0x69, 0x00, 0xc0, 0x4f, 0xd7, 0xc1, 0x5b
DEFINE_GUIDSTRUCT("bc29a660-30e3-11d0-9e69-00c04fd7c15b", KSPROPSETID_VPConfig);
#define KSPROPSETID_VPConfig DEFINE_GUIDNAMED(KSPROPSETID_VPConfig)
#define STATIC_KSPROPSETID_VPVBIConfig
0xec529b00L, 0x1a1f, 0x11d1, 0xba, 0xd9, 0x0, 0x60, 0x97, 0x44, 0x11, 0x1a
DEFINE_GUIDSTRUCT("ec529b00-1a1f-11d1-bad9-00609744111a", KSPROPSETID_VPVBIConfig);
#define KSPROPSETID_VPVBIConfig DEFINE_GUIDNAMED(KSPROPSETID_VPVBIConfig)
// Both of the above property sets use the same list of properties below
typedef enum {
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
} KSPROPERTY_VPCONFIG;
//=========================
// IBasicAudio
//
#define STATIC_CLSID_KsIBasicAudioInterfaceHandler
0xb9f8ac3e, 0x0f71, 0x11d2, 0xb7, 0x2c, 0x00, 0xc0, 0x4f, 0xb6, 0xbd, 0x3d
DEFINE_GUIDSTRUCT("b9f8ac3e-0f71-11d2-b72c-00c04fb6bd3d", CLSID_KsIBasicAudioInterfaceHandler);
#define CLSID_KsIBasicAudioInterfaceHandler DEFINE_GUIDNAMED(CLSID_KsIBasicAudioInterfaceHandler)
#if defined(__IVPType__)
typedef struct {
AMVPSIZE Size;
DWORD MaxPixelsPerSecond;
DWORD Reserved;
} KSVPMAXPIXELRATE, *PKSVPMAXPIXELRATE;
typedef struct {
KSPROPERTY Property;
AMVPSIZE Size;
} KSVPSIZE_PROP, *PKSVPSIZE_PROP;
typedef struct {
DWORD dwPitch;
DWORD dwXOrigin;
DWORD dwYOrigin;
} KSVPSURFACEPARAMS, *PKSVPSURFACEPARAMS;
#else // !defined(__IVPType__)
#if !defined(__DDRAW_INCLUDED__)
//==========================================================================
// The following definitions must be in sync with DDraw.h in DirectX SDK
//==========================================================================
/*
* The FourCC code is valid.
*/
#define DDPF_FOURCC 0x00000004l
typedef struct _DDPIXELFORMAT
{
DWORD dwSize; // size of structure
DWORD dwFlags; // pixel format flags
DWORD dwFourCC; // (FOURCC code)
union
{
DWORD dwRGBBitCount; // how many bits per pixel (BD_1,2,4,8,16,24,32)
DWORD dwYUVBitCount; // how many bits per pixel (BD_4,8,16,24,32)
DWORD dwZBufferBitDepth; // how many bits for z buffers (BD_8,16,24,32)
DWORD dwAlphaBitDepth; // how many bits for alpha channels (BD_1,2,4,8)
};
union
{
DWORD dwRBitMask; // mask for red bit
DWORD dwYBitMask; // mask for Y bits
};
union
{
DWORD dwGBitMask; // mask for green bits
DWORD dwUBitMask; // mask for U bits
};
union
{
DWORD dwBBitMask; // mask for blue bits
DWORD dwVBitMask; // mask for V bits
};
union
{
DWORD dwRGBAlphaBitMask; // mask for alpha channel
DWORD dwYUVAlphaBitMask; // mask for alpha channel
DWORD dwRGBZBitMask; // mask for Z channel
DWORD dwYUVZBitMask; // mask for Z channel
};
} DDPIXELFORMAT, * LPDDPIXELFORMAT;
#endif // !defined(__DDRAW_INCLUDED__)
//==========================================================================
// End of DDraw.h header info
//==========================================================================
//==========================================================================
// The following definitions must be in sync with DVP.h in DirectX SDK
//==========================================================================
#if !defined(__DVP_INCLUDED__)
typedef struct _DDVIDEOPORTCONNECT {
DWORD dwSize; // size of the DDVIDEOPORTCONNECT structure
DWORD dwPortWidth; // Width of the video port
GUID guidTypeID; // Description of video port connection
DWORD dwFlags; // Connection flags
DWORD dwReserved1; // Reserved, set to zero.
} DDVIDEOPORTCONNECT, * LPDDVIDEOPORTCONNECT;
#define DDVPTYPE_E_HREFH_VREFH
0x54F39980L,0xDA60,0x11CF,0x9B,0x06,0x00,0xA0,0xC9,0x03,0xA3,0xB8
#define DDVPTYPE_E_HREFL_VREFL
0xE09C77E0L,0xDA60,0x11CF,0x9B,0x06,0x00,0xA0,0xC9,0x03,0xA3,0xB8
#endif // !defined(__DVP_INCLUDED__)
//==========================================================================
// End of DVP.h header info
//==========================================================================
//==========================================================================
// The following definitions must be in sync with VPType.h in AM 2.0 SDK
//==========================================================================
// pixel aspect ratios corresponding to a 720x480 NTSC image or a 720x576 image
typedef enum // AMPixAspectRatio
{
KS_PixAspectRatio_NTSC4x3,
KS_PixAspectRatio_NTSC16x9,
KS_PixAspectRatio_PAL4x3,
KS_PixAspectRatio_PAL16x9,
} KS_AMPixAspectRatio ;
typedef enum // AMVP_SELECTFORMATBY
{
KS_AMVP_DO_NOT_CARE,
KS_AMVP_BEST_BANDWIDTH,
KS_AMVP_INPUT_SAME_AS_OUTPUT
} KS_AMVP_SELECTFORMATBY;
typedef enum // AMVP_MODE
{
KS_AMVP_MODE_WEAVE,
KS_AMVP_MODE_BOBINTERLEAVED,
KS_AMVP_MODE_BOBNONINTERLEAVED,
KS_AMVP_MODE_SKIPEVEN,
KS_AMVP_MODE_SKIPODD
} KS_AMVP_MODE ;
typedef struct tagKS_AMVPDIMINFO // AMVPDIMINFO
{
DWORD dwFieldWidth ; // [out] field width
DWORD dwFieldHeight ; // [out] field height
DWORD dwVBIWidth ; // [out] VBI data width
DWORD dwVBIHeight ; // [out] VBI data height
RECT rcValidRegion ; // [out] valid rect for data cropping
} KS_AMVPDIMINFO, *PKS_AMVPDIMINFO ;
typedef struct tagKS_AMVPDATAINFO // AMVPDATAINFO
{
DWORD dwSize; // Size of the struct
DWORD dwMicrosecondsPerField; // Time taken by each field
KS_AMVPDIMINFO amvpDimInfo; // Dimensional Information
DWORD dwPictAspectRatioX; // Pict aspect ratio in X dimn
DWORD dwPictAspectRatioY; // Pict aspect ratio in Y dimn
BOOL bEnableDoubleClock; // Videoport should enable double clocking
BOOL bEnableVACT; // Videoport should use an external VACT signal
BOOL bDataIsInterlaced; // Indicates that the signal is interlaced
LONG lHalfLinesOdd; // number of halflines in the odd field
BOOL bFieldPolarityInverted; // Device inverts the polarity by default
DWORD dwNumLinesInVREF; // Number of lines of data in VREF
LONG lHalfLinesEven; // number of halflines in the even field
DWORD dwReserved1; // Reserved for future use
} KS_AMVPDATAINFO, *PKS_AMVPDATAINFO;
typedef struct tagKS_AMVPSIZE // AMVPSIZE
{
DWORD dwWidth ; // [in] width in pixels
DWORD dwHeight ; // [in] height in pixels
} KS_AMVPSIZE, *PKS_AMVPSIZE ;
//==========================================================================
// End of VPType.h header info
//==========================================================================
typedef struct {
KS_AMVPSIZE Size;
DWORD MaxPixelsPerSecond;
DWORD Reserved;
} KSVPMAXPIXELRATE, *PKSVPMAXPIXELRATE;
typedef struct {
KSPROPERTY Property;
KS_AMVPSIZE Size;
} KSVPSIZE_PROP, *PKSVPSIZE_PROP;
typedef struct {
DWORD dwPitch;
DWORD dwXOrigin;
DWORD dwYOrigin;
} KSVPSURFACEPARAMS, *PKSVPSURFACEPARAMS;
#endif // !defined(__IVPType__)
//
// IVPNotify event notification
//
#define STATIC_KSEVENTSETID_VPNotify
0x20c5598eL, 0xd3c8, 0x11d0, 0x8d, 0xfc, 0x00, 0xc0, 0x4f, 0xd7, 0xc0, 0x8b
DEFINE_GUIDSTRUCT("20c5598e-d3c8-11d0-8dfc-00c04fd7c08b", KSEVENTSETID_VPNotify);
#define KSEVENTSETID_VPNotify DEFINE_GUIDNAMED(KSEVENTSETID_VPNotify)
typedef enum {
KSEVENT_VPNOTIFY_FORMATCHANGE,
} KSEVENT_VPNOTIFY;
//
// VIDCAPTOSTI event notification
//
#define STATIC_KSEVENTSETID_VIDCAPTOSTI
0xdb47de20, 0xf628, 0x11d1, 0xba, 0x41, 0x0, 0xa0, 0xc9, 0xd, 0x2b, 0x5
DEFINE_GUIDSTRUCT("DB47DE20-F628-11d1-BA41-00A0C90D2B05", KSEVENTSETID_VIDCAPTOSTI);
#define KSEVENTSETID_VIDCAPNotify DEFINE_GUIDNAMED(KSEVENTSETID_VIDCAPTOSTI)
typedef enum {
KSEVENT_VIDCAPTOSTI_EXT_TRIGGER,
} KSEVENT_VIDCAPTOSTI;
//
// IVPVBINotify event notification
//
#define STATIC_KSEVENTSETID_VPVBINotify
0xec529b01L, 0x1a1f, 0x11d1, 0xba, 0xd9, 0x0, 0x60, 0x97, 0x44, 0x11, 0x1a
DEFINE_GUIDSTRUCT("ec529b01-1a1f-11d1-bad9-00609744111a", KSEVENTSETID_VPVBINotify);
#define KSEVENTSETID_VPVBINotify DEFINE_GUIDNAMED(KSEVENTSETID_VPVBINotify)
typedef enum {
KSEVENT_VPVBINOTIFY_FORMATCHANGE,
} KSEVENT_VPVBINOTIFY;
//
// closed caption information
//
#define STATIC_KSDATAFORMAT_TYPE_AUXLine21Data
0x670aea80L, 0x3a82, 0x11d0, 0xb7, 0x9b, 0x00, 0xaa, 0x00, 0x37, 0x67, 0xa7
DEFINE_GUIDSTRUCT("670aea80-3a82-11d0-b79b-00aa003767a7", KSDATAFORMAT_TYPE_AUXLine21Data);
#define KSDATAFORMAT_TYPE_AUXLine21Data DEFINE_GUIDNAMED(KSDATAFORMAT_TYPE_AUXLine21Data)
#define STATIC_KSDATAFORMAT_SUBTYPE_Line21_BytePair
0x6e8d4a22L, 0x310c, 0x11d0, 0xb7, 0x9a, 0x00, 0xaa, 0x00, 0x37, 0x67, 0xa7
DEFINE_GUIDSTRUCT("6e8d4a22-310c-11d0-b79a-00aa003767a7", KSDATAFORMAT_SUBTYPE_Line21_BytePair);
#define KSDATAFORMAT_SUBTYPE_Line21_BytePair DEFINE_GUIDNAMED(KSDATAFORMAT_SUBTYPE_Line21_BytePair)
#define STATIC_KSDATAFORMAT_SUBTYPE_Line21_GOPPacket
0x6e8d4a23L, 0x310c, 0x11d0, 0xb7, 0x9a, 0x00, 0xaa, 0x00, 0x37, 0x67, 0xa7
DEFINE_GUIDSTRUCT("6e8d4a23-310c-11d0-b79a-00aa003767a7", KSDATAFORMAT_SUBTYPE_Line21_GOPPacket);
#define KSDATAFORMAT_SUBTYPE_Line21_GOPPacket DEFINE_GUIDNAMED(KSDATAFORMAT_SUBTYPE_Line21_GOPPacket)
typedef struct _KSGOP_USERDATA {
ULONG sc;
ULONG reserved1;
BYTE cFields;
CHAR l21Data[3];
} KSGOP_USERDATA, *PKSGOP_USERDATA;
//
// DVD encrypted PACK format type definition
//
#define STATIC_KSDATAFORMAT_TYPE_DVD_ENCRYPTED_PACK
0xed0b916a, 0x044d, 0x11d1, 0xaa, 0x78, 0x00, 0xc0, 0x4f, 0xc3, 0x1d, 0x60
DEFINE_GUIDSTRUCT("ed0b916a-044d-11d1-aa78-00c04fc31d60", KSDATAFORMAT_TYPE_DVD_ENCRYPTED_PACK);
#define KSDATAFORMAT_TYPE_DVD_ENCRYPTED_PACK DEFINE_GUIDNAMED(KSDATAFORMAT_TYPE_DVD_ENCRYPTED_PACK)
#define KS_AM_UseNewCSSKey 0x1
// -----------------------------------------------------------------------
// KS_AM_KSPROPSETID_TSRateChange property set definitions for time stamp
// rate changes.
// -----------------------------------------------------------------------
#define STATIC_KSPROPSETID_TSRateChange
0xa503c5c0, 0x1d1d, 0x11d1, 0xad, 0x80, 0x44, 0x45, 0x53, 0x54, 0x0, 0x0
DEFINE_GUIDSTRUCT("A503C5C0-1D1D-11D1-AD80-444553540000", KSPROPSETID_TSRateChange);
#define KSPROPSETID_TSRateChange DEFINE_GUIDNAMED(KSPROPSETID_TSRateChange)
typedef enum {
KS_AM_RATE_SimpleRateChange=1, // rw, use KS_AM_SimpleRateChange
KS_AM_RATE_ExactRateChange=2, // rw, use KS_AM_ExactRateChange
KS_AM_RATE_MaxFullDataRate=3, // r, use KS_AM_MaxFullDataRate
KS_AM_RATE_Step=4 // w, use KS_AM_Step
} KS_AM_PROPERTY_TS_RATE_CHANGE;
typedef struct {
// 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).
REFERENCE_TIME StartTime; //stream time at which to start this rate
LONG Rate; //new rate * 10000 (decimal)
} KS_AM_SimpleRateChange, *PKS_AM_SimpleRateChange;
typedef struct {
REFERENCE_TIME OutputZeroTime; //input TS that maps to zero output TS
LONG Rate; //new rate * 10000 (decimal)
} KS_AM_ExactRateChange, *PKS_AM_ExactRateChange;
typedef LONG KS_AM_MaxFullDataRate; //rate * 10000 (decimal)
typedef DWORD KS_AM_Step; // number of frame to step
#endif // !defined(_KSMEDIA_)