switch to new internal vidix API, no more dlopen/dlsym, libvidix is now a fully static library with all drivers built-in

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

13 files changed, 657 insertions, 383 deletions

diff --git a/vidix/cyberblade_vid.c b/vidix/cyberblade_vid.c
index 3da2f4db2e..b7acc0c251 100644
--- a/vidix/cyberblade_vid.c
+++ b/vidix/cyberblade_vid.c
@@ -44,6 +44,7 @@
 #include <unistd.h>
 
 #include "vidix.h"
+#include "vidixlib.h"
 #include "fourcc.h"
 #include "../libdha/libdha.h"
 #include "../libdha/pci_ids.h"
@@ -135,7 +136,7 @@ static vidix_capability_t cyberblade_cap =
 };
 
 
-unsigned int vixGetVersion(void)
+static unsigned int cyberblade_get_version(void)
 {
 	return(VIDIX_VERSION);
 }
@@ -162,7 +163,7 @@ static int find_chip(unsigned chip_id)
   return -1;
 }
 
-int vixProbe(int verbose, int force)
+static int cyberblade_probe(int verbose, int force)
 {
 	pciinfo_t lst[MAX_PCI_DEVICES];
 	unsigned i,num_pci;
@@ -206,7 +207,7 @@ int vixProbe(int verbose, int force)
 }
 
 
-int vixInit(void)
+static int cyberblade_init(void)
 {
 	cyberblade_mem = map_phys_mem(pci_info.base0, 0x800000); 
 	enable_app_io();
@@ -222,7 +223,7 @@ int vixInit(void)
 	return 0;
 }
 
-void vixDestroy(void)
+static void cyberblade_destroy(void)
 {
 	int protect;
 #ifdef DEBUG_LOGFILE
@@ -244,7 +245,7 @@ void vixDestroy(void)
 }
 
 
-int vixGetCapability(vidix_capability_t *to)
+static int cyberblade_get_caps(vidix_capability_t *to)
 {
 	memcpy(to, &cyberblade_cap, sizeof(vidix_capability_t));
 	return 0;
@@ -266,7 +267,7 @@ static int is_supported_fourcc(uint32_t fourcc)
 	}
 }
 
