Mercurial > mplayer.hg

changeset 22859:c5a45e3d6d16

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
updated vidix.h from upstream vidix project
author ben
date Sun, 01 Apr 2007 12:16:49 +0000
parents 6c57087c5a2d
children efe51e2b81c3
files vidix/vidix.h
diffstat 1 files changed, 278 insertions(+), 202 deletions(-) [+]
line wrap: on
line diff
--- a/vidix/vidix.h	Sun Apr 01 11:13:04 2007 +0000
+++ b/vidix/vidix.h	Sun Apr 01 12:16:49 2007 +0000
@@ -22,236 +22,313 @@
 
 #define VIDIX_VERSION 100
 
-			/* returns driver version */
-extern unsigned vixGetVersion( void );
+/* returns driver version */
+extern unsigned vixGetVersion (void);
 
 #define PROBE_NORMAL	0 /* normal probing */
 #define PROBE_FORCE	1 /* ignore device_id but recognize device if it's known */
-			/* Probes video hw.
-			   verbose - specifies verbose level.
-			   force   - specifies force mode - driver should ignore
-			             device_id (danger but useful for new devices)
-			   Returns 0 if ok else errno */
-extern int	vixProbe( int verbose, int force );
-			/* Initializes driver. Returns 0 if ok else errno */
-extern int	vixInit( void );
-			/* Destroys driver */
-extern void	vixDestroy( void );
+
+/* Probes video hw.
+   verbose - specifies verbose level.
+   force   - specifies force mode - driver should ignore
+   device_id (danger but useful for new devices)
+   Returns 0 if ok else errno */
+extern int vixProbe (int verbose, int force);
+
+/* Initializes driver.
+   args	    - specifies driver specific parameters
+   Returns 0 if ok else errno */
+extern int vixInit (const char *args);
+
+/* Destroys driver */
+extern void vixDestroy (void);
 
+typedef enum vidix_dev_type {
+  TYPE_OUTPUT  =        0x00000000,	/* Is a video playback device */
+  TYPE_CAPTURE =	0x00000001,	/* Is a capture device */
+  TYPE_CODEC   =        0x00000002,	/* Device supports hw (de)coding */
+  TYPE_FX      =	0x00000004,	/* Is a video effects device */
+} vidix_dev_type_t;
+
+typedef enum vidix_dev_flag {
+  FLAG_NONE       =	0x00000000, /* No flags defined */
+  FLAG_DMA        =	0x00000001, /* Card can use DMA */
+  /* Card can use DMA only if src pitch == dest pitch */
+  FLAG_EQ_DMA     =	0x00000002,
+  /* Possible to wait for DMA to finish. See BM_DMA_SYNC and BM_DMA_BLOCK */
+  FLAG_SYNC_DMA   =     0x00000004,
+  FLAG_UPSCALER   =	0x00000010, /* Card supports hw upscaling */
+  FLAG_DOWNSCALER =	0x00000020, /* Card supports hw downscaling */
+  FLAG_SUBPIC	  =	0x00001000, /* Card supports DVD subpictures */
+  FLAG_EQUALIZER  =	0x00002000, /* Card supports equalizer */
+} vidix_dev_flag_t;
+  
 typedef struct vidix_capability_s
 {
-	char	name[64];	/* Driver name */
-	char	author[64];	/* Author name */
-#define TYPE_OUTPUT	0x00000000	/* Is a video playback device */
-#define TYPE_CAPTURE	0x00000001	/* Is a capture device */
-#define TYPE_CODEC	0x00000002	/* Device supports hw (de)coding */
-#define TYPE_FX		0x00000004	/* Is a video effects device */
-	int	type;		/* Device type, see below */
-	unsigned reserved0[4];
-	int	maxwidth;
-	int	maxheight;
-	int	minwidth;
-	int	minheight;
-	int	maxframerate;   /* -1 if unlimited */
-#define FLAG_NONE		0x00000000 /* No flags defined */
-#define FLAG_DMA		0x00000001 /* Card can use DMA */
-#define FLAG_EQ_DMA		0x00000002 /* Card can use DMA only if src pitch == dest pitch */
-#define FLAG_UPSCALER		0x00000010 /* Card supports hw upscaling */
-#define FLAG_DOWNSCALER		0x00000020 /* Card supports hw downscaling */
-#define FLAG_SUBPIC		0x00001000 /* Card supports DVD subpictures */
-#define FLAG_EQUALIZER		0x00002000 /* Card supports equalizer */
-	unsigned flags;		/* Feature flags, see above */
-	unsigned short vendor_id;
-	unsigned short device_id;
-	unsigned reserved1[4];
-}vidix_capability_t;
+  char name[64]; /* Driver name */
+  char author[64]; /* Author name */
+  vidix_dev_type_t type;
+  unsigned reserved0[4];
+  int maxwidth;
+  int maxheight;
+  int minwidth;
+  int minheight;
+  int maxframerate; /* -1 if unlimited */
+  vidix_dev_flag_t flags;
+  unsigned short vendor_id;
+  unsigned short device_id;
+  unsigned reserved1[4];
+} vidix_capability_t;
+
+/* Should fill at least type before init.
+   Returns 0 if ok else errno */
+extern int vixGetCapability (vidix_capability_t *);
 
