mpegcmn.h

神龙卡 SDK_84xx_DShow_145_02.zip 这个是 windows 上二个是linux

// Mpeg4 capability
#define MPEG_CAPABILITY_MPEG4_DECODE             0x00000010

// Gamma correction can be adjusted
#define MPEG_CAPABILITY_GAMMA_ADJUST             0x00000020

// ????????
#define MPEG_CAPABILITY_HIRES                    0x00000040

// ????????
#define MPEG_CAPABILITY_USES_VPM                 0x00000080

// The hardware can play DVD titles
#define MPEG_CAPABILITY_DVD_CAN_PLAY             0x00000100

// ????????
#define MPEG_CAPABILITY_ASPECT_RATIO             0x00000200

// The video can be displayed on the VGA monitor. Note that it might
// also be possible to display it on TV when MPEG_CAPABILITY_TV_OUTPUT
// is set but it may not be possible at the same time. Use the flag
// MPEG_CAPABILITY_VGA_AND_TV to find if this is possible.
#define MPEG_CAPABILITY_VGA_WINDOW               0x00000400

// Indicates that hardware decryption is supported by the hardware
#define MPEG_CAPABILITY_DVD_DECRYPTION           0x00000800

// Used by DVD station to know if the video source size can change
// depending on the VGA alignement. This is to determine the default DVD
// station window size and to prevent scaling (and therefore video
// artifacts) when scale is 1:1.
#define MPEG_CAPABILITY_SRC_CHANGE               0x00001000

// Indicates that the hardware supports Frame Fast Forward
#define MPEG_CAPABILITY_FRAME_FF                 0x00002000

// The video can be displayed on TV. Note that it might also be possible
// to display the video on VGA when the flag MPEG_CAPABILITY_VGA_WINDOW
// is set but it may not be possible at the same time. Use the flag
// MPEG_CAPABILITY_VGA_AND_TV to find if this is possible.
#define MPEG_CAPABILITY_TV_OUTPUT                0x00004000

// Indicates that the video can be displayed both on TV and VGA. When this
// flag is set, both flag MPEG_CAPABILITY_VGA_WINDOW and 
// MPEG_CAPABILITY_TV_OUTPUT needs to be set. This capability can change
// in real time depending on the TV output format set using MpegAttrVideoTv.
// Therefore, every time DVD station changes the TV output format to
// PAL or NTSC with or without scale, it needs to verify this flag.
#define MPEG_CAPABILITY_VGA_AND_TV               0x00008000

// Indicates that the TV supports PAL 60, Note that this flag is invalid when
// MPEG_CAPABILITY_TV_OUTPUT is not set. Note also that PAL60 can only be used
// when source is NTSC unless MPEG_CAPABILITY_PAL_NTSC_CONVERT is set. This
// capability does not concern VGA.
#define MPEG_CAPABILITY_PAL60                    0x00010000

// Indicates that the hardware is capable of converting NTSC source into PAL and
// vice-versa. This is mostly usefull when a TV output is present.
#define MPEG_CAPABILITY_PAL_NTSC_CONVERT         0x00020000

// Indicates that the video can be displayed on a HDTV (progressive scan). This
// output format is incompatible (for now) with VGA and TV (ie, it cannot be
// displayed both on HDTV and TV or HDTV and VGA).
#define MPEG_CAPABILITY_HDTV_OUTPUT              0x00040000

// Indicates that the video on VGA cannot be scaled (Dragon products)
// MPEG_CAPABILITY_VGA_WINDOW cannot be set in the same time
#define MPEG_CAPABILITY_FULLSCREEN_ONLY          0x00080000

// Indicates that the video output cannot play simultaneously on VGA 
// and TV. If set DVD station will paint a VGA_TV button.
#define MPEG_CAPABILITY_VGATV_SWITCH_BUTTON      0x00100000

