updated vidix.h from upstream vidix project

git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@22877 b3059339-0415-0410-9bf9-f77b7e298cf2

1 files changed, 294 insertions, 218 deletions

diff --git a/vidix/vidix.h b/vidix/vidix.h
index 67462b33c7..8e199d94cf 100644
--- a/vidix/vidix.h
+++ b/vidix/vidix.h
@@ -22,236 +22,313 @@ extern "C" {
 
 #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;
-
-			/* Should fill at least type before init.
-			   Returns 0 if ok else errno */
-extern int	vixGetCapability(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 *);
+
+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;
-
-			/* Returns 0 if ok else errno */
-extern int	vixQueryFourcc(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 *);
 
 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 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;
-
-			/* 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 	vixPlaybackOff( void );
-
-			/* Returns 0 if ok else errno */
-extern int 	vixPlaybackFrameSelect( unsigned frame_idx );
+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_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;
+typedef struct vidix_video_key_s {
+  vidix_video_key_op_t op;	/* defines logical operation */
+  unsigned char	key[8];
+} vidix_vkey_t;
 
-			/* Returns 0 if ok else errno */
-extern int 	vixGetGrKeys( vidix_grkey_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;
 
-			/* Returns 0 if ok else errno */
-extern int 	vixSetGrKeys( const vidix_grkey_t * );
+#define VID_PLAY_MAXFRAMES 64	/* unreal limitation */
 
-
-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 * );
-
-typedef struct vidix_deinterlace_s
+typedef struct vidix_playback_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;
-
-			/* 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
+  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 vixPlaybackOn (void);
+
+/* Returns 0 if ok else errno */
+extern int vixPlaybackOff (void);
+
+/* 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
 {
-	void*		address;		/* app -> driver */
-	unsigned	size;			/* app -> driver */
-	vidix_rect_t	slice;			/* app -> driver */
-}vidix_slice_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;
+
+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;
+
+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;
+
+/* 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 *);
+
+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;
+
+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_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 DMA is available else errno (EBUSY) */
+extern int vixQueryDMAStatus (void);
 
-			/* Returns 0 if ok else errno */
-extern int 	vixPlaybackCopyFrame( const vidix_dma_t * );
+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 @@ extern int 	vixPlaybackCopyFrame( const vidix_dma_t * );
 */
 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;
-
-			/* 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	vixSetOemEffect( const 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 vixGetOemEffect (vidix_oem_fx_t *);
+
+/* Returns 0 if ok else errno */
+extern int vixSetOemEffect (const vidix_oem_fx_t *);
 
 #ifdef __cplusplus
 }