-			/* Should fill at least type before init.
-			   Returns 0 if ok else errno */
-extern int	vixGetCapability(vidix_capability_t *);
+typedef enum vidix_depth {
+  VID_DEPTH_NONE  =		0x0000,
+  VID_DEPTH_1BPP  =		0x0001,
+  VID_DEPTH_2BPP  =		0x0002,
+  VID_DEPTH_4BPP  =		0x0004,
+  VID_DEPTH_8BPP  =		0x0008,
+  VID_DEPTH_12BPP =		0x0010,
+  VID_DEPTH_15BPP =		0x0020,
+  VID_DEPTH_16BPP =		0x0040,
+  VID_DEPTH_24BPP =		0x0080,
+  VID_DEPTH_32BPP =		0x0100,
+  VID_DEPTH_ALL   =             VID_DEPTH_1BPP  | VID_DEPTH_2BPP  | \
+                                VID_DEPTH_4BPP  | VID_DEPTH_8BPP  | \
+		                VID_DEPTH_12BPP | VID_DEPTH_15BPP | \
+		                VID_DEPTH_16BPP | VID_DEPTH_24BPP | \
+                                VID_DEPTH_32BPP,
+} vidix_depth_t;
+
+typedef enum vidix_cap {
+  VID_CAP_NONE               =	0x0000,
+  /* if overlay can be bigger than source */
+  VID_CAP_EXPAND             =	0x0001,
+  /* if overlay can be smaller than source */
+  VID_CAP_SHRINK             =	0x0002,
+  /* if overlay can be blended with framebuffer */
+  VID_CAP_BLEND              =	0x0004,
+  /* if overlay can be restricted to a colorkey */
+  VID_CAP_COLORKEY           =	0x0008,
+  /* if overlay can be restricted to an alpha channel */
+  VID_CAP_ALPHAKEY           =	0x0010,
+  /* if the colorkey can be a range */
+  VID_CAP_COLORKEY_ISRANGE   =	0x0020,
+  /* if the alphakey can be a range */
+  VID_CAP_ALPHAKEY_ISRANGE   =	0x0040,
+  /* colorkey is checked against framebuffer */
+  VID_CAP_COLORKEY_ISMAIN    =	0x0080,
+  /* colorkey is checked against overlay */
+  VID_CAP_COLORKEY_ISOVERLAY =	0x0100,
+  /* alphakey is checked against framebuffer */
+  VID_CAP_ALPHAKEY_ISMAIN    =	0x0200,
+  /* alphakey is checked against overlay */
+  VID_CAP_ALPHAKEY_ISOVERLAY =  0x0400,
+} vidix_cap_t;
 
 typedef struct vidix_fourcc_s
 {
-	unsigned fourcc;
-#define VID_DEPTH_NONE		0x0000
-#define VID_DEPTH_1BPP		0x0001
-#define VID_DEPTH_2BPP		0x0002
-#define VID_DEPTH_4BPP		0x0004
-#define VID_DEPTH_8BPP		0x0008
-#define VID_DEPTH_12BPP		0x0010
-#define VID_DEPTH_15BPP		0x0020
-#define VID_DEPTH_16BPP		0x0040
-#define VID_DEPTH_24BPP		0x0080
-#define VID_DEPTH_32BPP		0x0100
-	unsigned depth;
-#define VID_CAP_NONE			0x0000
-#define VID_CAP_EXPAND			0x0001 /* if overlay can be bigger than source */
-#define VID_CAP_SHRINK			0x0002 /* if overlay can be smaller than source */
-#define VID_CAP_BLEND			0x0004 /* if overlay can be blended with framebuffer */
-#define VID_CAP_COLORKEY		0x0008 /* if overlay can be restricted to a colorkey */
-#define VID_CAP_ALPHAKEY		0x0010 /* if overlay can be restricted to an alpha channel */
-#define VID_CAP_COLORKEY_ISRANGE	0x0020 /* if the colorkey can be a range */
-#define VID_CAP_ALPHAKEY_ISRANGE	0x0040 /* if the alphakey can be a range */
-#define VID_CAP_COLORKEY_ISMAIN		0x0080 /* colorkey is checked against framebuffer */
-#define VID_CAP_COLORKEY_ISOVERLAY	0x0100 /* colorkey is checked against overlay */
-#define VID_CAP_ALPHAKEY_ISMAIN		0x0200 /* alphakey is checked against framebuffer */
-#define VID_CAP_ALPHAKEY_ISOVERLAY	0x0400 /* alphakey is checked against overlay */
-	unsigned flags;
-}vidix_fourcc_t;
+  unsigned fourcc;      /* input: requested fourcc */
+  vidix_depth_t depth;	/* output: screen depth for given fourcc */
+  vidix_cap_t flags;	/* output: capability */
+} vidix_fourcc_t;
 