// Indicates that the TV encoder can be slightly adjusted for color
// control one some PAL TVs that only display back and white.
#define MPEG_CAPABILITY_TV_TOLERANCE             0x00200000

// Indicates that the EEPROM to store the region code is present on the board
#define MPEG_CAPABILITY_EEPROM_PRESENT           0x00400000

// Indicates that hardware supports seeking accurately (this is used by DirectShow
// in order to allow playing first frame after a StreamPause or Video flush).
#define MPEG_CAPABILITY_SEEK_ACCURATE            0x00800000

// Indicates that hardware only supports NTSC (Only used for IGS to prevent
// double conversion)
#define MPEG_CAPABILITY_NTSC_ONLY                0x01000000

// Indicates that hardware only supports NTSC (Only used for IGS to prevent
// double conversion)
#define MPEG_CAPABILITY_PAL_ONLY                 0x02000000

// Indicates that hardware supports Tv Component YUV
#define MPEG_CAPABILITY_TV_YUV_COMPONENT		0x04000000

// Indicates that hardware can play in the same time PCM data
// through Dac and Spdif
#define MPEG_CAPABILITY_DAC_SPDIF				0x08000000

// Indicates that hardware has a 480P connector to display fullscreen on
// another Vga monitor - Ventura2000
#define MPEG_CAPABILITY_480P					0x10000000

// Indicates that hardware supports Tv Component RGB
#define MPEG_CAPABILITY_TV_RGB_COMPONENT		0x20000000

// Indicates that hardware has DVI output
#define MPEG_CAPABILITY_DVI						0x40000000

// Indicates that hardware has the audio clock controlled by VCXO
#define MPEG_CAPABILITY_AUDIO_VCXO				0x80000000
/*
#ifndef _RMDEV_CAPABILITIES_DEFINED_
#define _RMDEV_CAPABILITIES_DEFINED_

typedef enum {
	RMCAP_Flags_cap0,
	RMCAP_Flags_cap1_dw,
	RMCAP_Flags_cap1_ull
}RMCAP_TYPE;

typedef struct {
    ULONG    Size;
    ULONG    Count;
} RMMULTIPLE_ITEM, *PRMMULTIPLE_ITEM;

typedef struct{
	RMCAP_TYPE	type;
	union{
		ULONG	Capabilities;
		PVOID	pExtraData;	
	}cap0;
	union{
		DWORD			dwCaps[2];
		ULONGLONG		ullCaps;
		RMMULTIPLE_ITEM	multi_header;
	}cap1;
}RMDEV_CAPABILITIES,*PRMDEV_CAPABILITIES;

#endif // _RMDEV_CAPABILITIES_DEFINED_
*/
typedef enum _MPEG_DEVICE_TYPE
{
    MpegAudioDevice,
    MpegVideoDevice,
    MpegOverlayDevice,
    MpegCombinedDevice,
	MpegSubpictureDevice
} MPEG_DEVICE_TYPE, *PMPEG_DEVICE_TYPE;

typedef enum _MPEG_STREAM_TYPE
{
    MpegSystemStream = 1,
    MpegAudioStream,
    MpegVideoStream,
	MpegSubpictureStream,
	MpegPCIStream
} MPEG_STREAM_TYPE, *PMPEG_STREAM_TYPE;

typedef enum _MPEG_CAPABILITY
{
    MpegCapAudioDevice = 0,
    MpegCapVideoDevice,
    MpegCapSeparateStreams,
    MpegCapCombinedStreams,
    MpegCapBitmaskOverlay,
    MpegCapChromaKeyOverlay,
    MpegCapAudioRenderToMemory,
    MpegCapVideoRenderToMemory,
	MpegCapSubPictureDevice,
    MpegCapMaximumCapability
} MPEG_CAPABILITY, *PMPEG_CAPABILITY;

#define MPEG_OEM_CAPABILITY(a)  ((MPEG_CAPABILITY)(((unsigned)a) + 0x00008000))

