rpms/v4l-utils
7
0
Fork 0
Code Issues Pull Requests Releases Activity

New upstream release 0.8.7

Browse Source 
- Fixes rhbz#807656
This commit is contained in:
Hans de Goede 2012-04-09 12:45:35 +02:00
parent ed6fb24c89
commit 4a60185935
8 changed files with 733 additions and 3 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@ -1,3 +1,4 @@
/v4l-utils-0.8.3.tar.bz2
/v4l-utils-0.8.4.tar.bz2
/v4l-utils-0.8.5.tar.bz2
/v4l-utils-0.8.7.tar.bz2

26
0001-libv4lconver-tinyjpeg-Fix-out-of-bounds-array-usage.patch Normal file
View File

@ -0,0 +1,26 @@
From 3df030fe82a31556695dc147e2a28288bbe12cf8 Mon Sep 17 00:00:00 2001
From: Hans de Goede <hdegoede@redhat.com>
Date: Sat, 7 Apr 2012 16:31:12 +0200
Subject: [PATCH 1/5] libv4lconver/tinyjpeg: Fix out of bounds array usage
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
---
lib/libv4lconvert/tinyjpeg.c | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/lib/libv4lconvert/tinyjpeg.c b/lib/libv4lconvert/tinyjpeg.c
index e308f63..967e0be 100644
--- a/lib/libv4lconvert/tinyjpeg.c
+++ b/lib/libv4lconvert/tinyjpeg.c
@@ -2556,7 +2556,7 @@ int tinyjpeg_get_components(struct jdec_private *priv, unsigned char **component
{
int i;
- for (i = 0; priv->components[i] && i < COMPONENTS; i++)
+ for (i = 0; i < COMPONENTS && priv->components[i]; i++)
components[i] = priv->components[i];
return 0;
}
--
1.7.9.3

51
0002-tinyjpeg-Better-luminance-quantization-table-for-Pix.patch Normal file
View File

@ -0,0 +1,51 @@
From e186777daeaa717b7d919e932f7d3be10156d572 Mon Sep 17 00:00:00 2001
From: Jean-Francois Moine <moinejf@free.fr>
Date: Fri, 23 Mar 2012 20:19:45 +0100
Subject: [PATCH 2/5] tinyjpeg: Better luminance quantization table for Pixart
JPEG
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
An other luminance quantization table gives a better quality to the
Pixart images created by the webcams handled by the gspca drivers
pac7302 and pac7311 (pixel format 'PJPG').
Tests have been done with 5 different pac7302 webcams. The marker was
always 0x44.
Signed-off-by: Jean-François Moine <moinejf@free.fr>
---
lib/libv4lconvert/tinyjpeg.c | 16 ++++++++--------
1 file changed, 8 insertions(+), 8 deletions(-)
diff --git a/lib/libv4lconvert/tinyjpeg.c b/lib/libv4lconvert/tinyjpeg.c
index 967e0be..2c2d4af 100644
--- a/lib/libv4lconvert/tinyjpeg.c
+++ b/lib/libv4lconvert/tinyjpeg.c
@@ -206,14 +206,14 @@ static const unsigned char val_ac_chrominance[] = {
};
const unsigned char pixart_quantization[][64] = { {
- 0x07, 0x07, 0x08, 0x0a, 0x09, 0x07, 0x0d, 0x0b,
- 0x0c, 0x0d, 0x11, 0x10, 0x0f, 0x12, 0x17, 0x27,
- 0x1a, 0x18, 0x16, 0x16, 0x18, 0x31, 0x23, 0x25,
- 0x1d, 0x28, 0x3a, 0x33, 0x3d, 0x3c, 0x39, 0x33,
- 0x38, 0x37, 0x40, 0x48, 0x5c, 0x4e, 0x40, 0x44,
- 0x57, 0x45, 0x37, 0x38, 0x50, 0x6d, 0x51, 0x57,
- 0x5f, 0x62, 0x67, 0x68, 0x67, 0x3e, 0x4d, 0x71,
- 0x79, 0x70, 0x64, 0x78, 0x5c, 0x65, 0x67, 0x63,
+ 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x10, 0x10,
+ 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
+ 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
+ 0x10, 0x10, 0x10, 0x10, 0x20, 0x20, 0x20, 0x20,
+ 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+ 0x20, 0x20, 0x20, 0x40, 0x40, 0x40, 0x40, 0x40,
+ 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
+ 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
},
{
0x11, 0x12, 0x12, 0x18, 0x15, 0x18, 0x2f, 0x1a,
--
1.7.9.3

28
0003-libv4lconver-Add-06f8-301b-pac7302-based-cam-to-the-.patch Normal file
View File

@ -0,0 +1,28 @@
From e681916636373959c39b3f13a44e145106119b68 Mon Sep 17 00:00:00 2001
From: Hans de Goede <hdegoede@redhat.com>
Date: Sun, 8 Apr 2012 11:27:52 +0200
Subject: [PATCH 3/5] libv4lconver: Add 06f8:301b pac7302 based cam to the
quirk table
Reported-by: Jean-Francois Moine <moinejf@free.fr>
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
---
lib/libv4lconvert/control/libv4lcontrol.c | 2 ++
1 file changed, 2 insertions(+)
diff --git a/lib/libv4lconvert/control/libv4lcontrol.c b/lib/libv4lconvert/control/libv4lcontrol.c
index 701483b..25b502a 100644
--- a/lib/libv4lconvert/control/libv4lcontrol.c
+++ b/lib/libv4lconvert/control/libv4lcontrol.c
@@ -203,6 +203,8 @@ static const struct v4lcontrol_flags_info v4lcontrol_flags[] = {
V4LCONTROL_ROTATED_90_JPEG | V4LCONTROL_WANTS_WB, 1500 },
{ 0x06f8, 0x3009, 0, NULL, NULL,
V4LCONTROL_ROTATED_90_JPEG | V4LCONTROL_WANTS_WB, 1500 },
+ { 0x06f8, 0x301b, 0, NULL, NULL,
+ V4LCONTROL_ROTATED_90_JPEG | V4LCONTROL_WANTS_WB, 1500 },
{ 0x145f, 0x013c, 0, NULL, NULL,
V4LCONTROL_ROTATED_90_JPEG | V4LCONTROL_WANTS_WB, 1500 },
/* Pac7311 based devices */
--
1.7.9.3

542
0004-libv4lconvert-Use-bytesperline-instead-of-width.patch Normal file
View File

@ -0,0 +1,542 @@
From 31d2b0b0e40c6c92984d5077bb1a324729c71e7d Mon Sep 17 00:00:00 2001
From: Robert Abel <abel@uni-bielefeld.de>
Date: Sat, 25 Feb 2012 18:12:38 +0100
Subject: [PATCH 4/5] libv4lconvert: Use bytesperline instead of width
Basically, I found that libv4l and its conversion functions usually
choose to ignore v4l2_pix_format.bytesperline, which seems to work out
most of the time.
I'm currently working with the mt9v032 camera on a Gumstix Overo board.
The mt9v032's driver pads output lines to 768 pixels, giving 0x900 bytes
per line. All code in bayer.c (the camera uses raw bayer pattern) is
written to assume bytesperline = width and thus everything goes horribly
wrong.
Anyway, the patch for bayer => rgb as well as bayer => yuv is attached.
Basically, every time where width was assumed to be the offset to the
neighboring pixel below, now step is used.
Signed-off-by: Gregor Jasny <gjasny@googlemail.com>
---
lib/libv4lconvert/bayer.c | 219 ++++++++++++++++----------------
lib/libv4lconvert/libv4lconvert-priv.h | 6 +-
lib/libv4lconvert/libv4lconvert.c | 9 +-
3 files changed, 119 insertions(+), 115 deletions(-)
diff --git a/lib/libv4lconvert/bayer.c b/lib/libv4lconvert/bayer.c
index 924b8d4..d22db68 100644
--- a/lib/libv4lconvert/bayer.c
+++ b/lib/libv4lconvert/bayer.c
@@ -44,7 +44,7 @@
/* inspired by OpenCV's Bayer decoding */
static void v4lconvert_border_bayer_line_to_bgr24(
const unsigned char *bayer, const unsigned char *adjacent_bayer,
- unsigned char *bgr, int width, int start_with_green, int blue_line)
+ unsigned char *bgr, int width, const int start_with_green, const int blue_line)
{
int t0, t1;
@@ -164,11 +164,11 @@ static void v4lconvert_border_bayer_line_to_bgr24(
/* From libdc1394, which on turn was based on OpenCV's Bayer decoding */
static void bayer_to_rgbbgr24(const unsigned char *bayer,
- unsigned char *bgr, int width, int height, unsigned int pixfmt,
+ unsigned char *bgr, int width, int height, const unsigned int stride, unsigned int pixfmt,
int start_with_green, int blue_line)
{
/* render the first line */
- v4lconvert_border_bayer_line_to_bgr24(bayer, bayer + width, bgr, width,
+ v4lconvert_border_bayer_line_to_bgr24(bayer, bayer + stride, bgr, width,
start_with_green, blue_line);
bgr += width * 3;
@@ -179,139 +179,141 @@ static void bayer_to_rgbbgr24(const unsigned char *bayer,
const unsigned char *bayer_end = bayer + (width - 2);
if (start_with_green) {
- /* OpenCV has a bug in the next line, which was
- t0 = (bayer[0] + bayer[width * 2] + 1) >> 1; */
- t0 = (bayer[1] + bayer[width * 2 + 1] + 1) >> 1;
+
+ t0 = (bayer[1] + bayer[stride * 2 + 1] + 1) >> 1;
/* Write first pixel */
- t1 = (bayer[0] + bayer[width * 2] + bayer[width + 1] + 1) / 3;
+ t1 = (bayer[0] + bayer[stride * 2] + bayer[stride + 1] + 1) / 3;
if (blue_line) {
*bgr++ = t0;
*bgr++ = t1;
- *bgr++ = bayer[width];
+ *bgr++ = bayer[stride];
} else {
- *bgr++ = bayer[width];
+ *bgr++ = bayer[stride];
*bgr++ = t1;
*bgr++ = t0;
}
/* Write second pixel */
- t1 = (bayer[width] + bayer[width + 2] + 1) >> 1;
+ t1 = (bayer[stride] + bayer[stride + 2] + 1) >> 1;
if (blue_line) {
*bgr++ = t0;
- *bgr++ = bayer[width + 1];
+ *bgr++ = bayer[stride + 1];
*bgr++ = t1;
} else {
*bgr++ = t1;
- *bgr++ = bayer[width + 1];
+ *bgr++ = bayer[stride + 1];
*bgr++ = t0;
}
bayer++;
} else {
/* Write first pixel */
- t0 = (bayer[0] + bayer[width * 2] + 1) >> 1;
+ t0 = (bayer[0] + bayer[stride * 2] + 1) >> 1;
if (blue_line) {
*bgr++ = t0;
- *bgr++ = bayer[width];
- *bgr++ = bayer[width + 1];
+ *bgr++ = bayer[stride];
+ *bgr++ = bayer[stride + 1];
} else {
- *bgr++ = bayer[width + 1];
- *bgr++ = bayer[width];
+ *bgr++ = bayer[stride + 1];
+ *bgr++ = bayer[stride];
*bgr++ = t0;
}
}
if (blue_line) {
for (; bayer <= bayer_end - 2; bayer += 2) {
- t0 = (bayer[0] + bayer[2] + bayer[width * 2] +
- bayer[width * 2 + 2] + 2) >> 2;
- t1 = (bayer[1] + bayer[width] + bayer[width + 2] +
- bayer[width * 2 + 1] + 2) >> 2;
+ t0 = (bayer[0] + bayer[2] + bayer[stride * 2] +
+ bayer[stride * 2 + 2] + 2) >> 2;
+ t1 = (bayer[1] + bayer[stride] + bayer[stride + 2] +
+ bayer[stride * 2 + 1] + 2) >> 2;
*bgr++ = t0;
*bgr++ = t1;
- *bgr++ = bayer[width + 1];
+ *bgr++ = bayer[stride + 1];
- t0 = (bayer[2] + bayer[width * 2 + 2] + 1) >> 1;
- t1 = (bayer[width + 1] + bayer[width + 3] + 1) >> 1;
+ t0 = (bayer[2] + bayer[stride * 2 + 2] + 1) >> 1;
+ t1 = (bayer[stride + 1] + bayer[stride + 3] + 1) >> 1;
*bgr++ = t0;
- *bgr++ = bayer[width + 2];
+ *bgr++ = bayer[stride + 2];
*bgr++ = t1;
}
} else {
for (; bayer <= bayer_end - 2; bayer += 2) {
- t0 = (bayer[0] + bayer[2] + bayer[width * 2] +
- bayer[width * 2 + 2] + 2) >> 2;
- t1 = (bayer[1] + bayer[width] + bayer[width + 2] +
- bayer[width * 2 + 1] + 2) >> 2;
- *bgr++ = bayer[width + 1];
+ t0 = (bayer[0] + bayer[2] + bayer[stride * 2] +
+ bayer[stride * 2 + 2] + 2) >> 2;
+ t1 = (bayer[1] + bayer[stride] + bayer[stride + 2] +
+ bayer[stride * 2 + 1] + 2) >> 2;
+ *bgr++ = bayer[stride + 1];
*bgr++ = t1;
*bgr++ = t0;
- t0 = (bayer[2] + bayer[width * 2 + 2] + 1) >> 1;
- t1 = (bayer[width + 1] + bayer[width + 3] + 1) >> 1;
+ t0 = (bayer[2] + bayer[stride * 2 + 2] + 1) >> 1;
+ t1 = (bayer[stride + 1] + bayer[stride + 3] + 1) >> 1;
*bgr++ = t1;
- *bgr++ = bayer[width + 2];
+ *bgr++ = bayer[stride + 2];
*bgr++ = t0;
}
}
if (bayer < bayer_end) {
/* write second to last pixel */
- t0 = (bayer[0] + bayer[2] + bayer[width * 2] +
- bayer[width * 2 + 2] + 2) >> 2;
- t1 = (bayer[1] + bayer[width] + bayer[width + 2] +
- bayer[width * 2 + 1] + 2) >> 2;
+ t0 = (bayer[0] + bayer[2] + bayer[stride * 2] +
+ bayer[stride * 2 + 2] + 2) >> 2;
+ t1 = (bayer[1] + bayer[stride] + bayer[stride + 2] +
+ bayer[stride * 2 + 1] + 2) >> 2;
if (blue_line) {
*bgr++ = t0;
*bgr++ = t1;
- *bgr++ = bayer[width + 1];
+ *bgr++ = bayer[stride + 1];
} else {
- *bgr++ = bayer[width + 1];
+ *bgr++ = bayer[stride + 1];
*bgr++ = t1;
*bgr++ = t0;
}
/* write last pixel */
- t0 = (bayer[2] + bayer[width * 2 + 2] + 1) >> 1;
+ t0 = (bayer[2] + bayer[stride * 2 + 2] + 1) >> 1;
if (blue_line) {
*bgr++ = t0;
- *bgr++ = bayer[width + 2];
- *bgr++ = bayer[width + 1];
+ *bgr++ = bayer[stride + 2];
+ *bgr++ = bayer[stride + 1];
} else {
- *bgr++ = bayer[width + 1];
- *bgr++ = bayer[width + 2];
+ *bgr++ = bayer[stride + 1];
+ *bgr++ = bayer[stride + 2];
*bgr++ = t0;
}
+
bayer++;
+
} else {
/* write last pixel */
- t0 = (bayer[0] + bayer[width * 2] + 1) >> 1;
- t1 = (bayer[1] + bayer[width * 2 + 1] + bayer[width] + 1) / 3;
+ t0 = (bayer[0] + bayer[stride * 2] + 1) >> 1;
+ t1 = (bayer[1] + bayer[stride * 2 + 1] + bayer[stride] + 1) / 3;
if (blue_line) {
*bgr++ = t0;
*bgr++ = t1;
- *bgr++ = bayer[width + 1];
+ *bgr++ = bayer[stride + 1];
} else {
- *bgr++ = bayer[width + 1];
+ *bgr++ = bayer[stride + 1];
*bgr++ = t1;
*bgr++ = t0;
}
+
}
- /* skip 2 border pixels */
- bayer += 2;
+ /* skip 2 border pixels and padding */
+ bayer += (stride - width) + 2;
blue_line = !blue_line;
start_with_green = !start_with_green;
}
/* render the last line */
- v4lconvert_border_bayer_line_to_bgr24(bayer + width, bayer, bgr, width,
+ v4lconvert_border_bayer_line_to_bgr24(bayer + stride, bayer, bgr, width,
!start_with_green, !blue_line);
}
void v4lconvert_bayer_to_rgb24(const unsigned char *bayer,
- unsigned char *bgr, int width, int height, unsigned int pixfmt)
+ unsigned char *bgr, int width, int height, const unsigned int stride, unsigned int pixfmt)
{
- bayer_to_rgbbgr24(bayer, bgr, width, height, pixfmt,
+ bayer_to_rgbbgr24(bayer, bgr, width, height, stride, pixfmt,
pixfmt == V4L2_PIX_FMT_SGBRG8 /* start with green */
|| pixfmt == V4L2_PIX_FMT_SGRBG8,
pixfmt != V4L2_PIX_FMT_SBGGR8 /* blue line */
@@ -319,9 +321,9 @@ void v4lconvert_bayer_to_rgb24(const unsigned char *bayer,
}
void v4lconvert_bayer_to_bgr24(const unsigned char *bayer,
- unsigned char *bgr, int width, int height, unsigned int pixfmt)
+ unsigned char *bgr, int width, int height, const unsigned int stride, unsigned int pixfmt)
{
- bayer_to_rgbbgr24(bayer, bgr, width, height, pixfmt,
+ bayer_to_rgbbgr24(bayer, bgr, width, height, stride, pixfmt,
pixfmt == V4L2_PIX_FMT_SGBRG8 /* start with green */
|| pixfmt == V4L2_PIX_FMT_SGRBG8,
pixfmt == V4L2_PIX_FMT_SBGGR8 /* blue line */
@@ -428,7 +430,7 @@ static void v4lconvert_border_bayer_line_to_y(
}
void v4lconvert_bayer_to_yuv420(const unsigned char *bayer, unsigned char *yuv,
- int width, int height, unsigned int src_pixfmt, int yvu)
+ int width, int height, const unsigned int stride, unsigned int src_pixfmt, int yvu)
{
int blue_line = 0, start_with_green = 0, x, y;
unsigned char *ydst = yuv;
@@ -451,12 +453,12 @@ void v4lconvert_bayer_to_yuv420(const unsigned char *bayer, unsigned char *yuv,
b = bayer[x];
g = bayer[x + 1];
- g += bayer[x + width];
- r = bayer[x + width + 1];
+ g += bayer[x + stride];
+ r = bayer[x + stride + 1];
*udst++ = (-4878 * r - 4789 * g + 14456 * b + 4210688) >> 15;
*vdst++ = (14456 * r - 6052 * g - 2351 * b + 4210688) >> 15;
}
- bayer += 2 * width;
+ bayer += 2 * stride;
}
blue_line = 1;
break;
@@ -468,12 +470,12 @@ void v4lconvert_bayer_to_yuv420(const unsigned char *bayer, unsigned char *yuv,
r = bayer[x];
g = bayer[x + 1];
- g += bayer[x + width];
- b = bayer[x + width + 1];
+ g += bayer[x + stride];
+ b = bayer[x + stride + 1];
*udst++ = (-4878 * r - 4789 * g + 14456 * b + 4210688) >> 15;
*vdst++ = (14456 * r - 6052 * g - 2351 * b + 4210688) >> 15;
}
- bayer += 2 * width;
+ bayer += 2 * stride;
}
break;
@@ -484,12 +486,12 @@ void v4lconvert_bayer_to_yuv420(const unsigned char *bayer, unsigned char *yuv,
g = bayer[x];
b = bayer[x + 1];
- r = bayer[x + width];
- g += bayer[x + width + 1];
+ r = bayer[x + stride];
+ g += bayer[x + stride + 1];
*udst++ = (-4878 * r - 4789 * g + 14456 * b + 4210688) >> 15;
*vdst++ = (14456 * r - 6052 * g - 2351 * b + 4210688) >> 15;
}
- bayer += 2 * width;
+ bayer += 2 * stride;
}
blue_line = 1;
start_with_green = 1;
@@ -502,21 +504,22 @@ void v4lconvert_bayer_to_yuv420(const unsigned char *bayer, unsigned char *yuv,
g = bayer[x];
r = bayer[x + 1];
- b = bayer[x + width];
- g += bayer[x + width + 1];
+ b = bayer[x + stride];
+ g += bayer[x + stride + 1];
*udst++ = (-4878 * r - 4789 * g + 14456 * b + 4210688) >> 15;
*vdst++ = (14456 * r - 6052 * g - 2351 * b + 4210688) >> 15;
}
- bayer += 2 * width;
+ bayer += 2 * stride;
}
start_with_green = 1;
break;
}
- bayer -= width * height;
+ /* Point bayer back to start of frame */
+ bayer -= stride * height;
/* render the first line */
- v4lconvert_border_bayer_line_to_y(bayer, bayer + width, ydst, width,
+ v4lconvert_border_bayer_line_to_y(bayer, bayer + stride, ydst, width,
start_with_green, blue_line);
ydst += width;
@@ -527,104 +530,104 @@ void v4lconvert_bayer_to_yuv420(const unsigned char *bayer, unsigned char *yuv,
const unsigned char *bayer_end = bayer + (width - 2);
if (start_with_green) {
- t0 = bayer[1] + bayer[width * 2 + 1];
+ t0 = bayer[1] + bayer[stride * 2 + 1];
/* Write first pixel */
- t1 = bayer[0] + bayer[width * 2] + bayer[width + 1];
+ t1 = bayer[0] + bayer[stride * 2] + bayer[stride + 1];
if (blue_line)
- *ydst++ = (8453 * bayer[width] + 5516 * t1 +
+ *ydst++ = (8453 * bayer[stride] + 5516 * t1 +
1661 * t0 + 524288) >> 15;
else
*ydst++ = (4226 * t0 + 5516 * t1 +
- 3223 * bayer[width] + 524288) >> 15;
+ 3223 * bayer[stride] + 524288) >> 15;
/* Write second pixel */
- t1 = bayer[width] + bayer[width + 2];
+ t1 = bayer[stride] + bayer[stride + 2];
if (blue_line)
- *ydst++ = (4226 * t1 + 16594 * bayer[width + 1] +
+ *ydst++ = (4226 * t1 + 16594 * bayer[stride + 1] +
1611 * t0 + 524288) >> 15;
else
- *ydst++ = (4226 * t0 + 16594 * bayer[width + 1] +
+ *ydst++ = (4226 * t0 + 16594 * bayer[stride + 1] +
1611 * t1 + 524288) >> 15;
bayer++;
} else {
/* Write first pixel */
- t0 = bayer[0] + bayer[width * 2];
+ t0 = bayer[0] + bayer[stride * 2];
if (blue_line) {
- *ydst++ = (8453 * bayer[width + 1] + 16594 * bayer[width] +
+ *ydst++ = (8453 * bayer[stride + 1] + 16594 * bayer[stride] +
1661 * t0 + 524288) >> 15;
} else {
- *ydst++ = (4226 * t0 + 16594 * bayer[width] +
- 3223 * bayer[width + 1] + 524288) >> 15;
+ *ydst++ = (4226 * t0 + 16594 * bayer[stride] +
+ 3223 * bayer[stride + 1] + 524288) >> 15;
}
}
if (blue_line) {
for (; bayer <= bayer_end - 2; bayer += 2) {
- t0 = bayer[0] + bayer[2] + bayer[width * 2] + bayer[width * 2 + 2];
- t1 = bayer[1] + bayer[width] + bayer[width + 2] + bayer[width * 2 + 1];
- *ydst++ = (8453 * bayer[width + 1] + 4148 * t1 +
+ t0 = bayer[0] + bayer[2] + bayer[stride * 2] + bayer[stride * 2 + 2];
+ t1 = bayer[1] + bayer[stride] + bayer[stride + 2] + bayer[stride * 2 + 1];
+ *ydst++ = (8453 * bayer[stride + 1] + 4148 * t1 +
806 * t0 + 524288) >> 15;
- t0 = bayer[2] + bayer[width * 2 + 2];
- t1 = bayer[width + 1] + bayer[width + 3];
- *ydst++ = (4226 * t1 + 16594 * bayer[width + 2] +
+ t0 = bayer[2] + bayer[stride * 2 + 2];
+ t1 = bayer[stride + 1] + bayer[stride + 3];
+ *ydst++ = (4226 * t1 + 16594 * bayer[stride + 2] +
1611 * t0 + 524288) >> 15;
}
} else {
for (; bayer <= bayer_end - 2; bayer += 2) {
- t0 = bayer[0] + bayer[2] + bayer[width * 2] + bayer[width * 2 + 2];
- t1 = bayer[1] + bayer[width] + bayer[width + 2] + bayer[width * 2 + 1];
+ t0 = bayer[0] + bayer[2] + bayer[stride * 2] + bayer[stride * 2 + 2];
+ t1 = bayer[1] + bayer[stride] + bayer[stride + 2] + bayer[stride * 2 + 1];
*ydst++ = (2113 * t0 + 4148 * t1 +
- 3223 * bayer[width + 1] + 524288) >> 15;
+ 3223 * bayer[stride + 1] + 524288) >> 15;
- t0 = bayer[2] + bayer[width * 2 + 2];
- t1 = bayer[width + 1] + bayer[width + 3];
- *ydst++ = (4226 * t0 + 16594 * bayer[width + 2] +
+ t0 = bayer[2] + bayer[stride * 2 + 2];
+ t1 = bayer[stride + 1] + bayer[stride + 3];
+ *ydst++ = (4226 * t0 + 16594 * bayer[stride + 2] +
1611 * t1 + 524288) >> 15;
}
}
if (bayer < bayer_end) {
/* Write second to last pixel */
- t0 = bayer[0] + bayer[2] + bayer[width * 2] + bayer[width * 2 + 2];
- t1 = bayer[1] + bayer[width] + bayer[width + 2] + bayer[width * 2 + 1];
+ t0 = bayer[0] + bayer[2] + bayer[stride * 2] + bayer[stride * 2 + 2];
+ t1 = bayer[1] + bayer[stride] + bayer[stride + 2] + bayer[stride * 2 + 1];
if (blue_line)
- *ydst++ = (8453 * bayer[width + 1] + 4148 * t1 +
+ *ydst++ = (8453 * bayer[stride + 1] + 4148 * t1 +
806 * t0 + 524288) >> 15;
else
*ydst++ = (2113 * t0 + 4148 * t1 +
- 3223 * bayer[width + 1] + 524288) >> 15;
+ 3223 * bayer[stride + 1] + 524288) >> 15;
/* write last pixel */
- t0 = bayer[2] + bayer[width * 2 + 2];
+ t0 = bayer[2] + bayer[stride * 2 + 2];
if (blue_line) {
- *ydst++ = (8453 * bayer[width + 1] + 16594 * bayer[width + 2] +
+ *ydst++ = (8453 * bayer[stride + 1] + 16594 * bayer[stride + 2] +
1661 * t0 + 524288) >> 15;
} else {
- *ydst++ = (4226 * t0 + 16594 * bayer[width + 2] +
- 3223 * bayer[width + 1] + 524288) >> 15;
+ *ydst++ = (4226 * t0 + 16594 * bayer[stride + 2] +
+ 3223 * bayer[stride + 1] + 524288) >> 15;
}
bayer++;
} else {
/* write last pixel */
- t0 = bayer[0] + bayer[width * 2];
- t1 = bayer[1] + bayer[width * 2 + 1] + bayer[width];
+ t0 = bayer[0] + bayer[stride * 2];
+ t1 = bayer[1] + bayer[stride * 2 + 1] + bayer[stride];
if (blue_line)
- *ydst++ = (8453 * bayer[width + 1] + 5516 * t1 +
+ *ydst++ = (8453 * bayer[stride + 1] + 5516 * t1 +
1661 * t0 + 524288) >> 15;
else
*ydst++ = (4226 * t0 + 5516 * t1 +
- 3223 * bayer[width + 1] + 524288) >> 15;
+ 3223 * bayer[stride + 1] + 524288) >> 15;
}
- /* skip 2 border pixels */
- bayer += 2;
+ /* skip 2 border pixels and padding */
+ bayer += (stride - width) + 2;
blue_line = !blue_line;
start_with_green = !start_with_green;
}
/* render the last line */
- v4lconvert_border_bayer_line_to_y(bayer + width, bayer, ydst, width,
+ v4lconvert_border_bayer_line_to_y(bayer + stride, bayer, ydst, width,
!start_with_green, !blue_line);
}
diff --git a/lib/libv4lconvert/libv4lconvert-priv.h b/lib/libv4lconvert/libv4lconvert-priv.h
index 705a26d..5b76767 100644
--- a/lib/libv4lconvert/libv4lconvert-priv.h
+++ b/lib/libv4lconvert/libv4lconvert-priv.h
@@ -230,13 +230,13 @@ void v4lconvert_decode_stv0680(const unsigned char *src, unsigned char *dst,
int width, int height);
void v4lconvert_bayer_to_rgb24(const unsigned char *bayer,
- unsigned char *rgb, int width, int height, unsigned int pixfmt);
+ unsigned char *rgb, int width, int height, const unsigned int stride, unsigned int pixfmt);
void v4lconvert_bayer_to_bgr24(const unsigned char *bayer,
- unsigned char *rgb, int width, int height, unsigned int pixfmt);
+ unsigned char *rgb, int width, int height, const unsigned int stride, unsigned int pixfmt);
void v4lconvert_bayer_to_yuv420(const unsigned char *bayer, unsigned char *yuv,
- int width, int height, unsigned int src_pixfmt, int yvu);
+ int width, int height, const unsigned int stride, unsigned int src_pixfmt, int yvu);
void v4lconvert_hm12_to_rgb24(const unsigned char *src,
unsigned char *dst, int width, int height);
diff --git a/lib/libv4lconvert/libv4lconvert.c b/lib/libv4lconvert/libv4lconvert.c
index 246e2c9..f44f9ff 100644
--- a/lib/libv4lconvert/libv4lconvert.c
+++ b/lib/libv4lconvert/libv4lconvert.c
@@ -629,6 +629,7 @@ static int v4lconvert_convert_pixfmt(struct v4lconvert_data *data,
unsigned int src_pix_fmt = fmt->fmt.pix.pixelformat;
unsigned int width = fmt->fmt.pix.width;
unsigned int height = fmt->fmt.pix.height;
+ unsigned int bytesperline = fmt->fmt.pix.bytesperline;
switch (src_pix_fmt) {
/* JPG and variants */
@@ -858,16 +859,16 @@ static int v4lconvert_convert_pixfmt(struct v4lconvert_data *data,
case V4L2_PIX_FMT_SRGGB8:
switch (dest_pix_fmt) {
case V4L2_PIX_FMT_RGB24:
- v4lconvert_bayer_to_rgb24(src, dest, width, height, src_pix_fmt);
+ v4lconvert_bayer_to_rgb24(src, dest, width, height, bytesperline, src_pix_fmt);
break;
case V4L2_PIX_FMT_BGR24:
- v4lconvert_bayer_to_bgr24(src, dest, width, height, src_pix_fmt);
+ v4lconvert_bayer_to_bgr24(src, dest, width, height, bytesperline, src_pix_fmt);
break;
case V4L2_PIX_FMT_YUV420:
- v4lconvert_bayer_to_yuv420(src, dest, width, height, src_pix_fmt, 0);
+ v4lconvert_bayer_to_yuv420(src, dest, width, height, bytesperline, src_pix_fmt, 0);
break;
case V4L2_PIX_FMT_YVU420:
- v4lconvert_bayer_to_yuv420(src, dest, width, height, src_pix_fmt, 1);
+ v4lconvert_bayer_to_yuv420(src, dest, width, height, bytesperline, src_pix_fmt, 1);
break;
}
if (src_size < (width * height)) {
--
1.7.9.3

66
0005-Documentation-spelling-fixes.patch Normal file
View File

@ -0,0 +1,66 @@
From 34da390c9b260fc94a1bf6a5dc9a574d09f6e6d1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ville=20Skytt=C3=A4?= <ville.skytta@iki.fi>
Date: Mon, 9 Apr 2012 09:03:53 +0200
Subject: [PATCH 5/5] Documentation spelling fixes
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
---
README.lib | 8 ++++----
README.lib-multi-threading | 2 +-
2 files changed, 5 insertions(+), 5 deletions(-)
diff --git a/README.lib b/README.lib
index 09638d4..bdafd6d 100644
--- a/README.lib
+++ b/README.lib
@@ -4,7 +4,7 @@ Introduction
libv4l is a collection of libraries which adds a thin abstraction layer on
top of video4linux2 devices. The purpose of this (thin) layer is to make it
easy for application writers to support a wide variety of devices without
-having to write seperate code for different devices in the same class.
+having to write separate code for different devices in the same class.
All libv4l components are licensed under the GNU Lesser General Public
License version 2 or (at your option) any later version.
@@ -121,7 +121,7 @@ would need to be extended with many more often chip dependent formats, like
the bayer compression used by the spca561 and the (different) compression used
by the pac207 and the (again different) compression used by the sn9c102. Adding
support for all these formats should not be done at the application level, as
-then it needs to be written for each application seperately. Licensing issues
+then it needs to be written for each application separately. Licensing issues
with the decompressors will then also become a problem as just cut and pasting
from one application to another is bound to hit license incompatibilities.
@@ -156,14 +156,14 @@ Q: Why should I use libv4l2 in my app instead of direct device access
combined with libv4lconvert?
A: libv4l2 is mainly meant for quickly and easily adding support for more
pixelformats to existing v4l2 applications. So if you feel better directly
-accessing the device in combination with libv4lconvert thats fine too.
+accessing the device in combination with libv4lconvert that's fine too.
Notice that libv4l2 also does emulation of the read() call on devices which
do not support it in the driver. In the background this uses mmap buffers
(even on devices which do support the read call). This mmap gives libv4lconvert
zero-copy access to the captured frame, and then it can write the converted
data directly to the buffer the application provided to v4l2_read(). Thus
-another reason to use liv4l2 is to get the no memcpy advantage of the mmap
+another reason to use libv4l2 is to get the no memcpy advantage of the mmap
capture method combined with the simplicity of making a simple read() call.
diff --git a/README.lib-multi-threading b/README.lib-multi-threading
index 93b393c..e444dd4 100644
--- a/README.lib-multi-threading
+++ b/README.lib-multi-threading
@@ -1,7 +1,7 @@
libv4lconvert is not safe for using one convert instance as returned by
v4lconvert_create from multiple threads, if you want to use one v4lconvert
instance from multiple threads you must provide your own locking and make
-sure no simultanious calls are made.
+sure no simultaneous calls are made.
libv4l1 and libv4l2 are safe for multithread use *under* *the* *following*
*conditions* :
--
1.7.9.3

2
sources
View File

@ -1 +1 @@
037bec9f68cfb0b84bcccb00d30e429b v4l-utils-0.8.5.tar.bz2
d3506785ae022b6a37b986c66015bea3 v4l-utils-0.8.7.tar.bz2

20
v4l-utils.spec
View File

@ -1,12 +1,18 @@
Name: v4l-utils
Version: 0.8.5
Release: 2%{?dist}
Version: 0.8.7
Release: 1%{?dist}
Summary: Utilities for video4linux and DVB devices
Group: Applications/System
# ir-keytable and v4l2-sysfs-path are GPLv2 only
License: GPLv2+ and GPLv2
URL: http://www.linuxtv.org/downloads/v4l-utils/
Source0: http://linuxtv.org/downloads/v4l-utils/v4l-utils-%{version}.tar.bz2
# Bugfixes from upstream git, these can all be dropped with the next release
Patch1: 0001-libv4lconver-tinyjpeg-Fix-out-of-bounds-array-usage.patch
Patch2: 0002-tinyjpeg-Better-luminance-quantization-table-for-Pix.patch
Patch3: 0003-libv4lconver-Add-06f8-301b-pac7302-based-cam-to-the-.patch
Patch4: 0004-libv4lconvert-Use-bytesperline-instead-of-width.patch
Patch5: 0005-Documentation-spelling-fixes.patch
BuildRequires: libjpeg-devel qt4-devel kernel-headers desktop-file-utils
# For /lib/udev/rules.d ownership
Requires: udev
@ -77,6 +83,11 @@ developing applications that use libv4l.
%prep
%setup -q
%patch1 -p1
%patch2 -p1
%patch3 -p1
%patch4 -p1
%patch5 -p1
%build
@ -114,6 +125,7 @@ gtk-update-icon-cache %{_datadir}/icons/hicolor &>/dev/null || :
%config(noreplace) %{_sysconfdir}/rc_maps.cfg
/lib/udev/rules.d/70-infrared.rules
%{_bindir}/cx18-ctl
%{_bindir}/dvb*
%{_bindir}/ir-keytable
%{_bindir}/ivtv-ctl
%{_bindir}/v4l2-ctl
@ -149,6 +161,10 @@ gtk-update-icon-cache %{_datadir}/icons/hicolor &>/dev/null || :
%changelog
* Mon Apr 9 2012 Hans de Goede <hdegoede@redhat.com> - 0.8.7-1
- New upstream release 0.8.7
- Fixes rhbz#807656
* Sat Jan 14 2012 Fedora Release Engineering <rel-eng@lists.fedoraproject.org> - 0.8.5-2
- Rebuilt for https://fedoraproject.org/wiki/Fedora_17_Mass_Rebuild