diff --git a/src/v4l.c b/src/v4l.c

--- a/src/v4l.c

+++ b/src/v4l.c

@@ -1,6 +1,9 @@

 /*

- *  video4linux Xv Driver 

+ *  video4linux Xv Driver

  *  based on Michael Schimek's permedia 2 driver.

+ *

+ * Copyright (c) 2011 Mauro Carvalho Chehab <mchehab@redhat.com> for:

+ *	- Major rewrite, as driver got ported to V4L2 API

  */

 #ifdef HAVE_CONFIG_H

@@ -9,12 +12,16 @@

 #include <sys/types.h>

 #include <sys/stat.h>

+#include <ctype.h>

+

 #include <fcntl.h>

 #include <errno.h>

 #include <string.h>

 #include <stdio.h>

+#include <unistd.h>

+#include <sys/ioctl.h>

-#include "videodev.h"

+#include "videodev2.h"

 #include "xf86.h"

 #include "xf86_OSproc.h"

 #include "xf86Pci.h"

@@ -25,29 +32,32 @@

 #include "regionstr.h"

 #include "dgaproc.h"

 #include "xf86str.h"

+#include "fourcc.h"

-#include <asm/ioctl.h>		/* _IORW(xxx) #defines are here */

+#include <asm/ioctl.h>          /* _IORW(xxx) #defines are here */

-#if 0

+#if 1

 # define DEBUG(x) (x)

 #else

 # define DEBUG(x)

 #endif

+/***************************************************************************/

+

 static void     V4LIdentify(int flags);

 static Bool     V4LProbe(DriverPtr drv, int flags);

 static const OptionInfoRec * V4LAvailableOptions(int chipid, int busid);

 _X_EXPORT DriverRec V4L = {

-        40000,

-        "v4l",

-        V4LIdentify, /* Identify*/

-        V4LProbe, /* Probe */

-	V4LAvailableOptions,

-        NULL,

-        0

-};    

-

+    .driverVersion = 50000,

+    .driverName = "v4l",

+    .Identify = V4LIdentify,

+    .Probe = V4LProbe,

+    .AvailableOptions = V4LAvailableOptions,

+    .module = NULL,

+    .refCount = 0,

+    .driverFunc = NULL,   /* FIXME: Need to implement for new probing mode */

+};

 #ifdef XFree86LOADER

@@ -55,16 +65,16 @@ static MODULESETUPPROTO(v4lSetup);

 static XF86ModuleVersionInfo v4lVersRec =

 {

-        "v4l",

-        MODULEVENDORSTRING,

-        MODINFOSTRING1,

-        MODINFOSTRING2,

-        XORG_VERSION_CURRENT,

-        0, 1, 1,

-        ABI_CLASS_VIDEODRV,

-        ABI_VIDEODRV_VERSION,

-        MOD_CLASS_NONE,

-        {0,0,0,0}

+    "v4l",

+    MODULEVENDORSTRING,

+    MODINFOSTRING1,

+    MODINFOSTRING2,

+    XORG_VERSION_CURRENT,

+    0, 1, 1,

+    ABI_CLASS_VIDEODRV,

+    ABI_VIDEODRV_VERSION,

+    MOD_CLASS_NONE,

+    {0,0,0,0}

 };

 _X_EXPORT XF86ModuleData v4lModuleData = { &v4lVersRec, v4lSetup, NULL };