-			/* Returns 0 if ok else errno */
-extern int	vixQueryFourcc(vidix_fourcc_t *);
+/* Returns 0 if ok else errno */
+extern int vixQueryFourcc (vidix_fourcc_t *);
 
 typedef struct vidix_yuv_s
 {
-	unsigned y,u,v;
-}vidix_yuv_t;
+  unsigned y,u,v;
+} vidix_yuv_t;
 
 typedef struct vidix_rect_s
 {
-	unsigned x,y,w,h;	/* in pixels */
-	vidix_yuv_t pitch;	/* line-align in bytes */
-}vidix_rect_t;
+  unsigned x,y,w,h;	/* in pixels */
+  vidix_yuv_t pitch;	/* line-align in bytes */
+} vidix_rect_t;
+
+typedef enum vidix_color_key_op {
+  CKEY_FALSE =	0,
+  CKEY_TRUE  =	1,
+  CKEY_EQ    =	2,
+  CKEY_NEQ   =	3,
+} vidix_color_key_op_t;
 
 typedef struct vidix_color_key_s
 {
-#define CKEY_FALSE	0
-#define CKEY_TRUE	1
-#define CKEY_EQ		2
-#define CKEY_NEQ	3
-	unsigned	op;		/* defines logical operation */
-	unsigned char	red;
-	unsigned char	green;
-	unsigned char	blue;
-	unsigned char	reserved;
+  vidix_color_key_op_t op;	/* defines logical operation */
+  unsigned char	red;
+  unsigned char	green;
+  unsigned char	blue;
+  unsigned char	reserved;
 }vidix_ckey_t;
 