typedef enum _MPEG_INFO_ITEM
{
    MpegInfoCurrentPendingRequest = 1,      // Video and Audio
    MpegInfoMaximumPendingRequests,         // Video and Audio
    MpegInfoDecoderBufferSize,              // Video and Audio
    MpegInfoDecoderBufferBytesInUse,        // Video and Audio
    MpegInfoCurrentPacketBytesOutstanding,  // Video and Audio
    MpegInfoCurrentFrameNumber,             // Video and Audio
    MpegInfoStarvationCount,                // Video and Audio
    MpegInfoDecompressHeight,               // Video
    MpegInfoDecompressWidth,                // Video
    MpegInfoMinDestinationHeight,           // Overlay
    MpegInfoMaxDestinationHeight,           // Overlay
    MpegInfoMinDestinationWidth,            // Overlay
    MpegInfoMaxDestinationWidth,            // Overlay
	MpegInfoEventStatus,					// Video and Audio
	MpegInfoHwDecode						// Audio
} MPEG_INFO_ITEM, *PMPEG_INFO_ITEM;

#define MPEG_OEM_INFO_ITEM(a)   ((MPEG_INFO_ITEM)(((unsigned)a) + 0x00008000))

typedef enum _MPEG_DEVICE_STATE
{
    MpegStateStartup = 0,
    MpegStatePaused,
    MpegStatePlaying,
    MpegStateStarved,
    MpegStateFailed,
	MpegStateFrozen
} MPEG_DEVICE_STATE, *PMPEG_DEVICE_STATE;

typedef enum _REQUESTED_STATE_TYPE {
    RequestedNone = 0,
    RequestedPlay,
    RequestedPause,
    RequestedStop
} REQUESTED_STATE_TYPE;

typedef enum _MPEG_OVERLAY_MODE
{
    MpegModeNone = 1,
    MpegModeRectangle,
    MpegModeOverlay,
	MpegModeCalibrate
} MPEG_OVERLAY_MODE, *PMPEG_OVERLAY_MODE;

typedef enum _MPEG_EVENT_TYPE
{
    MpegPulseEvent = 0,
	MpegTimerEvent,
	MpegNullEvent
} MPEG_EVENT_TYPE, *PMPEG_EVENT_TYPE;

typedef enum _MPEG_DISPLAY_CONTEXT
{
	MpegDisplayGdi = 0
} MPEG_DISPLAY_CONTEXT, *PMPEG_DISPLAY_CONTEXT;

#ifdef _WINGDI_

typedef struct _MPEG_DISPLAY_PALETTE
{
	PLOGPALETTE pLogPalette;
	HPALETTE hPalette;
} MPEG_DISPLAY_PALETTE, *PMPEG_DISPLAY_PALETTE;

#endif

typedef enum _MPEG_HLI_CMD
{
	MpegSelectAdjacentButton = 0,
	MpegActivate,
	MpegSelectAndActivate,
	MpegMouseMove,
	MpegMouseButton,
	MpegSelectButton
} MPEG_HLI_CMD, *PMPEG_HLI_CMD;

typedef enum _MPEG_HLI_DIRECTION
{
	MpegUpperButton = 0,
	MpegLowerButton,
	MpegLeftButton,
	MpegRightButton
} MPEG_HLI_DIRECTION, *PMPEG_HLI_DIRECTION;

typedef enum _MPEG_DISPLAY_STATE
{
	MpegDisplayOff = 0,
	MpegDisplayOn
} MPEG_DISPLAY_STATE, *PMPEG_DISPLAY_STATE;

typedef enum _MPEG_DISPLAY_TYPE
{
	MpegDisplayNormal = 0,  //  4:3
	MpegDisplayWide,        // 16:9
	MpegDisplayLetterBox,
	MpegDisplayPanScan
} MPEG_DISPLAY_TYPE, *PMPEG_DISPLAY_TYPE;