@@ -72,32 +82,32 @@ _X_EXPORT XF86ModuleData v4lModuleData =

 static pointer

 v4lSetup(pointer module, pointer opts, int *errmaj, int *errmin)

 {

-        const char *osname;

-	static Bool setupDone = FALSE;

+    const char *osname;

+    static Bool setupDone = FALSE;

-	if (setupDone) {

-	    if (errmaj)

-		*errmaj = LDR_ONCEONLY;

-	    return NULL;             

-	}

-	

-	setupDone = TRUE;

+    if (setupDone) {

+        if (errmaj)

+            *errmaj = LDR_ONCEONLY;

+        return NULL;

+    }

-        /* Check that we're being loaded on a Linux system */

-        LoaderGetOS(&osname, NULL, NULL, NULL);

-        if (!osname || strcmp(osname, "linux") != 0) {

-                if (errmaj)

-                        *errmaj = LDR_BADOS;

-                if (errmin)

-                        *errmin = 0;

-                return NULL;

-        } else {

-                /* OK */

+    setupDone = TRUE;

-	        xf86AddDriver (&V4L, module, 0);   

-	  

-                return (pointer)1;

-        }

+    /* Check that we're being loaded on a Linux system */

+    LoaderGetOS(&osname, NULL, NULL, NULL);

+    if (!osname || strcmp(osname, "linux") != 0) {

+        if (errmaj)

+            *errmaj = LDR_BADOS;

+        if (errmin)

+            *errmin = 0;

+        return NULL;

+    } else {

+        /* OK */

+

+        xf86AddDriver (&V4L, module, 0);

+

+        return (pointer)1;

+    }

 }

 #else

