V4L/DVB (5077): Bttv cropping support

Adds the missing VIDIOC_CROPCAP, G_CROP and S_CROP ioctls, permitting 
applications to capture or overlay a subsection of the picture or to 
extend the capture window beyond active video, into the VBI area and the 
horizontal blanking. VBI capturing can start and end on any line, 
including the picture area, and apps can capture different lines of each 
field and single fields.
For compatibility with existing applications, the open() function
resets the cropping and VBI capturing parameters and a VIDIOC_S_CROP
call is necessary to actually enable cropping. 
Regrettably in PAL-M, PAL-N, PAL-Nc and NTSC-JP mode the maximum image 
width will increase from 640 and 768 to 747 and 923 pixels respectively.
Like the VBI changes however, this should only affect applications which 
depend on former driver limitations, such as never getting more than 640 
pixels regardless of the requested width. 
Also, new freedoms require additional checks for conflicts and some 
applications may not expect an EBUSY error from the VIDIOC_QBUF and 
VIDIOCMCAPTURE ioctls. These errors should be rare though.
So far, the patch has been tested on a UP machine with a bt878 in PAL-
BGHI and NTSC-M mode using xawtv, tvtime, mplayer/mencoder, zapping/
libzvbi and these tools: http://zapping.sf.net/bttv-crop-test.tar.bz2
I'd be grateful about comments or bug reports.

Signed-off-by: Michael H. Schimek <mschimek@gmx.at>
Signed-off-by: Mauro Carvalho Chehab <mchehab@infradead.org>

1 files changed, 298 insertions, 68 deletions

diff --git a/drivers/media/video/bt8xx/bttv-vbi.c b/drivers/media/video/bt8xx/bttv-vbi.c
index 6fc6b0260056..754f66bfdf46 100644
--- a/drivers/media/video/bt8xx/bttv-vbi.c
+++ b/drivers/media/video/bt8xx/bttv-vbi.c
@@ -5,6 +5,9 @@
 
     (c) 2002 Gerd Knorr <kraxel@bytesex.org>
 
+    Copyright (C) 2005, 2006 Michael H. Schimek <mschimek@gmx.at>
+    Sponsored by OPQ Systems AB
+
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
@@ -41,8 +44,15 @@
    to be about 244.  */
 #define VBI_OFFSET 244
 
+/* 2048 for compatibility with earlier driver versions. The driver
+   really stores 1024 + tvnorm->vbipack * 4 samples per line in the
+   buffer. Note tvnorm->vbipack is <= 0xFF (limit of VBIPACK_LO + HI
+   is 0x1FF DWORDs) and VBI read()s store a frame counter in the last
+   four bytes of the VBI image. */
+#define VBI_BPL 2048
+
+/* Compatibility. */
 #define VBI_DEFLINES 16
-#define VBI_MAXLINES 32
 
 static unsigned int vbibufs = 4;
 static unsigned int vbi_debug = 0;