-typedef struct vidix_video_key_s
-{
-#define VKEY_FALSE	0
-#define VKEY_TRUE	1
-#define VKEY_EQ		2
-#define VKEY_NEQ	3
-	unsigned	op;		/* defines logical operation */
-	unsigned char	key[8];
-}vidix_vkey_t;
+typedef enum vidix_video_key_op {
+  VKEY_FALSE =	0,
+  VKEY_TRUE  =	1,
+  VKEY_EQ    =	2,
+  VKEY_NEQ   =	3,
+} vidix_video_key_op_t;
+
+typedef struct vidix_video_key_s {
+  vidix_video_key_op_t op;	/* defines logical operation */
+  unsigned char	key[8];
+} vidix_vkey_t;
+
+typedef enum vidix_interleave {
+  VID_PLAY_INTERLEAVED_UV =             0x00000001,
+  /* UVUVUVUVUV used by Matrox G200 */
+  INTERLEAVING_UV         =             0x00001000,
+  /* VUVUVUVUVU */
+  INTERLEAVING_VU         =		0x00001001,
+} vidix_interleave_t;
+
+#define VID_PLAY_MAXFRAMES 64	/* unreal limitation */
 
 typedef struct vidix_playback_s
 {
-	unsigned	fourcc;		/* app -> driver: movies's fourcc */
-	unsigned	capability;	/* app -> driver: what capability to use */
-	unsigned	blend_factor;	/* app -> driver: blending factor */
-	vidix_rect_t	src;            /* app -> driver: original movie size */
-	vidix_rect_t	dest;           /* app -> driver: destinition movie size. driver->app dest_pitch */
-#define VID_PLAY_INTERLEAVED_UV	0x00000001	/* driver -> app: interleaved UV planes */
-#define INTERLEAVING_UV		0x00001000	/* UVUVUVUVUV used by Matrox G200 */
-#define INTERLEAVING_VU		0x00001001	/* VUVUVUVUVU */
-	int		flags;
-	/* memory model */
-	unsigned	frame_size;		/* driver -> app: destinition frame size */
-	unsigned	num_frames;		/* app -> driver: after call: driver -> app */
-#define VID_PLAY_MAXFRAMES 64		/* reasonable limitation for decoding ahead */
-	unsigned	offsets[VID_PLAY_MAXFRAMES];	/* driver -> app */
-	vidix_yuv_t	offset;			/* driver -> app: relative offsets within frame for yuv planes */
-	void*		dga_addr;		/* driver -> app: linear address */
-}vidix_playback_t;
+  unsigned fourcc;		/* app -> driver: movies's fourcc */
+  unsigned capability;	        /* app -> driver: what capability to use */
+  unsigned blend_factor;	/* app -> driver: blending factor */
+  vidix_rect_t src;             /* app -> driver: original movie size */
+  vidix_rect_t dest;            /* app -> driver: destinition movie size.
+                                   driver->app dest_pitch */
+  vidix_interleave_t flags;     /* driver -> app: interleaved UV planes */
+  /* memory model */
+  unsigned frame_size;		/* driver -> app: destinition frame size */
+  unsigned num_frames;		/* app -> driver: after call: driver -> app */
+  unsigned offsets[VID_PLAY_MAXFRAMES];	/* driver -> app */
+  vidix_yuv_t offset;		/* driver -> app: relative offsets
+                                   within frame for yuv planes */
+  void *dga_addr;		/* driver -> app: linear address */
+} vidix_playback_t;
 
-			/* Returns 0 if ok else errno */
-extern int	vixConfigPlayback(vidix_playback_t *);
+/* Returns 0 if ok else errno */
+extern int vixConfigPlayback (vidix_playback_t *);
 
-			/* Returns 0 if ok else errno */
-extern int 	vixPlaybackOn( void );
+/* Returns 0 if ok else errno */
+extern int vixPlaybackOn (void);
+
+/* Returns 0 if ok else errno */
+extern int vixPlaybackOff (void);
 