@@ -112,25 +122,28 @@ v4lSetup(pointer module, pointer opts, i

 #define VIDEO_YUV     2  /* yuv overlay (to offscreen memory + hw scaling) */

 #define VIDEO_RECLIP  3  /* temporarly off, window clipping changes */

+typedef struct _XvV4LCtrlRec {

+    struct v4l2_queryctrl       qctrl;

+    Atom                        xv;

+} XvV4LCtrlRec, *XvV4LCtrlPtr;

+

 typedef struct _PortPrivRec {

     ScrnInfoPtr                 pScrn;

-    FBAreaPtr			pFBArea[2];

-    int				VideoOn;

-    Bool			StreamOn;

+    FBAreaPtr                   pFBArea[2];

+    int                         VideoOn;

+    Bool                        StreamOn;

     /* file handle */

-    int 			nr;

-    struct video_capability     cap;

+    int                         nr;

+    struct v4l2_capability      cap;

     /* RGB overlay */

-    struct video_buffer		rgb_fbuf;

-    struct video_window		rgb_win;

-    int                         rgbpalette;

+    struct v4l2_framebuffer     rgb_fbuf;

+    struct v4l2_window          rgb_win;

     int                         rgbdepth;

     /* attributes */

-    struct video_picture	pict;

-    struct video_audio          audio;

+    CARD32                      pixelformat;

     XF86VideoEncodingPtr        enc;

     int                         *input;

@@ -145,24 +158,21 @@ typedef struct _PortPrivRec {

     int                         yuv_width,yuv_height;

     XF86SurfacePtr              surface;

-    struct video_buffer		yuv_fbuf;

-    struct video_window		yuv_win;

+    struct v4l2_framebuffer     yuv_fbuf;

+    struct v4l2_window          yuv_win;

+

+    struct v4l2_standard        *standard; /* FIXME: can be removed */

+

+    XvV4LCtrlPtr                XvV4LCtrl;

+    int                         n_qctrl;

 } PortPrivRec, *PortPrivPtr;

-#define XV_ENCODING	"XV_ENCODING"

-#define XV_BRIGHTNESS  	"XV_BRIGHTNESS"

-#define XV_CONTRAST 	"XV_CONTRAST"

-#define XV_SATURATION  	"XV_SATURATION"

-#define XV_HUE		"XV_HUE"

+#define XV_ENCODING "XV_ENCODING"

+#define XV_FREQ     "XV_FREQ"

-#define XV_FREQ		"XV_FREQ"

-#define XV_MUTE		"XV_MUTE"

-#define XV_VOLUME      	"XV_VOLUME"

+#define MAKE_ATOM(a) MakeAtom(a, strlen(a), TRUE)

-#define MAKE_ATOM(a) MakeAtom(a, sizeof(a) - 1, TRUE)

-

-static Atom xvEncoding, xvBrightness, xvContrast, xvSaturation, xvHue;

-static Atom xvFreq, xvMute, xvVolume;

+static Atom xvEncoding, xvFreq;

 static XF86VideoFormatRec

 InputVideoFormats[] = {

@@ -176,16 +186,8 @@ InputVideoFormats[] = {

 static const XF86AttributeRec Attributes[] = {

     {XvSettable | XvGettable, -1000,    1000, XV_ENCODING},

-    {XvSettable | XvGettable, -1000,    1000, XV_BRIGHTNESS},

-    {XvSettable | XvGettable, -1000,    1000, XV_CONTRAST},

-    {XvSettable | XvGettable, -1000,    1000, XV_SATURATION},

-    {XvSettable | XvGettable, -1000,    1000, XV_HUE},

 };

-static const XF86AttributeRec VolumeAttr = 

-    {XvSettable | XvGettable, -1000,    1000, XV_VOLUME};

-static const XF86AttributeRec MuteAttr = 

-    {XvSettable | XvGettable,     0,       1, XV_MUTE};

-static const XF86AttributeRec FreqAttr = 

+static const XF86AttributeRec FreqAttr =

     {XvSettable | XvGettable,     0, 16*1000, XV_FREQ};

@@ -206,59 +208,247 @@ static struct V4L_DEVICE {

 };

 /* ---------------------------------------------------------------------- */

-/* forward decl */

-static void V4lQueryBestSize(ScrnInfoPtr pScrn, Bool motion,

-		 short vid_w, short vid_h, short drw_w, short drw_h,

-		 unsigned int *p_w, unsigned int *p_h, pointer data);

+static int SetV4LFmt(int fd, CARD32 pixelformat)

+{

+    struct v4l2_framebuffer fbuf;

+    char *p = (char *)&pixelformat;

+

+    memset(&fbuf, 0, sizeof(fbuf));

+    if (ioctl(fd, VIDIOC_G_FBUF, &fbuf) == -1) {

+        xf86Msg(X_ERROR, "v4l: Error %d: Can't get FBUF\n", errno);

+        return errno;

+    }

+    if (fbuf.fmt.pixelformat != pixelformat) {

+        fbuf.fmt.pixelformat = pixelformat;

+        if (ioctl(fd, VIDIOC_S_FBUF, &fbuf) == -1) {

+            xf86Msg(X_ERROR, "v4l: Error %d: Can't set FBUF to %c%c%c%c\n",

+                    errno, p[0], p[1], p[2], p[3]);

+            return errno;

+        }

+    }

+    DEBUG(xf86Msg(X_INFO, "v4l: Set overlay format to %c%c%c%c\n",

+                  p[0], p[1], p[2], p[3]));

+    return 0;

+}

+static int GetV4LFmt(int fd, CARD32 *pixelformat)

+{

+    struct v4l2_framebuffer fbuf;

+

+    memset(&fbuf, 0, sizeof(fbuf));

+    if (ioctl(fd, VIDIOC_G_FBUF, &fbuf) == -1) {

+        xf86Msg(X_ERROR, "v4l: Error %d: Can't get FBUF\n", errno);

+        return errno;

+    }

+

+    *pixelformat = fbuf.fmt.pixelformat;

+

+    return 0;

+}

+

+#define ATTR_NAME_PREFIX "XV_"

+static int AddControl(PortPrivPtr p, XF86AttributeRec **list, int *count,

+                      struct v4l2_queryctrl *qctrl, int *n)

+{

+    char *ptr;

+

+/* v4l_add_attr */

+    if (qctrl->flags & V4L2_CTRL_FLAG_DISABLED)

+        return 0;

+    switch (qctrl->type) {

+    case V4L2_CTRL_TYPE_INTEGER:

+    case V4L2_CTRL_TYPE_BOOLEAN:

+    case V4L2_CTRL_TYPE_MENU:

+    case V4L2_CTRL_TYPE_BUTTON:

+        break;

+    default:

+        return 0;

+    }

+

+    p->XvV4LCtrl = realloc(p->XvV4LCtrl, sizeof(XvV4LCtrlRec) * (*n + 1));

+    if (!p->XvV4LCtrl) {

+        if (*list) {

+            free (*list);

+            *count = 0;

+            *n = 0;

+        }

+        return -1;

+    }

+

+    *list = realloc(*list, sizeof(XF86AttributeRec) * (*count + 1));

+    if (NULL == *list) {

+        if (p->XvV4LCtrl)

+            free (p->XvV4LCtrl);

+        *count = 0;

+        return -1;

+    }

+

+    memset(*list + *count, 0, sizeof(XF86AttributeRec));

+    (*list)[*count].flags = XvSettable | XvGettable;

+

+    if (qctrl->flags & V4L2_CTRL_FLAG_READ_ONLY)

+        (*list)[*count].flags &= ~XvSettable;

+    if (qctrl->flags & V4L2_CTRL_FLAG_WRITE_ONLY)

+        (*list)[*count].flags &= ~XvGettable;

+    (*list)[*count].min_value = qctrl->minimum;

+    (*list)[*count].max_value = qctrl->maximum;

+    (*list)[*count].name = malloc(strlen((char *)qctrl->name) + 1 + sizeof (ATTR_NAME_PREFIX));

+    strcpy((*list)[*count].name, ATTR_NAME_PREFIX);

+    strcat((*list)[*count].name, (char *)qctrl->name);

+    for (ptr = (*list)[*count].name; *ptr; ptr++) {

+        *ptr = toupper(*ptr);

+        if (*ptr == ' ')

+            *ptr = '_';

+    }

+

+    p->XvV4LCtrl[*n].xv = MAKE_ATOM((*list)[*count].name);

+    memcpy(&p->XvV4LCtrl[*n].qctrl, qctrl, sizeof(*qctrl));

+

+    xf86Msg(X_INFO, "v4l: add attr %s (Xv/GPA %d) (%d to %d)\n",

+            (*list)[*count].name, (int)p->XvV4LCtrl[*n].xv,

+            p->XvV4LCtrl[*n].qctrl.minimum,

+            p->XvV4LCtrl[*n].qctrl.maximum);

+

+    (*count)++;

+    (*n)++;

+

+    return 0;

+}

+

+static void AddAllV4LControls(PortPrivPtr p, XF86AttributeRec **list,

+                              int *count, int fd)

+{

+    int entries = 0;

+    CARD32 id;

+    struct v4l2_queryctrl qctrl;

+

+    memset(&qctrl, 0, sizeof(qctrl));

+    qctrl.id = V4L2_CTRL_FLAG_NEXT_CTRL;

+    while (!ioctl(fd, VIDIOC_QUERYCTRL, &qctrl)) {

+        if (AddControl(p, list, count, &qctrl, &entries))

+            return;

+        qctrl.id |= V4L2_CTRL_FLAG_NEXT_CTRL;

+    }

+    if (qctrl.id != V4L2_CTRL_FLAG_NEXT_CTRL)

+        return;

+    for (id = V4L2_CID_USER_BASE; id < V4L2_CID_LASTP1; id++) {

+        qctrl.id = id;

+        if (!ioctl(fd, VIDIOC_QUERYCTRL, &qctrl)) {

+            if (AddControl(p, list, count, &qctrl, &entries))

+                return;

+        }

+    }

+    qctrl.id = V4L2_CID_PRIVATE_BASE;

+    while (!ioctl(fd, VIDIOC_QUERYCTRL, &qctrl)) {

+        if (AddControl(p, list, count, &qctrl, &entries))

+            return;

+        qctrl.id++;

+    }

+    p->n_qctrl = entries;

+}

 /* ---------------------------------------------------------------------- */

+/* setup yuv overlay + hw scaling: look if we find some common video

+   format which both v4l driver and the X-Server can handle */

+static int v4l_check_yuv(ScrnInfoPtr pScrn, PortPrivPtr pPPriv,

+                          char *dev, int fd)

+{

+    static const struct {

+        CARD32        v4l_palette;

+        unsigned int  xv_id;

+        unsigned int  xv_format;

+    } yuvlist[] = {

+        { V4L2_PIX_FMT_YUYV, FOURCC_YUY2, XvPacked },

+        { V4L2_PIX_FMT_UYVY, FOURCC_UYVY, XvPacked },

+        { 0 /* end of list */ },

+    };

+    /* FIXME: Why pScrn->scrnIndex? */

+    ScreenPtr pScreen = screenInfo.screens[pScrn->scrnIndex];

+    int fmt,i;

+

+    pPPriv->format = xf86XVQueryOffscreenImages(pScreen, &pPPriv->nformat);

+    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 2,

+                   "v4l: Number of Xv formats: %d\n", pPPriv->nformat);

+    if (!pPPriv->nformat)

+        return FALSE;

+

+    for (fmt = 0; yuvlist[fmt].v4l_palette != 0; fmt++) {

+        pPPriv->pixelformat = yuvlist[fmt].v4l_palette;

+        if (-1 == SetV4LFmt(fd, pPPriv->pixelformat))

+            continue;

+        GetV4LFmt(fd, &pPPriv->pixelformat);

+        if (pPPriv->pixelformat != yuvlist[fmt].v4l_palette)

+            continue;

+        /* ... works, check available offscreen image formats now ... */

+        for (i = 0; i < pPPriv->nformat; i++) {

+            if (pPPriv->format[i].image->id == yuvlist[fmt].xv_id &&

+                pPPriv->format[i].image->format == yuvlist[fmt].xv_format) {

+                /* ... match found, good. */

+                pPPriv->yuv_format = yuvlist[fmt].v4l_palette;

+                pPPriv->myfmt = pPPriv->format+i;

+                xf86DrvMsg(pScrn->scrnIndex, X_INFO,

+                           "v4l[%s]: using hw video scaling [%4.4s].\n",

+                           dev,(char*)&(pPPriv->format[i].image->id));

+                return TRUE;

+            }

+        }

+    }

+    return TRUE;

+}

+

 static int V4lOpenDevice(PortPrivPtr pPPriv, ScrnInfoPtr pScrn)

 {

     static int first = 1;

+#if 0

+    /*

+     * It may be a good idea to probe here, but this would break

+     * some things, as initialization uses yuv_format

+     */

+    if (!pPPriv->yuv_format && first)

+        v4l_check_yuv(pScrn, pPPriv, V4L_NAME, V4L_FD);

+#endif

     if (-1 == V4L_FD) {

-	V4L_FD = open(V4L_NAME, O_RDWR, 0);

+        V4L_FD = open(V4L_NAME, O_RDWR, 0);

-	pPPriv->rgb_fbuf.width        = pScrn->virtualX;

-	pPPriv->rgb_fbuf.height       = pScrn->virtualY;

-	pPPriv->rgb_fbuf.depth        = pScrn->bitsPerPixel;

-	pPPriv->rgb_fbuf.bytesperline = pScrn->displayWidth * ((pScrn->bitsPerPixel + 7)/8);

-	pPPriv->rgb_fbuf.base         = (pointer)(pScrn->memPhysBase + pScrn->fbOffset);

-	if (first) {

-	    first = 0;

-	    xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 2,

-			 "v4l: memPhysBase=0x%lx\n", pScrn->memPhysBase);

-	}

+        if (-1 == V4L_FD)

+            return errno;

-	switch (pScrn->bitsPerPixel) {

-	case 16:

-	    if (pScrn->weight.green == 5) {

-		pPPriv->rgbpalette = VIDEO_PALETTE_RGB555;

-		pPPriv->rgbdepth   = 16;

-	    } else {

-		pPPriv->rgbpalette = VIDEO_PALETTE_RGB565;

-		pPPriv->rgbdepth   = 16;

-	    }

-	    break;

-	case 24:

-	    pPPriv->rgbpalette = VIDEO_PALETTE_RGB24;

-	    pPPriv->rgbdepth   = 24;

-	    break;

-	case 32:

-	    pPPriv->rgbpalette = VIDEO_PALETTE_RGB32;

-	    pPPriv->rgbdepth   = 32;

-	    break;

-	}

+        if (-1 == ioctl(V4L_FD, VIDIOC_G_FBUF, &pPPriv->rgb_fbuf)) {

+            xf86Msg(X_ERROR, "v4l: Error %d: Can't get FBUF\n", errno);

+            return errno;

+        }

+        pPPriv->rgb_fbuf.fmt.width        = pScrn->virtualX;

+        pPPriv->rgb_fbuf.fmt.height       = pScrn->virtualY;

+        pPPriv->rgb_fbuf.fmt.bytesperline = pScrn->displayWidth * ((pScrn->bitsPerPixel + 7)/8);

+        pPPriv->rgb_fbuf.base             = (pointer)(pScrn->memPhysBase + pScrn->fbOffset);

+        if (first) {

+            xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 2,

+                           "v4l: memPhysBase=0x%lx\n", pScrn->memPhysBase);

+            first = 0;

+        }

+

+        switch (pScrn->bitsPerPixel) {

+        case 16:

+            if (pScrn->weight.green == 5) {

+                pPPriv->rgb_fbuf.fmt.pixelformat = V4L2_PIX_FMT_RGB555;

+            } else {

+                pPPriv->rgb_fbuf.fmt.pixelformat = V4L2_PIX_FMT_RGB565;

+            }

+            break;

+        case 24:

+            pPPriv->rgb_fbuf.fmt.pixelformat = V4L2_PIX_FMT_BGR24;

+            break;

+        case 32:

+            pPPriv->rgb_fbuf.fmt.pixelformat = V4L2_PIX_FMT_BGR32;

+            break;

+        }

     }

-    if (-1 == V4L_FD)

-	return errno;

-    

     V4L_REF++;

     DEBUG(xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 2,

-			 "Xv/open: refcount=%d\n",V4L_REF));

+                         "Xv/open: refcount=%d\n",V4L_REF));

     return 0;

 }