-int vixQueryFourcc(vidix_fourcc_t *to)
+static int cyberblade_query_fourcc(vidix_fourcc_t *to)
 {
 	if(is_supported_fourcc(to->fourcc))
 	{
@@ -288,13 +289,13 @@ static int frames[VID_PLAY_MAXFRAMES];
 
 static vidix_grkey_t cyberblade_grkey;
 
-int vixGetGrKeys(vidix_grkey_t *grkey)
+static int cyberblade_get_gkeys(vidix_grkey_t *grkey)
 {
 	memcpy(grkey, &cyberblade_grkey, sizeof(vidix_grkey_t));
 	return(0);
 }
 
-int vixSetGrKeys(const vidix_grkey_t *grkey)
+static int cyberblade_set_gkeys(const vidix_grkey_t *grkey)
 {
 	int pixfmt=CRINB(0x38);
 	int protect;
@@ -329,19 +330,19 @@ int vixSetGrKeys(const vidix_grkey_t *grkey)
 }
 
 
-vidix_video_eq_t equal =
+static vidix_video_eq_t equal =
 {
 	VEQ_CAP_BRIGHTNESS | VEQ_CAP_SATURATION | VEQ_CAP_HUE,
 	300, 100, 0, 0, 0, 0, 0, 0
 };
 
-int vixPlaybackGetEq( vidix_video_eq_t * eq)
+static int cyberblade_get_eq( vidix_video_eq_t * eq)
 {
   memcpy(eq,&equal,sizeof(vidix_video_eq_t));
   return 0;
 }
 
-int vixPlaybackSetEq( const vidix_video_eq_t * eq)
+static int cyberblade_set_eq( const vidix_video_eq_t * eq)
 {
 	int br,sat,cr,protect;
 	if(eq->cap & VEQ_CAP_BRIGHTNESS) equal.brightness = eq->brightness;
@@ -381,7 +382,7 @@ int vixPlaybackSetEq( const vidix_video_eq_t * eq)
 
 static int YOffs,UOffs,VOffs;
 
-int vixConfigPlayback(vidix_playback_t *info)
+static int cyberblade_config_playback(vidix_playback_t *info)
 {
 	int shrink, zoom;
 	int src_w, drw_w;
@@ -465,7 +466,7 @@ int vixConfigPlayback(vidix_playback_t *info)
 	SROUTB(0x21, 0x34); /* Signature control */
 	SROUTB(0x37, 0x30); /* Video key mode */
 
-        vixSetGrKeys(&cyberblade_grkey);
+        cyberblade_set_gkeys(&cyberblade_grkey);
 
 	/* compute_scale_factor(&src_w, &drw_w, &shrink, &zoom); */
 	{
@@ -598,7 +599,7 @@ int vixConfigPlayback(vidix_playback_t *info)
 		SROUTB(0x85, ((base0+info->offset.u) >> 19) &0xf); /* Upper 4 bits of start address */
 	}
 
-	vixPlaybackSetEq(&equal);
+	cyberblade_set_eq(&equal);
 
 	/* Protect hardware registers again */
 	SROUTB(0x11, protect);
@@ -606,7 +607,7 @@ int vixConfigPlayback(vidix_playback_t *info)
 }
 
 
-int vixPlaybackOn(void)
+static int cyberblade_playback_on(void)
 {
 	LOGWRITE("Enable overlay\n");
 	CROUTB(0x8E, 0xd4); /* VDE Flags*/
@@ -615,7 +616,7 @@ int vixPlaybackOn(void)
 }
 
 
-int vixPlaybackOff(void)
+static int cyberblade_playback_off(void)
 {
         LOGWRITE("Disable overlay\n"); 
 	CROUTB(0x8E, 0xc4); /* VDE Flags*/
@@ -624,7 +625,7 @@ int vixPlaybackOff(void)
 }
 
 
-int vixPlaybackFrameSelect(unsigned int frame)
+static int cyberblade_frame_sel(unsigned int frame)
 {
 	int protect;
         LOGWRITE("Frame select\n"); 
@@ -644,4 +645,21 @@ int vixPlaybackFrameSelect(unsigned int frame)
 	return 0;
 }
 
-
+VDXDriver cyberblade_drv = {
+  "cyberblade",
+  NULL,
+  .probe = cyberblade_probe,
+  .get_version = cyberblade_get_version,
+  .get_caps = cyberblade_get_caps,
+  .query_fourcc = cyberblade_query_fourcc,
+  .init = cyberblade_init,
+  .destroy = cyberblade_destroy,
+  .config_playback = cyberblade_config_playback,
+  .playback_on = cyberblade_playback_on,
+  .playback_off = cyberblade_playback_off,
+  .frame_sel = cyberblade_frame_sel,
+  .get_eq = cyberblade_get_eq,
+  .set_eq = cyberblade_set_eq,
+  .get_gkey = cyberblade_get_gkeys,
+  .set_gkey = cyberblade_set_gkeys,
+};
diff --git a/vidix/drivers.c b/vidix/drivers.c
new file mode 100644
index 0000000000..1bf2193806
--- /dev/null
+++ b/vidix/drivers.c
@@ -0,0 +1,123 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <errno.h>
+#include <string.h>
+
+#include "vidixlib.h"
+#include "../config.h"
+#include "../libavutil/common.h"
+#include "../mpbswap.h"
+
+VDXDriver *first_driver = NULL;
+
+extern VDXDriver cyberblade_drv;
+extern VDXDriver mach64_drv;
+extern VDXDriver mga_drv;
+extern VDXDriver mga_crtc2_drv;
+extern VDXDriver nvidia_drv;
+extern VDXDriver pm3_drv;
+extern VDXDriver radeon_drv;
+extern VDXDriver rage128_drv;
+extern VDXDriver savage_drv;
+extern VDXDriver sis_drv;
+extern VDXDriver unichrome_drv;
+
+static void vidix_register_driver (VDXDriver *drv)
+{
+  VDXDriver **d;
+  
+  d = &first_driver;
+  while (*d != NULL)
+    d = &(*d)->next;
+  *d = drv;
+  drv->next = NULL;
+}
+
+void vidix_register_all_drivers (void)
+{
+  vidix_register_driver (&cyberblade_drv);
+  vidix_register_driver (&mach64_drv);
+  vidix_register_driver (&mga_drv);
+  vidix_register_driver (&mga_crtc2_drv);
+  vidix_register_driver (&nvidia_drv);
+  vidix_register_driver (&pm3_drv);
+  vidix_register_driver (&radeon_drv);
+  vidix_register_driver (&rage128_drv);
+  vidix_register_driver (&savage_drv);
+  vidix_register_driver (&sis_drv);
+  vidix_register_driver (&unichrome_drv);
+}
+
+static int vidix_probe_driver (VDXContext *ctx, VDXDriver *drv,
+                               unsigned int cap, int verbose)
+{
+  vidix_capability_t vid_cap;
+
+  if (verbose)
+    printf ("vidixlib: PROBING: %s\n", drv->name);
+
+  if (!drv->get_version)
+    return 0;
+  
+  if (drv->get_version () != VIDIX_VERSION)
+  {
+    if (verbose)
+      printf ("vidixlib: %s has wrong version\n", drv->name);
+    return 0;
+  }
+
+  if (!drv->probe || drv->probe (verbose, PROBE_NORMAL) != 0)
+    return 0;
+
+  if (!drv->get_caps || drv->get_caps (&vid_cap) != 0)
+    return 0;
+
+  if ((vid_cap.type & cap) != cap)
+  {
+    if (verbose)
+      printf ("vidixlib: Found %s but has no required capability\n",
+              drv->name);
+     return 0;
+  }
+  
+  if (verbose)
+    printf ("vidixlib: %s probed o'k\n", drv->name);
+
+  ctx->drv = drv;
+  return 1;
+}
+
+int vidix_find_driver (VDXContext *ctx, const char *name,
+                       unsigned int cap, int verbose)
+{
+  VDXDriver *drv;
+
+  drv = first_driver;
+  while (drv)
+  {
+    if (name) /* forced driver */
+    {
+      if (!strcmp (drv->name, name))
+      {
+        if (vidix_probe_driver (ctx, drv, cap, verbose))
+          return 1;
+        else
+        {
+          ctx->drv = NULL;
+          return 0;
+        }
+      }
+    }
+    else /* auto-probe */
+    {
+      if (vidix_probe_driver (ctx, drv, cap, verbose))
+        return 1;
+    }
+    drv = drv->next;
+  }
+
+  if (verbose)
+    printf ("vidixlib: No suitable driver can be found.\n");
+  ctx->drv = NULL;
+  return 0;
+}
diff --git a/vidix/drivers.h b/vidix/drivers.h
new file mode 100644
index 0000000000..0cf8772cd1
--- /dev/null
+++ b/vidix/drivers.h
@@ -0,0 +1,10 @@
+
+#ifndef VIDIX_DRIVERS_H
+#define VIDIX_DRIVERS_H
+
+void vidix_register_all_drivers (void);
+
+int vidix_find_driver (VDXContext *ctx, const char *name,
+                       unsigned int cap, int verbose);
+
+#endif /* VIDIX_DRIVERS_H */
diff --git a/vidix/mach64_vid.c b/vidix/mach64_vid.c
index a967506396..a439da768c 100644
--- a/vidix/mach64_vid.c
+++ b/vidix/mach64_vid.c
@@ -17,13 +17,13 @@
 #include "../libavutil/common.h"
 #include "../mpbswap.h"
 #include "vidix.h"
+#include "vidixlib.h"
 #include "fourcc.h"
 #include "../libdha/libdha.h"
 #include "../libdha/pci_ids.h"
 #include "../libdha/pci_names.h"
 
 #include "mach64.h"
-#include "../version.h"
 
 #define UNUSED(x) ((void)(x)) /**< Removes warning about unused arguments */
 
@@ -339,7 +339,7 @@ static void mach64_vid_dump_regs( void )
 }
 
 
-unsigned int vixGetVersion(void)
+static unsigned int mach64_get_version(void)
 {
     return(VIDIX_VERSION);
 }
@@ -396,7 +396,7 @@ static int find_chip(unsigned chip_id)
   return -1;
 }
 
-int vixProbe(int verbose,int force)
+static int mach64_probe(int verbose,int force)
 {
   pciinfo_t lst[MAX_PCI_DEVICES];
   unsigned i,num_pci;
@@ -456,7 +456,7 @@ static void reset_regs( void )
 }
 
 
-int vixInit(void)
+static int mach64_init(void)
 {
   int err;
   if(!probed)
@@ -464,7 +464,7 @@ int vixInit(void)
     printf("[mach64] Driver was not probed but is being initializing\n");
     return EINTR;
   }
-  if(__verbose>0) printf("[mach64] version %s\n", VERSION);
+  if(__verbose>0) printf("[mach64] version %d\n", VIDIX_VERSION);
   
   if((mach64_mmio_base = map_phys_mem(pci_info.base2,0x1000))==(void *)-1) return ENOMEM;
   mach64_wait_for_idle();
@@ -516,7 +516,7 @@ int vixInit(void)
   return 0;
 }
 
