|
|
@@ -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;
|
|
|
}
|
|
|
|
|
|
/* ----------------------------------------------------------------------- */
|
Michael Schimek