@@ -267,10 +457,10 @@ static void V4lCloseDevice(PortPrivPtr p

 {

     V4L_REF--;

     DEBUG(xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 2,

-			 "Xv/close: refcount=%d\n",V4L_REF));

+                         "Xv/close: refcount=%d\n",V4L_REF));

     if (0 == V4L_REF && -1 != V4L_FD) {

-	close(V4L_FD);

-	V4L_FD = -1;

+        close(V4L_FD);

+        V4L_FD = -1;

     }

 }

@@ -280,8 +470,10 @@ V4lPutVideo(ScrnInfoPtr pScrn,

     short vid_w, short vid_h, short drw_w, short drw_h,

     RegionPtr clipBoxes, pointer data, DrawablePtr pDraw)

 {

+    struct v4l2_format fmt;

+

     PortPrivPtr pPPriv = (PortPrivPtr) data;

-    struct video_clip *clip;

+    struct v4l2_clip *clip;

     BoxPtr pBox;

     RegionRec newReg;

     BoxRec    newBox;

@@ -291,179 +483,214 @@ V4lPutVideo(ScrnInfoPtr pScrn,

     /* Open a file handle to the device */

     if (VIDEO_OFF == pPPriv->VideoOn) {

-	if (V4lOpenDevice(pPPriv, pScrn))

-	    return Success;

+        if (V4lOpenDevice(pPPriv, pScrn))

+            return Success;

     }

     if (0 != pPPriv->yuv_format) {

-	DEBUG(xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 2, "Xv/PV yuv\n"));

-	width  = pPPriv->enc[pPPriv->cenc].width;

+        DEBUG(xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 2, "Xv/PV yuv\n"));

+        width  = pPPriv->enc[pPPriv->cenc].width;

         height = pPPriv->enc[pPPriv->cenc].height/2; /* no interlace */

-	if (drw_w < width)

-	    width = drw_w;

-	if (drw_h < height)

-	    height = drw_h;

-	if ((height != pPPriv->yuv_height) || (width != pPPriv->yuv_width)) {

-	    /* new size -- free old surface */

-	    DEBUG(xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 2, "  surface resize\n"));

-	    if (pPPriv->surface) {

-		pPPriv->VideoOn = VIDEO_OFF;

-		pPPriv->myfmt->stop(pPPriv->surface);

-		pPPriv->myfmt->free_surface(pPPriv->surface);

-		xfree(pPPriv->surface);

-		pPPriv->surface    = NULL;

-	    }

-	    pPPriv->yuv_width  = width;

-	    pPPriv->yuv_height = height;

-	}

