~martijnbraam/public-inbox

This thread contains a patchset. You're looking at the original emails, but you may wish to use the patch review UI. Review patch
4 4

[PATCH megapixels 1/2] main: Correctly configure mbus for 8-bits Bayer pix fmts

~kholk
Details
Message ID
<160364446750.31186.7957363702037364238-0@git.sr.ht>
DKIM signature
missing
Download raw message
Patch: +3 -0
From: AngeloGioacchino Del Regno <angelogioacchino.delregno@somainline.org>

The mbus has to be configured correctly for each of the pixel
formats in order to send the right indications to V4L2.

Signed-off-by: AngeloGioacchino Del Regno <angelogioacchino.delregno@somainline.org>
---
 main.c | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/main.c b/main.c
index 1de0a40..f85a699 100644
--- a/main.c
+++ b/main.c
@@ -937,13 +937,16 @@ config_ini_handler(void *user, const char *section, const char *name,
		} else if (strcmp(name, "fmt") == 0) {
			if (strcmp(value, "RGGB8") == 0) {
				cc->fmt = V4L2_PIX_FMT_SRGGB8;
				cc->mbus = MEDIA_BUS_FMT_SRGGB8_1X8;
			} else if (strcmp(value, "BGGR8") == 0) {
				cc->fmt = V4L2_PIX_FMT_SBGGR8;
				cc->mbus = MEDIA_BUS_FMT_SBGGR8_1X8;
			} else if (strcmp(value, "GRBG8") == 0) {
				cc->fmt = V4L2_PIX_FMT_SGRBG8;
				cc->mbus = MEDIA_BUS_FMT_SGRBG8_1X8;
			} else if (strcmp(value, "GBRG8") == 0) {
				cc->fmt = V4L2_PIX_FMT_SGBRG8;
				cc->mbus = MEDIA_BUS_FMT_SGBRG8_1X8;
			} else {
				g_printerr("Unsupported pixelformat %s\n", value);
				exit(1);
-- 
2.26.2

[PATCH megapixels 2/2] megapixels: Implement quick-debayering all Bayer 8-bits pixel formats

~kholk
Details
Message ID
<160364446750.31186.7957363702037364238-1@git.sr.ht>
In-Reply-To
<160364446750.31186.7957363702037364238-0@git.sr.ht> (view parent)
DKIM signature
missing
Download raw message
Patch: +75 -36
From: AngeloGioacchino Del Regno <angelogioacchino.delregno@somainline.org>

This application was supporting only debayering of BGGR8 streams:
this is an issue on cameras that are outputting a different format.

Implement quick-debayering of all Bayer 8-bits pixfmts in order to
solve wrong tint issues on many, many camera sensors.

This was tested on a Sony Exmor-RS IMX300 sensor.

Signed-off-by: AngeloGioacchino Del Regno <angelogioacchino.delregno@somainline.org>
---
 main.c         |  8 +++--
 quickdebayer.c | 98 +++++++++++++++++++++++++++++++++-----------------
 quickdebayer.h |  5 +--
 3 files changed, 75 insertions(+), 36 deletions(-)

diff --git a/main.c b/main.c
index f85a699..d80051b 100644
--- a/main.c
+++ b/main.c
@@ -610,7 +610,9 @@ process_image(const int *p, int size)
		}
		pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, FALSE, 8, current.width / (skip*2), current.height / (skip*2));
		pixels = gdk_pixbuf_get_pixels(pixbuf);
		quick_debayer_bggr8((const uint8_t *)p, pixels, current.width, current.height, skip, current.blacklevel);
		quick_debayer((const uint8_t *)p, pixels, current.fmt,
			       current.width, current.height, skip,
			       current.blacklevel);

		if (current.rotate == 0) {
			pixbufrot = pixbuf;
@@ -765,7 +767,9 @@ process_image(const int *p, int size)
			// Update the thumbnail if this is the last frame
			pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, FALSE, 8, current.width / (skip*2), current.height / (skip*2));
			pixels = gdk_pixbuf_get_pixels(pixbuf);
			quick_debayer_bggr8((const uint8_t *)p, pixels, current.width, current.height, skip, current.blacklevel);
			quick_debayer((const uint8_t *)p, pixels, current.fmt,
				      current.width, current.height, skip,
				      current.blacklevel);

			if (current.rotate == 0) {
				pixbufrot = pixbuf;
diff --git a/quickdebayer.c b/quickdebayer.c
index a9c322f..7b4f8c7 100644
--- a/quickdebayer.c
+++ b/quickdebayer.c
@@ -1,43 +1,77 @@
/*
 * Fast but bad debayer method that scales and rotates by skipping source
 * pixels and doesn't interpolate any values at all
 */

#include <linux/videodev2.h>
#include "quickdebayer.h"

// Fast but bad debayer method that scales and rotates by skipping source pixels and
// doesn't interpolate any values at all
/* Linear -> sRGB lookup table */
static const int srgb[] = {
	0, 12, 21, 28, 33, 38, 42, 46, 49, 52, 55, 58, 61, 63, 66, 68, 70,
	73, 75, 77, 79, 81, 82, 84, 86, 88, 89, 91, 93, 94, 96, 97, 99, 100,
	102, 103, 104, 106, 107, 109, 110, 111, 112, 114, 115, 116, 117, 118,
	120, 121, 122, 123, 124, 125, 126, 127, 129, 130, 131, 132, 133, 134,
	135, 136, 137, 138, 139, 140, 141, 142, 142, 143, 144, 145, 146, 147,
	148, 149, 150, 151, 151, 152, 153, 154, 155, 156, 157, 157, 158, 159,
	160, 161, 161, 162, 163, 164, 165, 165, 166, 167, 168, 168, 169, 170,
	171, 171, 172, 173, 174, 174, 175, 176, 176, 177, 178, 179, 179, 180,
	181, 181, 182, 183, 183, 184, 185, 185, 186, 187, 187, 188, 189, 189,
	190, 191, 191, 192, 193, 193, 194, 194, 195, 196, 196, 197, 197, 198,
	199, 199, 200, 201, 201, 202, 202, 203, 204, 204, 205, 205, 206, 206,
	207, 208, 208, 209, 209, 210, 210, 211, 212, 212, 213, 213, 214, 214,
	215, 215, 216, 217, 217, 218, 218, 219, 219, 220, 220, 221, 221, 222,
	222, 223, 223, 224, 224, 225, 226, 226, 227, 227, 228, 228, 229, 229,
	230, 230, 231, 231, 232, 232, 233, 233, 234, 234, 235, 235, 236, 236,
	237, 237, 237, 238, 238, 239, 239, 240, 240, 241, 241, 242, 242, 243,
	243, 244, 244, 245, 245, 245, 246, 246, 247, 247, 248, 248, 249, 249,
	250, 250, 251, 251, 251, 252, 252, 253, 253, 254, 254, 255
};

static void quick_debayer_set_dst(uint8_t *dst, uint8_t p0, uint8_t p1,
				  uint8_t p2)
{
	dst[0] = p0;
	dst[1] = p1;
	dst[2] = p2;
}

void
quick_debayer_bggr8(const uint8_t *source, uint8_t *destination, int width, int height, int skip, int blacklevel)
void quick_debayer(const uint8_t *source, uint8_t *destination,
		   uint32_t pix_fmt, int width, int height, int skip,
		   int blacklevel)
{
	int byteskip = 2 * skip;
	int input_size = width * height;
	int output_size = (width/byteskip) * (height/byteskip);
	int i;
	int j=0;
	int i = 0, j = 0;
	int row_left = width;

	// Linear -> sRGB lookup table
	static int srgb[] = {
		0, 12, 21, 28, 33, 38, 42, 46, 49, 52, 55, 58, 61, 63, 66, 68, 70, 73, 75, 77, 79, 
		81, 82, 84, 86, 88, 89, 91, 93, 94, 96, 97, 99, 100, 102, 103, 104, 106, 107, 109,
		110, 111, 112, 114, 115, 116, 117, 118, 120, 121, 122, 123, 124, 125, 126, 127, 129,
		130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 142, 143, 144, 145,
		146, 147, 148, 149, 150, 151, 151, 152, 153, 154, 155, 156, 157, 157, 158, 159, 160,
		161, 161, 162, 163, 164, 165, 165, 166, 167, 168, 168, 169, 170, 171, 171, 172, 173,
		174, 174, 175, 176, 176, 177, 178, 179, 179, 180, 181, 181, 182, 183, 183, 184, 185,
		185, 186, 187, 187, 188, 189, 189, 190, 191, 191, 192, 193, 193, 194, 194, 195, 196,
		196, 197, 197, 198, 199, 199, 200, 201, 201, 202, 202, 203, 204, 204, 205, 205, 206,
		206, 207, 208, 208, 209, 209, 210, 210, 211, 212, 212, 213, 213, 214, 214, 215, 215,
		216, 217, 217, 218, 218, 219, 219, 220, 220, 221, 221, 222, 222, 223, 223, 224, 224,
		225, 226, 226, 227, 227, 228, 228, 229, 229, 230, 230, 231, 231, 232, 232, 233, 233,
		234, 234, 235, 235, 236, 236, 237, 237, 237, 238, 238, 239, 239, 240, 240, 241, 241,
		242, 242, 243, 243, 244, 244, 245, 245, 245, 246, 246, 247, 247, 248, 248, 249, 249,
		250, 250, 251, 251, 251, 252, 252, 253, 253, 254, 254, 255
	};
	do {
		uint8_t b0 = srgb[source[i] - blacklevel];
		uint8_t b1 = srgb[source[i + 1] - blacklevel];
		uint8_t b2 = srgb[source[i + width + 1] - blacklevel];

		switch (pix_fmt) {
			case V4L2_PIX_FMT_SBGGR8:
				quick_debayer_set_dst(&destination[j],
						      b2, b1, b0);
				break;
			case V4L2_PIX_FMT_SGBRG8:
				quick_debayer_set_dst(&destination[j],
						      b1, b2, b0);
				break;
			case V4L2_PIX_FMT_SGRBG8:
				quick_debayer_set_dst(&destination[j],
						      b1, b0, b2);
				break;
			case V4L2_PIX_FMT_SRGGB8:
				/* fall through */
			default:
				quick_debayer_set_dst(&destination[j],
						      b0, b1, b2);
				break;
		}
		j += 3;

	// B G
	// G R
	for(i=0;i<input_size;) {
		destination[j++] = srgb[source[i+width+1] - blacklevel];
		destination[j++] = srgb[source[i+1] - blacklevel];
		destination[j++] = srgb[source[i] - blacklevel];
		i = i + byteskip;
		row_left = row_left - byteskip;
		if(row_left < byteskip){
@@ -46,5 +80,5 @@ quick_debayer_bggr8(const uint8_t *source, uint8_t *destination, int width, int
			i = i + width;
			i = i + (width * 2 * (skip-1));
		}
	}
	} while (i < input_size);
}
diff --git a/quickdebayer.h b/quickdebayer.h
index 38a4327..b5a0aac 100644
--- a/quickdebayer.h
+++ b/quickdebayer.h
@@ -1,4 +1,5 @@
#include <stdint.h>

void quick_debayer_bggr8(const uint8_t *source, uint8_t *destination, int width, int height, int skip, int blacklevel);

void quick_debayer(const uint8_t *source, uint8_t *destination,
		   uint32_t pix_fmt, int width, int height, int skip,
		   int blacklevel);
-- 
2.26.2

[megapixels/patches] build failed

builds.sr.ht
Details
Message ID
<C6M4J7NCL74L.27RJW84R3JX4X@cirno2>
In-Reply-To
<160364446750.31186.7957363702037364238-1@git.sr.ht> (view parent)
DKIM signature
missing
Download raw message
megapixels/patches: FAILED in 35s

[main: Correctly configure mbus for 8-bits Bayer pix fmts][0] from [~kholk][1]

[0]: https://lists.sr.ht/~martijnbraam/public-inbox/patches/14512
[1]: mailto:angelogioacchino.delregno@somainline.org

✗ #327472 FAILED megapixels/patches/arch.yml   https://builds.sr.ht/~martijnbraam/job/327472
✗ #327471 FAILED megapixels/patches/alpine.yml https://builds.sr.ht/~martijnbraam/job/327471

Re: [PATCH megapixels 2/2] megapixels: Implement quick-debayering all Bayer 8-bits pixel formats

Details
Message ID
<CA+XnvuNYoGe3Lk=0OpDOK3ch6EjsVq_rAxKg540sFXr_gbVDZg@mail.gmail.com>
In-Reply-To
<160364446750.31186.7957363702037364238-1@git.sr.ht> (view parent)
DKIM signature
missing
Download raw message
Thanks!

This is cleaner than what I was planning, so far both cameras I tested
on could run on BGGR8 mode (with BGGR being the native pixel order on
the ov5640).

Op zo 25 okt. 2020 om 17:47 schreef ~kholk <kholk@git.sr.ht>:
>
> From: AngeloGioacchino Del Regno <angelogioacchino.delregno@somainline.org>
>
> This application was supporting only debayering of BGGR8 streams:
> this is an issue on cameras that are outputting a different format.
>
> Implement quick-debayering of all Bayer 8-bits pixfmts in order to
> solve wrong tint issues on many, many camera sensors.
>
> This was tested on a Sony Exmor-RS IMX300 sensor.
>
> Signed-off-by: AngeloGioacchino Del Regno <angelogioacchino.delregno@somainline.org>
> ---
>  main.c         |  8 +++--
>  quickdebayer.c | 98 +++++++++++++++++++++++++++++++++-----------------
>  quickdebayer.h |  5 +--
>  3 files changed, 75 insertions(+), 36 deletions(-)
>
> diff --git a/main.c b/main.c
> index f85a699..d80051b 100644
> --- a/main.c
> +++ b/main.c
> @@ -610,7 +610,9 @@ process_image(const int *p, int size)
>                 }
>                 pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, FALSE, 8, current.width / (skip*2), current.height / (skip*2));
>                 pixels = gdk_pixbuf_get_pixels(pixbuf);
> -               quick_debayer_bggr8((const uint8_t *)p, pixels, current.width, current.height, skip, current.blacklevel);
> +               quick_debayer((const uint8_t *)p, pixels, current.fmt,
> +                              current.width, current.height, skip,
> +                              current.blacklevel);
>
>                 if (current.rotate == 0) {
>                         pixbufrot = pixbuf;
> @@ -765,7 +767,9 @@ process_image(const int *p, int size)
>                         // Update the thumbnail if this is the last frame
>                         pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, FALSE, 8, current.width / (skip*2), current.height / (skip*2));
>                         pixels = gdk_pixbuf_get_pixels(pixbuf);
> -                       quick_debayer_bggr8((const uint8_t *)p, pixels, current.width, current.height, skip, current.blacklevel);
> +                       quick_debayer((const uint8_t *)p, pixels, current.fmt,
> +                                     current.width, current.height, skip,
> +                                     current.blacklevel);
>
>                         if (current.rotate == 0) {
>                                 pixbufrot = pixbuf;
> diff --git a/quickdebayer.c b/quickdebayer.c
> index a9c322f..7b4f8c7 100644
> --- a/quickdebayer.c
> +++ b/quickdebayer.c
> @@ -1,43 +1,77 @@
> +/*
> + * Fast but bad debayer method that scales and rotates by skipping source
> + * pixels and doesn't interpolate any values at all
> + */
> +
> +#include <linux/videodev2.h>
>  #include "quickdebayer.h"
>
> -// Fast but bad debayer method that scales and rotates by skipping source pixels and
> -// doesn't interpolate any values at all
> +/* Linear -> sRGB lookup table */
> +static const int srgb[] = {
> +       0, 12, 21, 28, 33, 38, 42, 46, 49, 52, 55, 58, 61, 63, 66, 68, 70,
> +       73, 75, 77, 79, 81, 82, 84, 86, 88, 89, 91, 93, 94, 96, 97, 99, 100,
> +       102, 103, 104, 106, 107, 109, 110, 111, 112, 114, 115, 116, 117, 118,
> +       120, 121, 122, 123, 124, 125, 126, 127, 129, 130, 131, 132, 133, 134,
> +       135, 136, 137, 138, 139, 140, 141, 142, 142, 143, 144, 145, 146, 147,
> +       148, 149, 150, 151, 151, 152, 153, 154, 155, 156, 157, 157, 158, 159,
> +       160, 161, 161, 162, 163, 164, 165, 165, 166, 167, 168, 168, 169, 170,
> +       171, 171, 172, 173, 174, 174, 175, 176, 176, 177, 178, 179, 179, 180,
> +       181, 181, 182, 183, 183, 184, 185, 185, 186, 187, 187, 188, 189, 189,
> +       190, 191, 191, 192, 193, 193, 194, 194, 195, 196, 196, 197, 197, 198,
> +       199, 199, 200, 201, 201, 202, 202, 203, 204, 204, 205, 205, 206, 206,
> +       207, 208, 208, 209, 209, 210, 210, 211, 212, 212, 213, 213, 214, 214,
> +       215, 215, 216, 217, 217, 218, 218, 219, 219, 220, 220, 221, 221, 222,
> +       222, 223, 223, 224, 224, 225, 226, 226, 227, 227, 228, 228, 229, 229,
> +       230, 230, 231, 231, 232, 232, 233, 233, 234, 234, 235, 235, 236, 236,
> +       237, 237, 237, 238, 238, 239, 239, 240, 240, 241, 241, 242, 242, 243,
> +       243, 244, 244, 245, 245, 245, 246, 246, 247, 247, 248, 248, 249, 249,
> +       250, 250, 251, 251, 251, 252, 252, 253, 253, 254, 254, 255
> +};
> +
> +static void quick_debayer_set_dst(uint8_t *dst, uint8_t p0, uint8_t p1,
> +                                 uint8_t p2)
> +{
> +       dst[0] = p0;
> +       dst[1] = p1;
> +       dst[2] = p2;
> +}
>
> -void
> -quick_debayer_bggr8(const uint8_t *source, uint8_t *destination, int width, int height, int skip, int blacklevel)
> +void quick_debayer(const uint8_t *source, uint8_t *destination,
> +                  uint32_t pix_fmt, int width, int height, int skip,
> +                  int blacklevel)
>  {
>         int byteskip = 2 * skip;
>         int input_size = width * height;
> -       int output_size = (width/byteskip) * (height/byteskip);
> -       int i;
> -       int j=0;
> +       int i = 0, j = 0;
>         int row_left = width;
>
> -       // Linear -> sRGB lookup table
> -       static int srgb[] = {
> -               0, 12, 21, 28, 33, 38, 42, 46, 49, 52, 55, 58, 61, 63, 66, 68, 70, 73, 75, 77, 79,
> -               81, 82, 84, 86, 88, 89, 91, 93, 94, 96, 97, 99, 100, 102, 103, 104, 106, 107, 109,
> -               110, 111, 112, 114, 115, 116, 117, 118, 120, 121, 122, 123, 124, 125, 126, 127, 129,
> -               130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 142, 143, 144, 145,
> -               146, 147, 148, 149, 150, 151, 151, 152, 153, 154, 155, 156, 157, 157, 158, 159, 160,
> -               161, 161, 162, 163, 164, 165, 165, 166, 167, 168, 168, 169, 170, 171, 171, 172, 173,
> -               174, 174, 175, 176, 176, 177, 178, 179, 179, 180, 181, 181, 182, 183, 183, 184, 185,
> -               185, 186, 187, 187, 188, 189, 189, 190, 191, 191, 192, 193, 193, 194, 194, 195, 196,
> -               196, 197, 197, 198, 199, 199, 200, 201, 201, 202, 202, 203, 204, 204, 205, 205, 206,
> -               206, 207, 208, 208, 209, 209, 210, 210, 211, 212, 212, 213, 213, 214, 214, 215, 215,
> -               216, 217, 217, 218, 218, 219, 219, 220, 220, 221, 221, 222, 222, 223, 223, 224, 224,
> -               225, 226, 226, 227, 227, 228, 228, 229, 229, 230, 230, 231, 231, 232, 232, 233, 233,
> -               234, 234, 235, 235, 236, 236, 237, 237, 237, 238, 238, 239, 239, 240, 240, 241, 241,
> -               242, 242, 243, 243, 244, 244, 245, 245, 245, 246, 246, 247, 247, 248, 248, 249, 249,
> -               250, 250, 251, 251, 251, 252, 252, 253, 253, 254, 254, 255
> -       };
> +       do {
> +               uint8_t b0 = srgb[source[i] - blacklevel];
> +               uint8_t b1 = srgb[source[i + 1] - blacklevel];
> +               uint8_t b2 = srgb[source[i + width + 1] - blacklevel];
> +
> +               switch (pix_fmt) {
> +                       case V4L2_PIX_FMT_SBGGR8:
> +                               quick_debayer_set_dst(&destination[j],
> +                                                     b2, b1, b0);
> +                               break;
> +                       case V4L2_PIX_FMT_SGBRG8:
> +                               quick_debayer_set_dst(&destination[j],
> +                                                     b1, b2, b0);
> +                               break;
> +                       case V4L2_PIX_FMT_SGRBG8:
> +                               quick_debayer_set_dst(&destination[j],
> +                                                     b1, b0, b2);
> +                               break;
> +                       case V4L2_PIX_FMT_SRGGB8:
> +                               /* fall through */
> +                       default:
> +                               quick_debayer_set_dst(&destination[j],
> +                                                     b0, b1, b2);
> +                               break;
> +               }
> +               j += 3;
>
> -       // B G
> -       // G R
> -       for(i=0;i<input_size;) {
> -               destination[j++] = srgb[source[i+width+1] - blacklevel];
> -               destination[j++] = srgb[source[i+1] - blacklevel];
> -               destination[j++] = srgb[source[i] - blacklevel];
>                 i = i + byteskip;
>                 row_left = row_left - byteskip;
>                 if(row_left < byteskip){
> @@ -46,5 +80,5 @@ quick_debayer_bggr8(const uint8_t *source, uint8_t *destination, int width, int
>                         i = i + width;
>                         i = i + (width * 2 * (skip-1));
>                 }
> -       }
> +       } while (i < input_size);
>  }
> diff --git a/quickdebayer.h b/quickdebayer.h
> index 38a4327..b5a0aac 100644
> --- a/quickdebayer.h
> +++ b/quickdebayer.h
> @@ -1,4 +1,5 @@
>  #include <stdint.h>
>
> -void quick_debayer_bggr8(const uint8_t *source, uint8_t *destination, int width, int height, int skip, int blacklevel);
> -
> +void quick_debayer(const uint8_t *source, uint8_t *destination,
> +                  uint32_t pix_fmt, int width, int height, int skip,
> +                  int blacklevel);
> --
> 2.26.2

Re: [PATCH megapixels 2/2] megapixels: Implement quick-debayering all Bayer 8-bits pixel formats

Details
Message ID
<CAK7fi1aiq1QLg_Syv2ddRgrMTnCSGiv4aQ3HKcpMTA0tqhhJYA@mail.gmail.com>
In-Reply-To
<CA+XnvuNYoGe3Lk=0OpDOK3ch6EjsVq_rAxKg540sFXr_gbVDZg@mail.gmail.com> (view parent)
DKIM signature
missing
Download raw message
No problem!
I'm also testing some performance improvements for very high pixel
count cameras,
like my 23MP IMX300 here which seem to produce some very small improvement:
once perfectly validated, you will get some mode bits from me...
likely in 2-3 days
or something like that.

In any case, I've had a good look at the whole thing... apart the performance
nitpicks that I've done locally, I think that the only way to *really*
speed up the
camera preview (when doing debayering on the CPU) is to implement some
threading (perhaps OpenMP?), which shouldn't be an issue on basically all of
the devices that will run this application (relatively modern ARM/AArch64 SoCs
are all at least dual-core...) but I don't think I have time for that
soon, if any
at all.

What do you think about it?

Il giorno dom 25 ott 2020 alle ore 23:48 Martijn Braam
<martijn@brixit.nl> ha scritto:
>
> Thanks!
>
> This is cleaner than what I was planning, so far both cameras I tested
> on could run on BGGR8 mode (with BGGR being the native pixel order on
> the ov5640).
>
> Op zo 25 okt. 2020 om 17:47 schreef ~kholk <kholk@git.sr.ht>:
> >
> > From: AngeloGioacchino Del Regno <angelogioacchino.delregno@somainline.org>
> >
> > This application was supporting only debayering of BGGR8 streams:
> > this is an issue on cameras that are outputting a different format.
> >
> > Implement quick-debayering of all Bayer 8-bits pixfmts in order to
> > solve wrong tint issues on many, many camera sensors.
> >
> > This was tested on a Sony Exmor-RS IMX300 sensor.
> >
> > Signed-off-by: AngeloGioacchino Del Regno <angelogioacchino.delregno@somainline.org>
> > ---
> >  main.c         |  8 +++--
> >  quickdebayer.c | 98 +++++++++++++++++++++++++++++++++-----------------
> >  quickdebayer.h |  5 +--
> >  3 files changed, 75 insertions(+), 36 deletions(-)
> >
> > diff --git a/main.c b/main.c
> > index f85a699..d80051b 100644
> > --- a/main.c
> > +++ b/main.c
> > @@ -610,7 +610,9 @@ process_image(const int *p, int size)
> >                 }
> >                 pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, FALSE, 8, current.width / (skip*2), current.height / (skip*2));
> >                 pixels = gdk_pixbuf_get_pixels(pixbuf);
> > -               quick_debayer_bggr8((const uint8_t *)p, pixels, current.width, current.height, skip, current.blacklevel);
> > +               quick_debayer((const uint8_t *)p, pixels, current.fmt,
> > +                              current.width, current.height, skip,
> > +                              current.blacklevel);
> >
> >                 if (current.rotate == 0) {
> >                         pixbufrot = pixbuf;
> > @@ -765,7 +767,9 @@ process_image(const int *p, int size)
> >                         // Update the thumbnail if this is the last frame
> >                         pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, FALSE, 8, current.width / (skip*2), current.height / (skip*2));
> >                         pixels = gdk_pixbuf_get_pixels(pixbuf);
> > -                       quick_debayer_bggr8((const uint8_t *)p, pixels, current.width, current.height, skip, current.blacklevel);
> > +                       quick_debayer((const uint8_t *)p, pixels, current.fmt,
> > +                                     current.width, current.height, skip,
> > +                                     current.blacklevel);
> >
> >                         if (current.rotate == 0) {
> >                                 pixbufrot = pixbuf;
> > diff --git a/quickdebayer.c b/quickdebayer.c
> > index a9c322f..7b4f8c7 100644
> > --- a/quickdebayer.c
> > +++ b/quickdebayer.c
> > @@ -1,43 +1,77 @@
> > +/*
> > + * Fast but bad debayer method that scales and rotates by skipping source
> > + * pixels and doesn't interpolate any values at all
> > + */
> > +
> > +#include <linux/videodev2.h>
> >  #include "quickdebayer.h"
> >
> > -// Fast but bad debayer method that scales and rotates by skipping source pixels and
> > -// doesn't interpolate any values at all
> > +/* Linear -> sRGB lookup table */
> > +static const int srgb[] = {
> > +       0, 12, 21, 28, 33, 38, 42, 46, 49, 52, 55, 58, 61, 63, 66, 68, 70,
> > +       73, 75, 77, 79, 81, 82, 84, 86, 88, 89, 91, 93, 94, 96, 97, 99, 100,
> > +       102, 103, 104, 106, 107, 109, 110, 111, 112, 114, 115, 116, 117, 118,
> > +       120, 121, 122, 123, 124, 125, 126, 127, 129, 130, 131, 132, 133, 134,
> > +       135, 136, 137, 138, 139, 140, 141, 142, 142, 143, 144, 145, 146, 147,
> > +       148, 149, 150, 151, 151, 152, 153, 154, 155, 156, 157, 157, 158, 159,
> > +       160, 161, 161, 162, 163, 164, 165, 165, 166, 167, 168, 168, 169, 170,
> > +       171, 171, 172, 173, 174, 174, 175, 176, 176, 177, 178, 179, 179, 180,
> > +       181, 181, 182, 183, 183, 184, 185, 185, 186, 187, 187, 188, 189, 189,
> > +       190, 191, 191, 192, 193, 193, 194, 194, 195, 196, 196, 197, 197, 198,
> > +       199, 199, 200, 201, 201, 202, 202, 203, 204, 204, 205, 205, 206, 206,
> > +       207, 208, 208, 209, 209, 210, 210, 211, 212, 212, 213, 213, 214, 214,
> > +       215, 215, 216, 217, 217, 218, 218, 219, 219, 220, 220, 221, 221, 222,
> > +       222, 223, 223, 224, 224, 225, 226, 226, 227, 227, 228, 228, 229, 229,
> > +       230, 230, 231, 231, 232, 232, 233, 233, 234, 234, 235, 235, 236, 236,
> > +       237, 237, 237, 238, 238, 239, 239, 240, 240, 241, 241, 242, 242, 243,
> > +       243, 244, 244, 245, 245, 245, 246, 246, 247, 247, 248, 248, 249, 249,
> > +       250, 250, 251, 251, 251, 252, 252, 253, 253, 254, 254, 255
> > +};
> > +
> > +static void quick_debayer_set_dst(uint8_t *dst, uint8_t p0, uint8_t p1,
> > +                                 uint8_t p2)
> > +{
> > +       dst[0] = p0;
> > +       dst[1] = p1;
> > +       dst[2] = p2;
> > +}
> >
> > -void
> > -quick_debayer_bggr8(const uint8_t *source, uint8_t *destination, int width, int height, int skip, int blacklevel)
> > +void quick_debayer(const uint8_t *source, uint8_t *destination,
> > +                  uint32_t pix_fmt, int width, int height, int skip,
> > +                  int blacklevel)
> >  {
> >         int byteskip = 2 * skip;
> >         int input_size = width * height;
> > -       int output_size = (width/byteskip) * (height/byteskip);
> > -       int i;
> > -       int j=0;
> > +       int i = 0, j = 0;
> >         int row_left = width;
> >
> > -       // Linear -> sRGB lookup table
> > -       static int srgb[] = {
> > -               0, 12, 21, 28, 33, 38, 42, 46, 49, 52, 55, 58, 61, 63, 66, 68, 70, 73, 75, 77, 79,
> > -               81, 82, 84, 86, 88, 89, 91, 93, 94, 96, 97, 99, 100, 102, 103, 104, 106, 107, 109,
> > -               110, 111, 112, 114, 115, 116, 117, 118, 120, 121, 122, 123, 124, 125, 126, 127, 129,
> > -               130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 142, 143, 144, 145,
> > -               146, 147, 148, 149, 150, 151, 151, 152, 153, 154, 155, 156, 157, 157, 158, 159, 160,
> > -               161, 161, 162, 163, 164, 165, 165, 166, 167, 168, 168, 169, 170, 171, 171, 172, 173,
> > -               174, 174, 175, 176, 176, 177, 178, 179, 179, 180, 181, 181, 182, 183, 183, 184, 185,
> > -               185, 186, 187, 187, 188, 189, 189, 190, 191, 191, 192, 193, 193, 194, 194, 195, 196,
> > -               196, 197, 197, 198, 199, 199, 200, 201, 201, 202, 202, 203, 204, 204, 205, 205, 206,
> > -               206, 207, 208, 208, 209, 209, 210, 210, 211, 212, 212, 213, 213, 214, 214, 215, 215,
> > -               216, 217, 217, 218, 218, 219, 219, 220, 220, 221, 221, 222, 222, 223, 223, 224, 224,
> > -               225, 226, 226, 227, 227, 228, 228, 229, 229, 230, 230, 231, 231, 232, 232, 233, 233,
> > -               234, 234, 235, 235, 236, 236, 237, 237, 237, 238, 238, 239, 239, 240, 240, 241, 241,
> > -               242, 242, 243, 243, 244, 244, 245, 245, 245, 246, 246, 247, 247, 248, 248, 249, 249,
> > -               250, 250, 251, 251, 251, 252, 252, 253, 253, 254, 254, 255
> > -       };
> > +       do {
> > +               uint8_t b0 = srgb[source[i] - blacklevel];
> > +               uint8_t b1 = srgb[source[i + 1] - blacklevel];
> > +               uint8_t b2 = srgb[source[i + width + 1] - blacklevel];
> > +
> > +               switch (pix_fmt) {
> > +                       case V4L2_PIX_FMT_SBGGR8:
> > +                               quick_debayer_set_dst(&destination[j],
> > +                                                     b2, b1, b0);
> > +                               break;
> > +                       case V4L2_PIX_FMT_SGBRG8:
> > +                               quick_debayer_set_dst(&destination[j],
> > +                                                     b1, b2, b0);
> > +                               break;
> > +                       case V4L2_PIX_FMT_SGRBG8:
> > +                               quick_debayer_set_dst(&destination[j],
> > +                                                     b1, b0, b2);
> > +                               break;
> > +                       case V4L2_PIX_FMT_SRGGB8:
> > +                               /* fall through */
> > +                       default:
> > +                               quick_debayer_set_dst(&destination[j],
> > +                                                     b0, b1, b2);
> > +                               break;
> > +               }
> > +               j += 3;
> >
> > -       // B G
> > -       // G R
> > -       for(i=0;i<input_size;) {
> > -               destination[j++] = srgb[source[i+width+1] - blacklevel];
> > -               destination[j++] = srgb[source[i+1] - blacklevel];
> > -               destination[j++] = srgb[source[i] - blacklevel];
> >                 i = i + byteskip;
> >                 row_left = row_left - byteskip;
> >                 if(row_left < byteskip){
> > @@ -46,5 +80,5 @@ quick_debayer_bggr8(const uint8_t *source, uint8_t *destination, int width, int
> >                         i = i + width;
> >                         i = i + (width * 2 * (skip-1));
> >                 }
> > -       }
> > +       } while (i < input_size);
> >  }
> > diff --git a/quickdebayer.h b/quickdebayer.h
> > index 38a4327..b5a0aac 100644
> > --- a/quickdebayer.h
> > +++ b/quickdebayer.h
> > @@ -1,4 +1,5 @@
> >  #include <stdint.h>
> >
> > -void quick_debayer_bggr8(const uint8_t *source, uint8_t *destination, int width, int height, int skip, int blacklevel);
> > -
> > +void quick_debayer(const uint8_t *source, uint8_t *destination,
> > +                  uint32_t pix_fmt, int width, int height, int skip,
> > +                  int blacklevel);
> > --
> > 2.26.2
Reply to thread Export thread (mbox)