-			/* Returns 0 if ok else errno */
-extern int 	vixPlaybackOff( void );
+/* Returns 0 if ok else errno */
+extern int vixPlaybackFrameSelect (unsigned frame_idx);
 
-			/* Returns 0 if ok else errno */
-extern int 	vixPlaybackFrameSelect( unsigned frame_idx );
+typedef enum vidix_key_op {
+  KEYS_PUT =	0,
+  KEYS_AND =	1,
+  KEYS_OR  =	2,
+  KEYS_XOR =	3,
+} vidix_key_op_t;
 
 typedef struct vidix_grkey_s
 {
-	vidix_ckey_t	ckey;		/* app -> driver: color key */
-	vidix_vkey_t	vkey;		/* app -> driver: video key */
-#define KEYS_PUT	0
-#define KEYS_AND	1
-#define KEYS_OR		2
-#define KEYS_XOR	3
-	unsigned	key_op;		/* app -> driver: keys operations */
-}vidix_grkey_t;
+  vidix_ckey_t ckey;		/* app -> driver: color key */
+  vidix_vkey_t vkey;		/* app -> driver: video key */
+  vidix_key_op_t key_op;	/* app -> driver: keys operations */
+} vidix_grkey_t;
+
+/* Returns 0 if ok else errno */
+extern int vixGetGrKeys (vidix_grkey_t *);
+
+/* Returns 0 if ok else errno */
+extern int vixSetGrKeys (const vidix_grkey_t *);
+
+typedef enum vidix_veq_cap {
+  VEQ_CAP_NONE		=	0x00000000UL,
+  VEQ_CAP_BRIGHTNESS	=	0x00000001UL,
+  VEQ_CAP_CONTRAST	=	0x00000002UL,
+  VEQ_CAP_SATURATION	=	0x00000004UL,
+  VEQ_CAP_HUE		=	0x00000008UL,
+  VEQ_CAP_RGB_INTENSITY =	0x00000010UL,
+} vidix_veq_cap_t;
 
-			/* Returns 0 if ok else errno */
-extern int 	vixGetGrKeys( vidix_grkey_t * );
+typedef enum vidix_veq_flag {
+  VEQ_FLG_ITU_R_BT_601 = 0x00000000, /* ITU-R BT.601 colour space (default) */
+  VEQ_FLG_ITU_R_BT_709 = 0x00000001, /* ITU-R BT.709 colour space */
+  VEQ_FLG_ITU_MASK     = 0x0000000f,
+} vidix_veq_flag_t;
 
-			/* Returns 0 if ok else errno */
-extern int 	vixSetGrKeys( const vidix_grkey_t * );
-
+typedef struct vidix_video_eq_s {
+  vidix_veq_cap_t cap;	 /* on get_eq should contain capability of
+                            equalizer on set_eq should contain using fields */
+  /* end-user app can have presets like: cold-normal-hot picture and so on */
+  int brightness;	        /* -1000 : +1000 */
+  int contrast;	                /* -1000 : +1000 */
+  int saturation;	        /* -1000 : +1000 */
+  int hue;		        /* -1000 : +1000 */
+  int red_intensity;	        /* -1000 : +1000 */
+  int green_intensity;          /* -1000 : +1000 */
+  int blue_intensity;           /* -1000 : +1000 */
+  vidix_veq_flag_t flags;	/* currently specifies ITU YCrCb color
+                                   space to use */
+} vidix_video_eq_t;
 