-	if (!pPPriv->surface) {

-	    /* allocate + setup offscreen surface */

-	    if (NULL == (pPPriv->surface = xalloc(sizeof(XF86SurfaceRec))))

-		return FALSE;

-	    if (Success != pPPriv->myfmt->alloc_surface

-		(pScrn,pPPriv->myfmt->image->id,

-		 pPPriv->yuv_width,pPPriv->yuv_height,pPPriv->surface)) {

-		xfree(pPPriv->surface);

-		pPPriv->surface = NULL;

-		goto fallback_to_rgb;

-	    }

-	    pPPriv->yuv_fbuf.width        = pPPriv->surface->width;

-	    pPPriv->yuv_fbuf.height       = pPPriv->surface->height;

-	    pPPriv->yuv_fbuf.depth        = 16;

-	    pPPriv->yuv_fbuf.bytesperline = pPPriv->surface->pitches[0];

-	    pPPriv->yuv_fbuf.base         =

-		(pointer)(pScrn->memPhysBase + pPPriv->surface->offsets[0]);

-	    DEBUG(xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 2, "  surface: %p+%d = %p, %dx%d, pitch %d\n",

-				 pScrn->memPhysBase,pPPriv->surface->offsets[0],

-				 pScrn->memPhysBase+pPPriv->surface->offsets[0],

-				 pPPriv->surface->width,pPPriv->surface->height,

-				 pPPriv->surface->pitches[0]));