-void vixDestroy(void)
+static void mach64_destroy(void)
 {
   /*restore this*/
   mach64_wait_for_idle();
@@ -526,7 +526,7 @@ void vixDestroy(void)
   unmap_phys_mem(mach64_mmio_base,0x1000);
 }
 
-int vixGetCapability(vidix_capability_t *to)
+static int mach64_get_caps(vidix_capability_t *to)
 {
     memcpy(to, &mach64_cap, sizeof(vidix_capability_t));
     return 0;
@@ -872,7 +872,7 @@ static int is_supported_fourcc(uint32_t fourcc)
     }
 }
 
-int vixQueryFourcc(vidix_fourcc_t *to)
+static int mach64_query_fourcc(vidix_fourcc_t *to)
 {
     if(is_supported_fourcc(to->fourcc))
     {
@@ -888,7 +888,7 @@ int vixQueryFourcc(vidix_fourcc_t *to)
     return ENOSYS;
 }
 
-int vixConfigPlayback(vidix_playback_t *info)
+static int mach64_config_playback(vidix_playback_t *info)
 {
   if(!is_supported_fourcc(info->fourcc)) return ENOSYS;
 
@@ -908,19 +908,19 @@ int vixConfigPlayback(vidix_playback_t *info)
   return 0;
 }
 
-int vixPlaybackOn(void)
+static int mach64_playback_on(void)
 {
   mach64_vid_display_video();
   return 0;
 }
 
-int vixPlaybackOff(void)
+static int mach64_playback_off(void)
 {
   mach64_vid_stop_video();
   return 0;
 }
 
-int vixPlaybackFrameSelect(unsigned int frame)
+static int mach64_frame_sel(unsigned int frame)
 {
     uint32_t off[6];
     int i;
@@ -960,19 +960,19 @@ for(i=0; i<10000000; i++);
     return 0;
 }
 
-vidix_video_eq_t equal =
+static vidix_video_eq_t equal =
 {
  VEQ_CAP_BRIGHTNESS | VEQ_CAP_SATURATION
  ,
  0, 0, 0, 0, 0, 0, 0, 0 };
 
-int 	vixPlaybackGetEq( vidix_video_eq_t * eq)
+static int mach64_get_eq( vidix_video_eq_t * eq)
 {
   memcpy(eq,&equal,sizeof(vidix_video_eq_t));
   return 0;
 }
 
-int 	vixPlaybackSetEq( const vidix_video_eq_t * eq)
+static int mach64_set_eq( const vidix_video_eq_t * eq)
 {
   int br,sat;
     if(eq->cap & VEQ_CAP_BRIGHTNESS) equal.brightness = eq->brightness;
@@ -994,13 +994,13 @@ int 	vixPlaybackSetEq( const vidix_video_eq_t * eq)
   return 0;
 }
 
-int vixGetGrKeys(vidix_grkey_t *grkey)
+static int mach64_get_gkeys(vidix_grkey_t *grkey)
 {
     memcpy(grkey, &mach64_grkey, sizeof(vidix_grkey_t));
     return(0);
 }
 
-int vixSetGrKeys(const vidix_grkey_t *grkey)
+static int mach64_set_gkeys(const vidix_grkey_t *grkey)
 {
     memcpy(&mach64_grkey, grkey, sizeof(vidix_grkey_t));
 
@@ -1064,3 +1064,22 @@ int vixSetGrKeys(const vidix_grkey_t *grkey)
 
     return(0);
 }
+
+VDXDriver mach64_drv = {
+  "mach64",
+  NULL,
+  .probe = mach64_probe,
+  .get_version = mach64_get_version,
+  .get_caps = mach64_get_caps,
+  .query_fourcc = mach64_query_fourcc,
+  .init = mach64_init,
+  .destroy = mach64_destroy,
+  .config_playback = mach64_config_playback,
+  .playback_on = mach64_playback_on,
+  .playback_off = mach64_playback_off,
+  .frame_sel = mach64_frame_sel,
+  .get_eq = mach64_get_eq,
+  .set_eq = mach64_set_eq,
+  .get_gkey = mach64_get_gkeys,
+  .set_gkey = mach64_set_gkeys,
+};
diff --git a/vidix/mga_vid.c b/vidix/mga_vid.c
index f75ac8ff59..47fbafbe09 100644
--- a/vidix/mga_vid.c
+++ b/vidix/mga_vid.c
@@ -55,6 +55,7 @@
 #include <inttypes.h>
 
 #include "vidix.h"
+#include "vidixlib.h"
 #include "fourcc.h"
 #include "../libdha/libdha.h"
 #include "../libdha/pci_ids.h"
@@ -343,7 +344,7 @@ case 3:
 }
 #endif
 