-typedef struct vidix_video_eq_s
-{
-#define VEQ_CAP_NONE			0x00000000UL
-#define VEQ_CAP_BRIGHTNESS		0x00000001UL
-#define VEQ_CAP_CONTRAST		0x00000002UL
-#define VEQ_CAP_SATURATION		0x00000004UL
-#define VEQ_CAP_HUE			0x00000008UL
-#define VEQ_CAP_RGB_INTENSITY		0x00000010UL
-	int		cap;		/* on get_eq should contain capability of equalizer
-					   on set_eq should contain using fields */
-/* end-user app can have presets like: cold-normal-hot picture and so on */
-	int		brightness;	/* -1000 : +1000 */
-	int		contrast;	/* -1000 : +1000 */
-	int		saturation;	/* -1000 : +1000 */
-	int		hue;		/* -1000 : +1000 */
-	int		red_intensity;	/* -1000 : +1000 */
-	int		green_intensity;/* -1000 : +1000 */
-	int		blue_intensity; /* -1000 : +1000 */
-#define VEQ_FLG_ITU_R_BT_601	0x00000000 /* ITU-R BT.601 colour space (default) */
-#define VEQ_FLG_ITU_R_BT_709	0x00000001 /* ITU-R BT.709 colour space */
-#define VEQ_FLG_ITU_MASK	0x0000000f
-	int		flags;		/* currently specifies ITU YCrCb color space to use */
-}vidix_video_eq_t;
+/* Returns 0 if ok else errno */
+extern int vixPlaybackGetEq (vidix_video_eq_t *);
+
+/* Returns 0 if ok else errno */
+extern int vixPlaybackSetEq (const vidix_video_eq_t *);
 
-			/* Returns 0 if ok else errno */
-extern int 	vixPlaybackGetEq( vidix_video_eq_t * );
+typedef enum vidix_interlace_flag {
+  /* stream is not interlaced */
+  CFG_NON_INTERLACED       =	0x00000000,
+  /* stream is interlaced */
+  CFG_INTERLACED           =	0x00000001,
+  /* first frame contains even fields but second - odd */
+  CFG_EVEN_ODD_INTERLACING =	0x00000002,
+  /* first frame contains odd fields but second - even */
+  CFG_ODD_EVEN_INTERLACING =	0x00000004,
+  /* field deinterlace_pattern is valid */
+  CFG_UNIQUE_INTERLACING   =	0x00000008,
+  /* unknown deinterlacing - use adaptive if it's possible */
+  CFG_UNKNOWN_INTERLACING  =	0x0000000f,
+} vidix_interlace_flag_t;
 
-			/* Returns 0 if ok else errno */
-extern int 	vixPlaybackSetEq( const vidix_video_eq_t * );
+typedef struct vidix_deinterlace_s {
+  vidix_interlace_flag_t flags;
+  unsigned deinterlace_pattern;	/* app -> driver: deinterlace pattern if
+                                   flag CFG_UNIQUE_INTERLACING is set */
+} vidix_deinterlace_t;
+
+/* Returns 0 if ok else errno */
+extern int vixPlaybackGetDeint (vidix_deinterlace_t *);
+
+/* Returns 0 if ok else errno */
+extern int vixPlaybackSetDeint (const vidix_deinterlace_t *);
 
-typedef struct vidix_deinterlace_s
-{
-#define CFG_NON_INTERLACED		0x00000000 /* stream is not interlaced */
-#define CFG_INTERLACED			0x00000001 /* stream is interlaced */
-#define CFG_EVEN_ODD_INTERLACING	0x00000002 /* first frame contains even fields but second - odd */
-#define CFG_ODD_EVEN_INTERLACING	0x00000004 /* first frame contains odd fields but second - even */
-#define CFG_UNIQUE_INTERLACING		0x00000008 /* field deinterlace_pattern is valid */
-#define CFG_UNKNOWN_INTERLACING		0x0000000f /* unknown deinterlacing - use adaptive if it's possible */
-	unsigned	flags;
-	unsigned	deinterlace_pattern;	/* app -> driver: deinterlace pattern if flag CFG_UNIQUE_INTERLACING is set */
-}vidix_deinterlace_t;
+typedef struct vidix_slice_s {
+  void *address;		/* app -> driver */
+  unsigned size;		/* app -> driver */
+  vidix_rect_t slice;		/* app -> driver */
+} vidix_slice_t;
 