-	    pPPriv->yuv_win.width         = pPPriv->surface->width;

-	    pPPriv->yuv_win.height        = pPPriv->surface->height;

-	}

+        if (drw_w < width)

+            width = drw_w;

+        if (drw_h < height)

+            height = drw_h;

+        if ((height != pPPriv->yuv_height) || (width != pPPriv->yuv_width)) {

+            /* new size -- free old surface */

+            DEBUG(xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 2, "  surface resize\n"));

+            if (pPPriv->surface) {

+                pPPriv->VideoOn = VIDEO_OFF;

+                pPPriv->myfmt->stop(pPPriv->surface);

+                pPPriv->myfmt->free_surface(pPPriv->surface);

+                free(pPPriv->surface);

+                pPPriv->surface    = NULL;

+            }

+            pPPriv->yuv_width  = width;

+            pPPriv->yuv_height = height;

+        }

+        if (!pPPriv->surface) {

+            /* allocate + setup offscreen surface */

+            if (NULL == (pPPriv->surface = malloc(sizeof(XF86SurfaceRec))))

+                return FALSE;

+            if (Success != pPPriv->myfmt->alloc_surface

+                (pScrn,pPPriv->myfmt->image->id,

+                pPPriv->yuv_width,pPPriv->yuv_height,pPPriv->surface)) {

+                free(pPPriv->surface);

+                pPPriv->surface = NULL;

+                goto fallback_to_rgb;

+            }

-	/* program driver */

-	if (-1 == ioctl(V4L_FD,VIDIOCSFBUF,&(pPPriv->yuv_fbuf)))

-	    perror("ioctl VIDIOCSFBUF");

-	if (-1 == ioctl(V4L_FD,VIDIOCGPICT,&pPPriv->pict))

-	    perror("ioctl VIDIOCGPICT");

-	pPPriv->pict.palette = pPPriv->yuv_format;

-	pPPriv->pict.depth   = 16;

-	if (-1 == ioctl(V4L_FD,VIDIOCSPICT,&pPPriv->pict))

-	    perror("ioctl VIDIOCSPICT");

-	if (-1 == ioctl(V4L_FD,VIDIOCSWIN,&(pPPriv->yuv_win)))

-	    perror("ioctl VIDIOCSWIN");

-	if (-1 == ioctl(V4L_FD, VIDIOCCAPTURE, &one))

-	    perror("ioctl VIDIOCCAPTURE(1)");

+            if (-1 == ioctl(V4L_FD, VIDIOC_G_FBUF, &pPPriv->yuv_fbuf)) {

+                xf86Msg(X_ERROR, "v4l: Error %d: Can't get FBUF\n", errno);

+                return errno;

+            }

+            pPPriv->yuv_fbuf.fmt.width        = pPPriv->surface->width;

+            pPPriv->yuv_fbuf.fmt.height       = pPPriv->surface->height;

+            pPPriv->yuv_fbuf.fmt.bytesperline = pPPriv->surface->pitches[0];

+            pPPriv->yuv_fbuf.fmt.pixelformat = pPPriv->yuv_format;

+            pPPriv->yuv_fbuf.base         =

+                (pointer)(pScrn->memPhysBase + pPPriv->surface->offsets[0]);

+            DEBUG(xf86DrvMsgVerb(pScrn->scrnIndex, X_INFO, 2,

+                                 "  surface: %p+%d = %p, %dx%d, pitch %d\n",

+                                (void *)pScrn->memPhysBase, pPPriv->surface->offsets[0],

+                                (void *)pScrn->memPhysBase+pPPriv->surface->offsets[0],

+                                pPPriv->surface->width, pPPriv->surface->height,

+                                pPPriv->surface->pitches[0]));

+            memset(&pPPriv->yuv_win, 0, sizeof(pPPriv->yuv_win));

+            pPPriv->yuv_win.w.left    = 0;

+            pPPriv->yuv_win.w.top     = 0;

+            pPPriv->yuv_win.w.width  = pPPriv->surface->width;

+            pPPriv->yuv_win.w.height = pPPriv->surface->height;

+        }