@@ -58,21 +68,12 @@ MODULE_PARM_DESC(vbi_debug,"vbi code debug messages, default is 0 (no)");
 #define dprintk(fmt, arg...)    if (vbi_debug) \
         printk(KERN_DEBUG "bttv%d/vbi: " fmt, btv->c.nr , ## arg)
 
+#define IMAGE_SIZE(fmt) \
+        (((fmt)->count[0] + (fmt)->count[1]) * (fmt)->samples_per_line)
+
 /* ----------------------------------------------------------------------- */
 /* vbi risc code + mm                                                      */
 
-static int
-vbi_buffer_risc(struct bttv *btv, struct bttv_buffer *buf, int lines)
-{
-        int bpl = 2048;
-
-        bttv_risc_packed(btv, &buf->top, buf->vb.dma.sglist,
-                         0, bpl-4, 4, lines);
-        bttv_risc_packed(btv, &buf->bottom, buf->vb.dma.sglist,
-                         lines * bpl, bpl-4, 4, lines);
-        return 0;
-}
-
 static int vbi_buffer_setup(struct videobuf_queue *q,
                             unsigned int *count, unsigned int *size)
 {
@@ -81,8 +82,16 @@ static int vbi_buffer_setup(struct videobuf_queue *q,
 
         if (0 == *count)
                 *count = vbibufs;
-        *size = fh->lines * 2 * 2048;
-        dprintk("setup: lines=%d\n",fh->lines);
+
+        *size = IMAGE_SIZE(&fh->vbi_fmt.fmt);
+
+        dprintk("setup: samples=%u start=%d,%d count=%u,%u\n",
+                fh->vbi_fmt.fmt.samples_per_line,
+                fh->vbi_fmt.fmt.start[0],
+                fh->vbi_fmt.fmt.start[1],
+                fh->vbi_fmt.fmt.count[0],
+                fh->vbi_fmt.fmt.count[1]);
+
         return 0;
 }
 
@@ -93,18 +102,93 @@ static int vbi_buffer_prepare(struct videobuf_queue *q,
         struct bttv_fh *fh = q->priv_data;
         struct bttv *btv = fh->btv;
         struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb);
+        const struct bttv_tvnorm *tvnorm;
+        unsigned int skip_lines0, skip_lines1, min_vdelay;
+        int redo_dma_risc;
         int rc;
 
-        buf->vb.size = fh->lines * 2 * 2048;
+        buf->vb.size = IMAGE_SIZE(&fh->vbi_fmt.fmt);
         if (0 != buf->vb.baddr  &&  buf->vb.bsize < buf->vb.size)
                 return -EINVAL;
 
+        tvnorm = fh->vbi_fmt.tvnorm;
+
+        /* There's no VBI_VDELAY register, RISC must skip the lines
+           we don't want. With default parameters we skip zero lines
+           as earlier driver versions did. The driver permits video
+           standard changes while capturing, so we use vbi_fmt.tvnorm
+           instead of btv->tvnorm to skip zero lines after video
+           standard changes as well. */
+
+        skip_lines0 = 0;
+        skip_lines1 = 0;
+
+        if (fh->vbi_fmt.fmt.count[0] > 0)
+                skip_lines0 = max(0, (fh->vbi_fmt.fmt.start[0]
+                                      - tvnorm->vbistart[0]));
+        if (fh->vbi_fmt.fmt.count[1] > 0)
+                skip_lines1 = max(0, (fh->vbi_fmt.fmt.start[1]
+                                      - tvnorm->vbistart[1]));
+
+        redo_dma_risc = 0;
+
+        if (buf->vbi_skip[0] != skip_lines0 ||
+            buf->vbi_skip[1] != skip_lines1 ||
+            buf->vbi_count[0] != fh->vbi_fmt.fmt.count[0] ||
+            buf->vbi_count[1] != fh->vbi_fmt.fmt.count[1]) {
+                buf->vbi_skip[0] = skip_lines0;
+                buf->vbi_skip[1] = skip_lines1;
+                buf->vbi_count[0] = fh->vbi_fmt.fmt.count[0];
+                buf->vbi_count[1] = fh->vbi_fmt.fmt.count[1];
+                redo_dma_risc = 1;
+        }
+
         if (STATE_NEEDS_INIT == buf->vb.state) {
+                redo_dma_risc = 1;
                 if (0 != (rc = videobuf_iolock(q, &buf->vb, NULL)))
                         goto fail;
-                if (0 != (rc = vbi_buffer_risc(btv,buf,fh->lines)))
-                        goto fail;
         }
+
+        if (redo_dma_risc) {
+                unsigned int bpl, padding, offset;
+
+                bpl = 2044; /* max. vbipack */
+                padding = VBI_BPL - bpl;
+
+                if (fh->vbi_fmt.fmt.count[0] > 0) {
+                        rc = bttv_risc_packed(btv, &buf->top,
+                                              buf->vb.dma.sglist,
+                                              /* offset */ 0, bpl,
+                                              padding, skip_lines0,
+                                              fh->vbi_fmt.fmt.count[0]);
+                        if (0 != rc)
+                                goto fail;
+                }
+
+                if (fh->vbi_fmt.fmt.count[1] > 0) {
+                        offset = fh->vbi_fmt.fmt.count[0] * VBI_BPL;
+
+                        rc = bttv_risc_packed(btv, &buf->bottom,
+                                              buf->vb.dma.sglist,
+                                              offset, bpl,
+                                              padding, skip_lines1,
+                                              fh->vbi_fmt.fmt.count[1]);
+                        if (0 != rc)
+                                goto fail;
+                }
+        }
+
+        /* VBI capturing ends at VDELAY, start of video capturing,
+           no matter where the RISC program ends. VDELAY minimum is 2,
+           bounds.top is the corresponding first field line number
+           times two. VDELAY counts half field lines. */
+        min_vdelay = MIN_VDELAY;
+        if (fh->vbi_fmt.end >= tvnorm->cropcap.bounds.top)
+                min_vdelay += fh->vbi_fmt.end - tvnorm->cropcap.bounds.top;
+
+        /* For bttv_buffer_activate_vbi(). */
+        buf->geo.vdelay = min_vdelay;
+
         buf->vb.state = STATE_PREPARED;
         buf->vb.field = field;
         dprintk("buf prepare %p: top=%p bottom=%p field=%s\n",
@@ -152,69 +236,215 @@ struct videobuf_queue_ops bttv_vbi_qops = {
 
 /* ----------------------------------------------------------------------- */
 
-void bttv_vbi_setlines(struct bttv_fh *fh, struct bttv *btv, int lines)
+static int
+try_fmt                 (struct v4l2_vbi_format *       f,
+                         const struct bttv_tvnorm *     tvnorm,
+                         __s32                          crop_start)
 {
-        int vdelay;
-
-        if (lines < 1)
-                lines = 1;
-        if (lines > VBI_MAXLINES)
-                lines = VBI_MAXLINES;
-        fh->lines = lines;
-
-        vdelay = btread(BT848_E_VDELAY_LO);
-        if (vdelay < lines*2) {
-                vdelay = lines*2;
-                btwrite(vdelay,BT848_E_VDELAY_LO);
-                btwrite(vdelay,BT848_O_VDELAY_LO);
+        __s32 min_start, max_start, max_end, f2_offset;
+        unsigned int i;
+
+        /* For compatibility with earlier driver versions we must pretend
+           the VBI and video capture window may overlap. In reality RISC
+           magic aborts VBI capturing at the first line of video capturing,
+           leaving the rest of the buffer unchanged, usually all zero.
+           VBI capturing must always start before video capturing. >> 1
+           because cropping counts field lines times two. */
+        min_start = tvnorm->vbistart[0];
+        max_start = (crop_start >> 1) - 1;
+        max_end = (tvnorm->cropcap.bounds.top
+                   + tvnorm->cropcap.bounds.height) >> 1;
+
+        if (min_start > max_start)
+                return -EBUSY;
+
+        BUG_ON(max_start >= max_end);
+
+        f->sampling_rate    = tvnorm->Fsc;
+        f->samples_per_line = VBI_BPL;
+        f->sample_format    = V4L2_PIX_FMT_GREY;
+        f->offset           = VBI_OFFSET;
+
+        f2_offset = tvnorm->vbistart[1] - tvnorm->vbistart[0];
+
+        for (i = 0; i < 2; ++i) {
+                if (0 == f->count[i]) {
+                        /* No data from this field. We leave f->start[i]
+                           alone because VIDIOCSVBIFMT is w/o and EINVALs
+                           when a driver does not support exactly the
+                           requested parameters. */
+                } else {
+                        s64 start, count;
+
+                        start = clamp(f->start[i], min_start, max_start);
+                        /* s64 to prevent overflow. */
+                        count = (s64) f->start[i] + f->count[i] - start;
+                        f->start[i] = start;
+                        f->count[i] = clamp(count, (s64) 1,
+                                            max_end - start);
+                }
+
+                min_start += f2_offset;
+                max_start += f2_offset;
+                max_end += f2_offset;
         }
+
+        if (0 == (f->count[0] | f->count[1])) {
+                /* As in earlier driver versions. */
+                f->start[0] = tvnorm->vbistart[0];
+                f->start[1] = tvnorm->vbistart[1];
+                f->count[0] = 1;
+                f->count[1] = 1;
+        }
+
+        f->flags = 0;
+
+        f->reserved[0] = 0;
+        f->reserved[1] = 0;
+
+        return 0;
 }
 
-void bttv_vbi_try_fmt(struct bttv_fh *fh, struct v4l2_format *f)
+int
+bttv_vbi_try_fmt        (struct bttv_fh *               fh,
+                         struct v4l2_vbi_format *       f)
 {
+        struct bttv *btv = fh->btv;
         const struct bttv_tvnorm *tvnorm;
-        s64 count0,count1,count;
+        __s32 crop_start;
 
-        tvnorm = &bttv_tvnorms[fh->btv->tvnorm];
-        f->type = V4L2_BUF_TYPE_VBI_CAPTURE;
-        f->fmt.vbi.sampling_rate    = tvnorm->Fsc;
-        f->fmt.vbi.samples_per_line = 2048;
-        f->fmt.vbi.sample_format    = V4L2_PIX_FMT_GREY;
-        f->fmt.vbi.offset           = VBI_OFFSET;
-        f->fmt.vbi.flags            = 0;
-
-        /* s64 to prevent overflow. */
-        count0 = (s64) f->fmt.vbi.start[0] + f->fmt.vbi.count[0]
-                - tvnorm->vbistart[0];
-        count1 = (s64) f->fmt.vbi.start[1] + f->fmt.vbi.count[1]
-                - tvnorm->vbistart[1];
-        count  = clamp (max (count0, count1), (s64) 1, (s64) VBI_MAXLINES);
-
-        f->fmt.vbi.start[0] = tvnorm->vbistart[0];
-        f->fmt.vbi.start[1] = tvnorm->vbistart[1];
-        f->fmt.vbi.count[0] = count;
-        f->fmt.vbi.count[1] = count;
-
-        f->fmt.vbi.reserved[0] = 0;
-        f->fmt.vbi.reserved[1] = 0;
+        mutex_lock(&btv->lock);
+
+        tvnorm = &bttv_tvnorms[btv->tvnorm];
+        crop_start = btv->crop_start;
+
+        mutex_unlock(&btv->lock);
+
+        return try_fmt(f, tvnorm, crop_start);
 }
 
-void bttv_vbi_get_fmt(struct bttv_fh *fh, struct v4l2_format *f)
+int
+bttv_vbi_set_fmt        (struct bttv_fh *               fh,
+                         struct v4l2_vbi_format *       f)
 {
+        struct bttv *btv = fh->btv;
         const struct bttv_tvnorm *tvnorm;
+        __s32 start1, end;
+        int rc;
+
+        mutex_lock(&btv->lock);
+
+        rc = -EBUSY;
+        if (fh->resources & RESOURCE_VBI)
+                goto fail;
+
+        tvnorm = &bttv_tvnorms[btv->tvnorm];
+
+        rc = try_fmt(f, tvnorm, btv->crop_start);
+        if (0 != rc)
+                goto fail;
+
+        start1 = f->start[1] - tvnorm->vbistart[1] + tvnorm->vbistart[0];
+
+        /* First possible line of video capturing. Should be
+           max(f->start[0] + f->count[0], start1 + f->count[1]) * 2
+           when capturing both fields. But for compatibility we must
+           pretend the VBI and video capture window may overlap,
+           so end = start + 1, the lowest possible value, times two
+           because vbi_fmt.end counts field lines times two. */
+        end = max(f->start[0], start1) * 2 + 2;
+
+        mutex_lock(&fh->vbi.lock);
+
+        fh->vbi_fmt.fmt    = *f;
+        fh->vbi_fmt.tvnorm = tvnorm;
+        fh->vbi_fmt.end    = end;
+
+        mutex_unlock(&fh->vbi.lock);
+
+        rc = 0;
+
+ fail:
+        mutex_unlock(&btv->lock);
+
+        return rc;
+}
+
+void
+bttv_vbi_get_fmt        (struct bttv_fh *               fh,
+                         struct v4l2_vbi_format *       f)
+{
+        const struct bttv_tvnorm *tvnorm;
+
+        *f = fh->vbi_fmt.fmt;
 
         tvnorm = &bttv_tvnorms[fh->btv->tvnorm];
-        memset(f,0,sizeof(*f));
-        f->type = V4L2_BUF_TYPE_VBI_CAPTURE;
-        f->fmt.vbi.sampling_rate    = tvnorm->Fsc;
-        f->fmt.vbi.samples_per_line = 2048;
-        f->fmt.vbi.sample_format    = V4L2_PIX_FMT_GREY;
-        f->fmt.vbi.offset           = VBI_OFFSET;
-        f->fmt.vbi.start[0]         = tvnorm->vbistart[0];
-        f->fmt.vbi.start[1]         = tvnorm->vbistart[1];
-        f->fmt.vbi.count[0]         = fh->lines;
-        f->fmt.vbi.count[1]         = fh->lines;
-        f->fmt.vbi.flags            = 0;
+
+        if (tvnorm != fh->vbi_fmt.tvnorm) {
+                __s32 max_end;
+                unsigned int i;
+
+                /* As in vbi_buffer_prepare() this imitates the
+                   behaviour of earlier driver versions after video
+                   standard changes, with default parameters anyway. */
+
+                max_end = (tvnorm->cropcap.bounds.top
+                           + tvnorm->cropcap.bounds.height) >> 1;
+
+                f->sampling_rate = tvnorm->Fsc;
+
+                for (i = 0; i < 2; ++i) {
+                        __s32 new_start;
+
+                        new_start = f->start[i]
+                                + tvnorm->vbistart[i]
+                                - fh->vbi_fmt.tvnorm->vbistart[i];
+
+                        f->start[i] = min(new_start, max_end - 1);
+                        f->count[i] = min((__s32) f->count[i],
+                                          max_end - f->start[i]);
+
+                        max_end += tvnorm->vbistart[1]
+                                - tvnorm->vbistart[0];
+                }
+        }
+}
+
+void
+bttv_vbi_fmt_reset      (struct bttv_vbi_fmt *          f,
+                         int                            norm)
+{
+        const struct bttv_tvnorm *tvnorm;
+        unsigned int real_samples_per_line;
+        unsigned int real_count;
+
+        tvnorm = &bttv_tvnorms[norm];
+
+        f->fmt.sampling_rate    = tvnorm->Fsc;
+        f->fmt.samples_per_line = VBI_BPL;
+        f->fmt.sample_format    = V4L2_PIX_FMT_GREY;
+        f->fmt.offset           = VBI_OFFSET;
+        f->fmt.start[0]         = tvnorm->vbistart[0];
+        f->fmt.start[1]         = tvnorm->vbistart[1];
+        f->fmt.count[0]         = VBI_DEFLINES;
+        f->fmt.count[1]         = VBI_DEFLINES;
+        f->fmt.flags            = 0;
+        f->fmt.reserved[0]      = 0;
+        f->fmt.reserved[1]      = 0;
+
+        /* For compatibility the buffer size must be 2 * VBI_DEFLINES *
+           VBI_BPL regardless of the current video standard. */
+        real_samples_per_line   = 1024 + tvnorm->vbipack * 4;
+        real_count              = ((tvnorm->cropcap.defrect.top >> 1)
+                                   - tvnorm->vbistart[0]);
+
+        BUG_ON(real_samples_per_line > VBI_BPL);
+        BUG_ON(real_count > VBI_DEFLINES);
+
+        f->tvnorm               = tvnorm;
+
+        /* See bttv_vbi_fmt_set(). */
+        f->end                  = tvnorm->vbistart[0] * 2 + 2;
 }
 
 /* ----------------------------------------------------------------------- */