-			/* Returns 0 if ok else errno */
-extern int 	vixPlaybackGetDeint( vidix_deinterlace_t * );
-
-			/* Returns 0 if ok else errno */
-extern int 	vixPlaybackSetDeint( const vidix_deinterlace_t * );
-
-typedef struct vidix_slice_s
-{
-	void*		address;		/* app -> driver */
-	unsigned	size;			/* app -> driver */
-	vidix_rect_t	slice;			/* app -> driver */
-}vidix_slice_t;
+typedef enum vidix_bm_flag {
+  LVO_DMA_NOSYNC	     = 0,
+  /* waits for vsync or hsync */
+  LVO_DMA_SYNC               = 1,
+} vidix_dma_flag_t;
 
 typedef struct vidix_dma_s
 {
-	vidix_slice_t	src;                    /* app -> driver */
-	vidix_slice_t	dest;			/* app -> driver */
-#define LVO_DMA_NOSYNC		0
-#define LVO_DMA_SYNC		1       /* means: wait vsync or hsync */
-	unsigned	flags;			/* app -> driver */
-}vidix_dma_t;
+  vidix_slice_t	src;                    /* app -> driver */
+  vidix_slice_t	dest;			/* app -> driver */
+  vidix_dma_flag_t flags;		/* app -> driver */
+} vidix_dma_t;
+
+/* Returns 0 if ok else errno */
+extern int vixPlaybackCopyFrame (vidix_dma_t *);
 
-			/* Returns 0 if ok else errno */
-extern int 	vixPlaybackCopyFrame( const vidix_dma_t * );
+/* Returns 0 if DMA is available else errno (EBUSY) */
+extern int vixQueryDMAStatus (void);
+
+typedef enum vidix_fx_type {
+  FX_TYPE_BOOLEAN =		0x00000000,
+  FX_TYPE_INTEGER =		0x00000001,
+} vidix_fx_type_t;
 
 /*
    This structure is introdused to support OEM effects like:
@@ -265,24 +342,23 @@
 */
 typedef struct vidix_oem_fx_s
 {
-#define FX_TYPE_BOOLEAN		0x00000000
-#define FX_TYPE_INTEGER		0x00000001
-	int		type;			/* type of effects */
-	int		num;			/* app -> driver: effect number. From 0 to max number of effects */
-	int		minvalue;		/* min value of effect. 0 - for boolean */
-	int		maxvalue;		/* max value of effect. 1 - for boolean */
-	int		value;			/* current value of effect on 'get'; required on set */
-	char *		name[80];		/* effect name to display */
-}vidix_oem_fx_t;
+  vidix_fx_type_t type;	/* type of effects */
+  int num;		/* app -> driver: effect number.
+                           From 0 to max number of effects */
+  int minvalue;		/* min value of effect. 0 - for boolean */
+  int maxvalue;		/* max value of effect. 1 - for boolean */
+  int value;   	        /* current value of effect on get; required on set */
+  char *name[80];	/* effect name to display */
+} vidix_oem_fx_t;
 
-			/* Returns 0 if ok else errno */
-extern int	vixQueryNumOemEffects( unsigned * number );
+/* Returns 0 if ok else errno */
+extern int vixQueryNumOemEffects (unsigned * number);
 
-			/* Returns 0 if ok else errno */
-extern int	vixGetOemEffect( vidix_oem_fx_t * );
+/* Returns 0 if ok else errno */
+extern int vixGetOemEffect (vidix_oem_fx_t *);
 
-			/* Returns 0 if ok else errno */
-extern int	vixSetOemEffect( const vidix_oem_fx_t * );
+/* Returns 0 if ok else errno */
+extern int vixSetOemEffect (const vidix_oem_fx_t *);
 
 #ifdef __cplusplus
 }