-	if (0 == (pPPriv->myfmt->flags & VIDEO_INVERT_CLIPLIST)) {

-	    /* invert cliplist */

-	    newBox.x1 = drw_x;

-	    newBox.y1 = drw_y;

-	    newBox.x2 = drw_x + drw_w;

-	    newBox.y2 = drw_y + drw_h;

+        /* program driver */

+        if (-1 == ioctl(V4L_FD, VIDIOC_S_FBUF, &pPPriv->yuv_fbuf)) {

+            xf86Msg(X_ERROR, "Error %d at VIDIOC_S_FBUF\n", errno);

+            return BadValue;

+        }

+        pPPriv->pixelformat = pPPriv->yuv_format;

+        if (-1 == SetV4LFmt(V4L_FD, pPPriv->pixelformat))

+            return BadValue;

-	    if (pPPriv->myfmt->flags & VIDEO_CLIP_TO_VIEWPORT) {

-		/* trim to the viewport */

-		if(newBox.x1 < pScrn->frameX0)

-		    newBox.x1 = pScrn->frameX0;

-		if(newBox.x2 > pScrn->frameX1)

-		    newBox.x2 = pScrn->frameX1;

-		

-		if(newBox.y1 < pScrn->frameY0)

-		    newBox.y1 = pScrn->frameY0;

-		if(newBox.y2 > pScrn->frameY1)

-		    newBox.y2 = pScrn->frameY1;

-	    }

+        memset(&fmt, 0, sizeof(fmt));

+        fmt.type = V4L2_BUF_TYPE_VIDEO_OVERLAY;

+        memcpy(&fmt.fmt.win, &pPPriv->yuv_win, sizeof(pPPriv->yuv_win));

+        if (-1 == ioctl(V4L_FD, VIDIOC_S_FMT, &fmt)) {

+            xf86Msg(X_ERROR, "Error %d at VIDIOC_S_FMT\n", errno);