-int vixPlaybackFrameSelect(unsigned int frame)
+static int mga_frame_select(unsigned int frame)
 {
     mga_next_frame = frame;
     if (mga_verbose>1) printf("[mga] frameselect: %d\n", mga_next_frame);
@@ -696,7 +697,7 @@ void mga_handle_irq(int irq, void *dev_id/*, struct pt_regs *pregs*/) {
 }
 #endif /* MGA_ALLOW_IRQ */
 
-int vixConfigPlayback(vidix_playback_t *config)
+static int mga_config_playback(vidix_playback_t *config)
 {
 	unsigned int i;
 	int x, y, sw, sh, dw, dh;
@@ -1152,7 +1153,7 @@ switch(config->fourcc){
     return(0);
 }
 
-int vixPlaybackOn(void)
+static int mga_playback_on(void)
 {
     if (mga_verbose) printf("[mga] playback on\n");
 
@@ -1171,7 +1172,7 @@ int vixPlaybackOn(void)
     return(0);
 }
 
-int vixPlaybackOff(void)
+static int mga_playback_off(void)
 {
     if (mga_verbose) printf("[mga] playback off\n");
 
@@ -1187,7 +1188,7 @@ int vixPlaybackOff(void)
     return(0);
 }
 
-int vixProbe(int verbose,int force)
+static int mga_probe(int verbose,int force)
 {
 	pciinfo_t lst[MAX_PCI_DEVICES];
 	unsigned int i, num_pci;
@@ -1258,7 +1259,7 @@ card_found:
 	return(0);
 }
 
-int vixInit(void)
+static int mga_init(void)
 {
     unsigned int card_option = 0;
     int err;
@@ -1387,7 +1388,7 @@ int vixInit(void)
     return(0);
 }
 
-void vixDestroy(void)
+static void mga_destroy(void)
 {
     if (mga_verbose) printf("[mga] destroy\n");
 
@@ -1411,7 +1412,7 @@ void vixDestroy(void)
     return;
 }
 
-int vixQueryFourcc(vidix_fourcc_t *to)
+static int mga_query_fourcc(vidix_fourcc_t *to)
 {
     if (mga_verbose) printf("[mga] query fourcc (%x)\n", to->fourcc);
 
@@ -1435,31 +1436,31 @@ int vixQueryFourcc(vidix_fourcc_t *to)
     return(0);
 }
 
-unsigned int vixGetVersion(void)
+static unsigned int mga_get_version(void)
 {
     return(VIDIX_VERSION);
 }
 
-int vixGetCapability(vidix_capability_t *to)
+static int mga_get_caps(vidix_capability_t *to)
 {
     memcpy(to, &mga_cap, sizeof(vidix_capability_t));
     return(0);
 }
 
-int vixGetGrKeys(vidix_grkey_t *grkey)
+static int mga_get_gkeys(vidix_grkey_t *grkey)
 {
     memcpy(grkey, &mga_grkey, sizeof(vidix_grkey_t));
     return(0);
 }
 
-int vixSetGrKeys(const vidix_grkey_t *grkey)
+static int mga_set_gkeys(const vidix_grkey_t *grkey)
 {
     memcpy(&mga_grkey, grkey, sizeof(vidix_grkey_t));
     mga_vid_write_regs(0);
     return(0);
 }
 
-int vixPlaybackSetEq( const vidix_video_eq_t * eq)
+static int mga_set_eq( const vidix_video_eq_t * eq)
 {
     /* contrast and brightness control isn't supported on G200 - alex */
     if (!is_g400)
@@ -1487,7 +1488,7 @@ int vixPlaybackSetEq( const vidix_video_eq_t * eq)
     return(0);
 }
 
-int vixPlaybackGetEq( vidix_video_eq_t * eq)
+static int mga_get_eq( vidix_video_eq_t * eq)
 {
     /* contrast and brightness control isn't supported on G200 - alex */
     if (!is_g400)
@@ -1506,3 +1507,28 @@ int vixPlaybackGetEq( vidix_video_eq_t * eq)
 
     return(0);
 }
+
+#ifndef CRTC2
+VDXDriver mga_drv = {
+  "mga",
+#else
+VDXDriver mga_crtc2_drv = {
+  "mga_crtc2",
+#endif
+  NULL,
+    
+  .probe = mga_probe,
+  .get_version = mga_get_version,
+  .get_caps = mga_get_caps,
+  .query_fourcc = mga_query_fourcc,
+  .init = mga_init,
+  .destroy = mga_destroy,
+  .config_playback = mga_config_playback,
+  .playback_on = mga_playback_on,
+  .playback_off = mga_playback_off,
+  .frame_sel = mga_frame_select,
+  .get_eq = mga_get_eq,
+  .set_eq = mga_set_eq,
+  .get_gkey = mga_get_gkeys,
+  .set_gkey = mga_set_gkeys,
+};
diff --git a/vidix/nvidia_vid.c b/vidix/nvidia_vid.c
index f76a5f09b1..faf5b9a4ec 100644
--- a/vidix/nvidia_vid.c
+++ b/vidix/nvidia_vid.c
@@ -19,6 +19,7 @@
 
 
 #include "vidix.h"
+#include "vidixlib.h"
 #include "fourcc.h"
 #include "../libdha/libdha.h"
 #include "../libdha/pci_ids.h"
@@ -52,7 +53,7 @@ static vidix_capability_t nvidia_cap = {
 };
 
 
-unsigned int vixGetVersion(void){
+static unsigned int nv_get_version(void){
     return(VIDIX_VERSION);
 }
 
@@ -164,7 +165,7 @@ static int find_chip(unsigned chip_id){
   return -1;
 }
 
-int vixProbe(int verbose, int force){
+static int nv_probe(int verbose, int force){
     pciinfo_t lst[MAX_PCI_DEVICES];
     unsigned i,num_pci;
     int err;
@@ -703,7 +704,7 @@ static rivatv_info* info;
 
       
       
-int vixInit(void){
+static int nv_init(void){
 	int mtrr;
   info = calloc(1,sizeof(rivatv_info));
   info->control_base = map_phys_mem(pci_info.base0, 0x00C00000 + 0x00008000);
@@ -793,13 +794,13 @@ int vixInit(void){
   return 0;
 }
 
-void vixDestroy(void){
+static void nv_destroy(void){
   unmap_phys_mem(info->control_base ,0x00C00000 + 0x00008000);
   unmap_phys_mem(info->video_base, info->chip.fbsize);
   free(info);
 }
 
-int vixGetCapability(vidix_capability_t *to){
+static int nv_get_caps(vidix_capability_t *to){
     memcpy(to, &nvidia_cap, sizeof(vidix_capability_t));
     return 0;
 }
@@ -812,7 +813,7 @@ inline static int is_supported_fourcc(uint32_t fourcc)
 		return 0;
 }
 
-int vixQueryFourcc(vidix_fourcc_t *to){
+static int nv_query_fourcc(vidix_fourcc_t *to){
     if(is_supported_fourcc(to->fourcc)){
 	to->depth = VID_DEPTH_1BPP | VID_DEPTH_2BPP |
 		    VID_DEPTH_4BPP | VID_DEPTH_8BPP |
@@ -826,7 +827,7 @@ int vixQueryFourcc(vidix_fourcc_t *to){
     return ENOSYS;
 }
 
-int vixConfigPlayback(vidix_playback_t *vinfo){
+static int nv_config_playback(vidix_playback_t *vinfo){
     uint32_t i;
     printf("called %s\n", __FUNCTION__);
     if (! is_supported_fourcc(vinfo->fourcc))
@@ -872,17 +873,17 @@ int vixConfigPlayback(vidix_playback_t *vinfo){
     return 0;
 }
 
-int vixPlaybackOn(void){
+static int nv_playback_on(void){
     rivatv_overlay_start(info,info->cur_frame);
     return 0;
 }
 
-int vixPlaybackOff(void){
+static int nv_playback_off(void){
     rivatv_overlay_stop(info);
     return 0;
 }
 
-int vixSetGrKeys( const vidix_grkey_t * grkey){
+static int nv_set_gkeys( const vidix_grkey_t * grkey){
   if (grkey->ckey.op == CKEY_FALSE)
   {
     info->use_colorkey = 0;
@@ -897,7 +898,7 @@ int vixSetGrKeys( const vidix_grkey_t * grkey){
   return 0;
 }
 
-int vixPlaybackFrameSelect(unsigned int frame){
+static int nv_frame_sel(unsigned int frame){
 //  printf("selecting buffer %d\n", frame);
   rivatv_overlay_start(info, frame);
   if (info->num_frames >= 1)
@@ -905,7 +906,7 @@ int vixPlaybackFrameSelect(unsigned int frame){
   return 0;
 }
 
-int vixPlaybackSetEq(const vidix_video_eq_t *eq_parm) {
+static int nv_set_eq(const vidix_video_eq_t *eq_parm) {
   double angle;
   int16_t chrom_cos, chrom_sin;
   if (eq_parm->cap & VEQ_CAP_BRIGHTNESS)
@@ -928,8 +929,25 @@ int vixPlaybackSetEq(const vidix_video_eq_t *eq_parm) {
   return 0;
 }
 
-int vixPlaybackGetEq(vidix_video_eq_t *eq_parm) {
+static int nv_get_eq(vidix_video_eq_t *eq_parm) {
   memcpy(eq_parm, &eq.vals, sizeof(vidix_video_eq_t));
   return 0;
 }
 
+VDXDriver nvidia_drv = {
+  "nvidia",
+  NULL,
+  .probe = nv_probe,
+  .get_version = nv_get_version,
+  .get_caps = nv_get_caps,
+  .query_fourcc = nv_query_fourcc,
+  .init = nv_init,
+  .destroy = nv_destroy,
+  .config_playback = nv_config_playback,
+  .playback_on = nv_playback_on,
+  .playback_off = nv_playback_off,
+  .frame_sel = nv_frame_sel,
+  .get_eq = nv_get_eq,
+  .set_eq = nv_set_eq,
+  .set_gkey = nv_set_gkeys,
+};
diff --git a/vidix/pm3_vid.c b/vidix/pm3_vid.c
index ff030b4ea5..f9737e34da 100644
--- a/vidix/pm3_vid.c
+++ b/vidix/pm3_vid.c
@@ -26,6 +26,7 @@
 #include <unistd.h>
 
 #include "vidix.h"
+#include "vidixlib.h"
 #include "fourcc.h"
 #include "../libdha/libdha.h"
 #include "../libdha/pci_ids.h"
@@ -65,7 +66,7 @@ static vidix_capability_t pm3_cap =
 };
 
 
-unsigned int vixGetVersion(void)
+static unsigned int pm3_get_version(void)
 {
     return(VIDIX_VERSION);
 }
@@ -85,7 +86,7 @@ static int find_chip(unsigned chip_id)
   return -1;
 }
 
-int vixProbe(int verbose, int force)
+static int pm3_probe(int verbose, int force)
 {
     pciinfo_t lst[MAX_PCI_DEVICES];
     unsigned i,num_pci;
@@ -134,20 +135,20 @@ int vixProbe(int verbose, int force)
     printf("[pm3] " #reg " (%x) = %#lx (%li)\n", reg, _foo, _foo);	\
 }
 
-int vixInit(void)
+static int pm3_init(void)
 {
     pm3_reg_base = map_phys_mem(pci_info.base0, 0x20000);
     pm3_mem = map_phys_mem(pci_info.base2, 0x2000000);
     return 0;
 }
 
-void vixDestroy(void)
+static void pm3_destroy(void)
 {
     unmap_phys_mem(pm3_reg_base, 0x20000);
     unmap_phys_mem(pm3_mem, 0x2000000);
 }
 
-int vixGetCapability(vidix_capability_t *to)
+static int pm3_get_caps(vidix_capability_t *to)
 {
     memcpy(to, &pm3_cap, sizeof(vidix_capability_t));
     return 0;
@@ -164,7 +165,7 @@ static int is_supported_fourcc(uint32_t fourcc)
     }
 }
 
-int vixQueryFourcc(vidix_fourcc_t *to)
+static int pm3_query_fourcc(vidix_fourcc_t *to)
 {
     if(is_supported_fourcc(to->fourcc))
     {
@@ -228,7 +229,7 @@ static int frames[VID_PLAY_MAXFRAMES];
 
 static long overlay_mode, overlay_control;
 
-int vixConfigPlayback(vidix_playback_t *info)
+static int pm3_config_playback(vidix_playback_t *info)
 {
     int shrink, zoom;
     short src_w, drw_w;
@@ -339,7 +340,7 @@ int vixConfigPlayback(vidix_playback_t *info)
     return 0;
 }
 
-int vixPlaybackOn(void)
+static int pm3_playback_on(void)
 {
     TRACE_ENTER();
 
@@ -354,7 +355,7 @@ int vixPlaybackOn(void)
     return 0;
 }
 
-int vixPlaybackOff(void)
+static int pm3_playback_off(void)
 {
     RAMDAC_SET_REG(PM3RD_VideoOverlayControl,
 		   PM3RD_VideoOverlayControl_DISABLE);
@@ -368,8 +369,23 @@ int vixPlaybackOff(void)
     return 0;
 }
 
-int vixPlaybackFrameSelect(unsigned int frame)
+static int pm3_frame_select(unsigned int frame)
 {
     WRITE_REG(PM3VideoOverlayBase0, frames[frame]);
     return 0;
 }
+
+VDXDriver pm3_drv = {
+  "pm3",
+  NULL,
+  .probe = pm3_probe,
+  .get_version = pm3_get_version,
+  .get_caps = pm3_get_caps,
+  .query_fourcc = pm3_query_fourcc,
+  .init = pm3_init,
+  .destroy = pm3_destroy,
+  .config_playback = pm3_config_playback,
+  .playback_on = pm3_playback_on,
+  .playback_off = pm3_playback_off,
+  .frame_sel = pm3_frame_select,
+};
diff --git a/vidix/radeon_vid.c b/vidix/radeon_vid.c
index 3b3031be80..cd0d9df0c0 100644
--- a/vidix/radeon_vid.c
+++ b/vidix/radeon_vid.c
@@ -22,6 +22,7 @@
 #include "../libdha/pci_ids.h"
 #include "../libdha/pci_names.h"
 #include "vidix.h"
+#include "vidixlib.h"
 #include "fourcc.h"
 #include "../libdha/libdha.h"
 #include "radeon.h"
@@ -794,7 +795,7 @@ static void radeon_vid_make_default(void)
 }
 
 
-unsigned vixGetVersion( void ) { return VIDIX_VERSION; }
+static unsigned int radeon_get_version( void ) { return VIDIX_VERSION; }
 
 static unsigned short ati_card_ids[] = 
 {
@@ -930,7 +931,7 @@ static int find_chip(unsigned chip_id)
 static pciinfo_t pci_info;
 static int probed=0;
 
-vidix_capability_t def_cap = 
+static vidix_capability_t def_cap = 
 {
 #ifdef RAGE128
     "BES driver for Rage128 cards",
@@ -981,7 +982,7 @@ static void probe_fireGL_driver(void) {
 }
 #endif
 
-int vixProbe( int verbose,int force )
+static int radeon_probe( int verbose,int force )
 {
   pciinfo_t lst[MAX_PCI_DEVICES];
   unsigned i,num_pci;
@@ -1139,7 +1140,7 @@ int vixProbe( int verbose,int force )
 
 static void radeon_vid_dump_regs( void ); /* forward declaration */
 
-int vixInit( void )
+static int radeon_init( void )
 {
   int err;
   if(!probed) 
@@ -1239,7 +1240,7 @@ int vixInit( void )
   return 0;  
 }
 
-void vixDestroy( void )
+static void radeon_destroy( void )
 {
   /* remove colorkeying */
   radeon_fifo_wait(3);
@@ -1264,7 +1265,7 @@ void vixDestroy( void )
   unmap_phys_mem(radeon_mmio_base,0xFFFF);
 }
 
-int vixGetCapability(vidix_capability_t *to)
+static int radeon_get_caps(vidix_capability_t *to)
 {
   memcpy(to,&def_cap,sizeof(vidix_capability_t));
   return 0; 
@@ -1275,7 +1276,7 @@ int vixGetCapability(vidix_capability_t *to)
   YUY2, UYVY, DDES, OGLT, OGL2, OGLS, OGLB, OGNT, OGNZ, OGNS,
   IF09, YVU9, IMC4, M2IA, IYUV, VBID, DXT1, DXT2, DXT3, DXT4, DXT5
 */
-uint32_t supported_fourcc[] = 
+static uint32_t supported_fourcc[] = 
 {
   IMGFMT_Y800, IMGFMT_Y8, IMGFMT_YVU9, IMGFMT_IF09,
   IMGFMT_YV12, IMGFMT_I420, IMGFMT_IYUV, 
@@ -1295,7 +1296,7 @@ inline static int is_supported_fourcc(uint32_t fourcc)
   return 0;
 }
 
-int vixQueryFourcc(vidix_fourcc_t *to)
+static int radeon_query_fourcc(vidix_fourcc_t *to)
 {
     if(is_supported_fourcc(to->fourcc))
     {
@@ -1803,7 +1804,7 @@ static void radeon_compute_framesize(vidix_playback_t *info)
   }
 }
 
-int vixConfigPlayback(vidix_playback_t *info)
+static int radeon_config_playback(vidix_playback_t *info)
 {
   unsigned rgb_size,nfr;
   if(!is_supported_fourcc(info->fourcc)) return ENOSYS;
@@ -1844,19 +1845,19 @@ int vixConfigPlayback(vidix_playback_t *info)
   return 0;
 }
 
-int vixPlaybackOn( void )
+static int radeon_playback_on( void )
 {
   radeon_vid_display_video();
   return 0;
 }
 
-int vixPlaybackOff( void )
+static int radeon_playback_off( void )
 {
   radeon_vid_stop_video();
   return 0;
 }
 
-int vixPlaybackFrameSelect(unsigned frame)
+static int radeon_frame_select(unsigned frame)
 {
     uint32_t off[6];
     int prev_frame= (frame-1+besr.vid_nbufs) % besr.vid_nbufs;
@@ -1889,7 +1890,7 @@ int vixPlaybackFrameSelect(unsigned frame)
     return 0;
 }
 
-vidix_video_eq_t equal =
+static vidix_video_eq_t equal =
 {
  VEQ_CAP_BRIGHTNESS | VEQ_CAP_SATURATION
 #ifndef RAGE128
@@ -1898,7 +1899,7 @@ vidix_video_eq_t equal =
  ,
  0, 0, 0, 0, 0, 0, 0, 0 };
 
-int 	vixPlaybackGetEq( vidix_video_eq_t * eq)
+static int radeon_get_eq( vidix_video_eq_t * eq)
 {
   memcpy(eq,&equal,sizeof(vidix_video_eq_t));
   return 0;
@@ -1913,7 +1914,7 @@ int 	vixPlaybackGetEq( vidix_video_eq_t * eq)
 #define RTFCheckParam(a) {if((a)<-1000) (a)=-1000; if((a)>1000) (a)=1000;}
 #endif
 
-int 	vixPlaybackSetEq( const vidix_video_eq_t * eq)
+static int radeon_set_eq( const vidix_video_eq_t * eq)
 {
 #ifdef RAGE128
   int br,sat;
@@ -1958,7 +1959,7 @@ int 	vixPlaybackSetEq( const vidix_video_eq_t * eq)
   return 0;
 }
 
-int 	vixPlaybackSetDeint( const vidix_deinterlace_t * info)
+static int radeon_playback_set_deint (const vidix_deinterlace_t * info)
 {
   unsigned sflg;
   switch(info->flags)
@@ -1996,7 +1997,7 @@ int 	vixPlaybackSetDeint( const vidix_deinterlace_t * info)
   return 0;  
 }
 
-int 	vixPlaybackGetDeint( vidix_deinterlace_t * info)
+static int radeon_playback_get_deint (vidix_deinterlace_t * info)
 {
   if(!besr.deinterlace_on) info->flags = CFG_NON_INTERLACED;
   else
@@ -2087,15 +2088,42 @@ static void set_gr_key( void )
     OUTREG(OV0_KEY_CNTL,besr.ckey_cntl);
 }
 
-int vixGetGrKeys(vidix_grkey_t *grkey)
+stati