diff --git a/.gitignore b/.gitignore index 9106b07..a9a1727 100644 --- a/.gitignore +++ b/.gitignore @@ -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 diff --git a/0001-libv4lconver-tinyjpeg-Fix-out-of-bounds-array-usage.patch b/0001-libv4lconver-tinyjpeg-Fix-out-of-bounds-array-usage.patch new file mode 100644 index 0000000..7ead163 --- /dev/null +++ b/0001-libv4lconver-tinyjpeg-Fix-out-of-bounds-array-usage.patch @@ -0,0 +1,26 @@ +From 3df030fe82a31556695dc147e2a28288bbe12cf8 Mon Sep 17 00:00:00 2001 +From: Hans de Goede +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 +--- + 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 + diff --git a/0002-tinyjpeg-Better-luminance-quantization-table-for-Pix.patch b/0002-tinyjpeg-Better-luminance-quantization-table-for-Pix.patch new file mode 100644 index 0000000..c44d678 --- /dev/null +++ b/0002-tinyjpeg-Better-luminance-quantization-table-for-Pix.patch @@ -0,0 +1,51 @@ +From e186777daeaa717b7d919e932f7d3be10156d572 Mon Sep 17 00:00:00 2001 +From: Jean-Francois Moine +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 +--- + 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 + diff --git a/0003-libv4lconver-Add-06f8-301b-pac7302-based-cam-to-the-.patch b/0003-libv4lconver-Add-06f8-301b-pac7302-based-cam-to-the-.patch new file mode 100644 index 0000000..cfa274b --- /dev/null +++ b/0003-libv4lconver-Add-06f8-301b-pac7302-based-cam-to-the-.patch @@ -0,0 +1,28 @@ +From e681916636373959c39b3f13a44e145106119b68 Mon Sep 17 00:00:00 2001 +From: Hans de Goede +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 +Signed-off-by: Hans de Goede +--- + 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 + diff --git a/0004-libv4lconvert-Use-bytesperline-instead-of-width.patch b/0004-libv4lconvert-Use-bytesperline-instead-of-width.patch new file mode 100644 index 0000000..645ba85 --- /dev/null +++ b/0004-libv4lconvert-Use-bytesperline-instead-of-width.patch @@ -0,0 +1,542 @@ +From 31d2b0b0e40c6c92984d5077bb1a324729c71e7d Mon Sep 17 00:00:00 2001 +From: Robert Abel +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 +--- + 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 + diff --git a/0005-Documentation-spelling-fixes.patch b/0005-Documentation-spelling-fixes.patch new file mode 100644 index 0000000..a1b94d8 --- /dev/null +++ b/0005-Documentation-spelling-fixes.patch @@ -0,0 +1,66 @@ +From 34da390c9b260fc94a1bf6a5dc9a574d09f6e6d1 Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?Ville=20Skytt=C3=A4?= +Date: Mon, 9 Apr 2012 09:03:53 +0200 +Subject: [PATCH 5/5] Documentation spelling fixes + +Signed-off-by: Hans de Goede +--- + 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 + diff --git a/sources b/sources index 0e541f8..c67f8f4 100644 --- a/sources +++ b/sources @@ -1 +1 @@ -037bec9f68cfb0b84bcccb00d30e429b v4l-utils-0.8.5.tar.bz2 +d3506785ae022b6a37b986c66015bea3 v4l-utils-0.8.7.tar.bz2 diff --git a/v4l-utils.spec b/v4l-utils.spec index 2a2ff19..285383f 100644 --- a/v4l-utils.spec +++ b/v4l-utils.spec @@ -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 - 0.8.7-1 +- New upstream release 0.8.7 +- Fixes rhbz#807656 + * Sat Jan 14 2012 Fedora Release Engineering - 0.8.5-2 - Rebuilt for https://fedoraproject.org/wiki/Fedora_17_Mass_Rebuild