typedef struct _MPEG_DISPLAY_RESOLUTION
{
	int iBitsPerPixel;
	int iScreenWidth;
	int iScreenHeight;
} MPEG_DISPLAY_RESOLUTION, *PMPEG_DISPLAY_RESOLUTION;

typedef struct _MPEG_DISPLAY_RESOLUTION_EX
{
	int iBitsPerPixel;
	int iScreenWidth;
	int iScreenHeight;
	int iHFrequency;
	int iTotalPixelsPerLine;
	int iTotalLinesPerFrame;
	int iPixelXOffset;
	int iLineYOffset;
	DWORD dwReserved[4];
} MPEG_DISPLAY_RESOLUTION_EX, *PMPEG_DISPLAY_RESOLUTION_EX;

typedef struct  _MPEG_ASYNC_CONTEXT{
	HANDLE	hEvent;
	ULONG	Reserved[ 10 ];
} MPEG_ASYNC_CONTEXT, *PMPEG_ASYNC_CONTEXT;

// Color limits for one specified color
//
typedef struct tagCOLOR_LIMITS{
	COLORREF crKeyColor;
	COLORREF crUpperLimit;
	COLORREF crLowerLimit;
} COLOR_LIMITS, *PCOLOR_LIMITS;

typedef enum _MPEG_DISPLAY_FRAME
{
	MpegDisplayMotion,
	MpegDisplayStill
} MPEG_DISPLAY_FRAME, *PMPEG_DISPLAY_FRAME;

typedef enum
{
	NO_OWNER,			// WDM, SYS and VXD not currently using the hardware
	OWNER_IS_WDM,
	OWNER_IS_SYS,		// We may want later to differentiate SYS from VxD
	OWNER_IS_VXD
} OWNER, *POWNER;

typedef struct tagHDTV_MODE
{
	DWORD HFreq;
	DWORD VFreq;
	DWORD VideoWidth;
	DWORD VideoHeight;

	DWORD HSyncTotal;	
	DWORD PreHSync;
	DWORD HSyncActive;
	DWORD PostHSync;

	DWORD VSyncTotal;	
	DWORD PreVSync;
	DWORD VSyncActive;
	DWORD PostVSync;

	DWORD PixelFreq;
	DWORD Interlaced;
} HDTV_MODE, *PHDTV_MODE;

//****************************************************************************
// Data Structures
//****************************************************************************

typedef struct _MPEG_PACKET_LIST_ENTRY
{
#ifdef MIDL_PASS
    ADDRESS     pPacketData;
#else
    UCHAR      *pPacketData;
#endif
    ULONG       ulPacketSize;
    MPEG_SYSTEM_TIME Scr;

	// the following 2 fields are used by the windows 95 VxDs
	// please do not use!
	UCHAR		*pData;
	ULONG		ulDataSize;
} MPEG_PACKET_LIST_ENTRY, *PMPEG_PACKET_LIST_ENTRY;

typedef struct _MPEG_ATTRIBUTE_PARAMS
{
    MPEG_ATTRIBUTE Attribute;			// attribute to Get or Set
    LONG	Value;                      // attribute dependent parameter 1
} MPEG_ATTRIBUTE_PARAMS, *PMPEG_ATTRIBUTE_PARAMS;

typedef struct _MPEG_ATTRIBUTE_PARAMS_EX
{
    MPEG_ATTRIBUTE Attribute;	// attribute to Get or Set
    void *pData;				// pointer to attribute data
    ULONG  ulDataSize;			// size of attribute data
} MPEG_ATTRIBUTE_PARAMS_EX, *PMPEG_ATTRIBUTE_PARAMS_EX;

typedef struct _MPEG_OVERLAY_RECT
{
    ULONG X;                         // window x position,width
    ULONG Y;                         // window y position,height
    ULONG cX;                        // window x position,width
    ULONG cY;                        // window y position,height
} MPEG_OVERLAY_RECT, *PMPEG_OVERLAY_RECT;