From chris at chris-wilson.co.uk Wed Oct 3 08:44:46 2018 From: chris at chris-wilson.co.uk (Chris Wilson) Date: Wed, 03 Oct 2018 09:44:46 +0100 Subject: [Pixman] [PATCH 1/2] pixman: Add support for argb/xrgb float formats, v3. In-Reply-To: References: <20180801124134.27779-1-maarten.lankhorst@linux.intel.com> <20180801124134.27779-2-maarten.lankhorst@linux.intel.com> <20180803050153.GH29581@bryceharrington.org> Message-ID: <153855628595.23109.1335094071009896872@skylake-alporthouse-com> Quoting Maarten Lankhorst (2018-08-03 12:02:38) > Op 03-08-18 om 07:01 schreef Bryce Harrington: > > On Wed, Aug 01, 2018 at 02:41:33PM +0200, Maarten Lankhorst wrote: > >> Pixman is already using the floating point formats internally, expose > >> this capability in case someone wants to support higher bit per > >> component formats. > >> > >> This is useful for igt which depends on cairo to do the rendering. > >> It can use it to convert floats internally to planar Y'CbCr formats, > >> or to F16. > >> > >> Changes since v1: > >> - Use RGBA 128 bits and RGB 96 bits memory layouts, to better match the opengl format. > >> Changes since v2: > >> - Add asserts in accessor and for strides to force alignment. > >> - Move test changes to their own commit. > >> > >> Signed-off-by: Maarten Lankhorst > >> --- > >> pixman/pixman-access.c | 128 ++++++++++++++++++++++++++++++++++++- > >> pixman/pixman-bits-image.c | 3 + > >> pixman/pixman-image.c | 4 ++ > >> pixman/pixman.h | 32 ++++++---- > >> 4 files changed, 155 insertions(+), 12 deletions(-) > >> > >> diff --git a/pixman/pixman-access.c b/pixman/pixman-access.c > >> index 4f0642d77785..10fa049becf4 100644 > >> --- a/pixman/pixman-access.c > >> +++ b/pixman/pixman-access.c > >> @@ -642,6 +642,48 @@ fetch_scanline_a2r10g10b10_float (bits_image_t * image, > >> } > >> > >> /* Expects a float buffer */ > >> +#ifndef PIXMAN_FB_ACCESSORS > >> +static void > >> +fetch_scanline_rgb_float_float (bits_image_t *image, > > Just out of curiosity, why are these routines named with float twice? > > > > Bryce > All the fetch/store functions are named fetch_scanline__float, with format being rgb_float > that gave a double float. Would it be consistent with elsewhere to call it rgbaf? We trade one confusion (float_float) for another (rgba, f). -Chris From chris at chris-wilson.co.uk Wed Oct 3 08:47:47 2018 From: chris at chris-wilson.co.uk (Chris Wilson) Date: Wed, 03 Oct 2018 09:47:47 +0100 Subject: [Pixman] [PATCH 1/2] pixman: Add support for argb/xrgb float formats, v3. In-Reply-To: <20180801124134.27779-2-maarten.lankhorst@linux.intel.com> References: <20180801124134.27779-1-maarten.lankhorst@linux.intel.com> <20180801124134.27779-2-maarten.lankhorst@linux.intel.com> Message-ID: <153855646242.23109.14968987430801435740@skylake-alporthouse-com> Quoting Maarten Lankhorst (2018-08-01 13:41:33) > Pixman is already using the floating point formats internally, expose > this capability in case someone wants to support higher bit per > component formats. > > This is useful for igt which depends on cairo to do the rendering. > It can use it to convert floats internally to planar Y'CbCr formats, > or to F16. > > Changes since v1: > - Use RGBA 128 bits and RGB 96 bits memory layouts, to better match the opengl format. > Changes since v2: > - Add asserts in accessor and for strides to force alignment. > - Move test changes to their own commit. > > Signed-off-by: Maarten Lankhorst > --- > pixman/pixman-access.c | 128 ++++++++++++++++++++++++++++++++++++- > pixman/pixman-bits-image.c | 3 + > pixman/pixman-image.c | 4 ++ > pixman/pixman.h | 32 ++++++---- > 4 files changed, 155 insertions(+), 12 deletions(-) > > diff --git a/pixman/pixman-access.c b/pixman/pixman-access.c > index 4f0642d77785..10fa049becf4 100644 > --- a/pixman/pixman-access.c > +++ b/pixman/pixman-access.c > @@ -642,6 +642,48 @@ fetch_scanline_a2r10g10b10_float (bits_image_t * image, > } > > /* Expects a float buffer */ > +#ifndef PIXMAN_FB_ACCESSORS > +static void > +fetch_scanline_rgb_float_float (bits_image_t *image, > + int x, > + int y, > + int width, > + uint32_t * b, > + const uint32_t *mask) > +{ > + const float *bits = (float *)image->bits + y * image->rowstride; rowstride is in bytes, is it not? -Chris From chris at chris-wilson.co.uk Wed Oct 3 08:56:45 2018 From: chris at chris-wilson.co.uk (Chris Wilson) Date: Wed, 03 Oct 2018 09:56:45 +0100 Subject: [Pixman] [PATCH 1/2] pixman: Add support for argb/xrgb float formats, v3. In-Reply-To: <153855646242.23109.14968987430801435740@skylake-alporthouse-com> References: <20180801124134.27779-1-maarten.lankhorst@linux.intel.com> <20180801124134.27779-2-maarten.lankhorst@linux.intel.com> <153855646242.23109.14968987430801435740@skylake-alporthouse-com> Message-ID: <153855700540.23109.9070026472716040910@skylake-alporthouse-com> Quoting Chris Wilson (2018-10-03 09:47:47) > Quoting Maarten Lankhorst (2018-08-01 13:41:33) > > Pixman is already using the floating point formats internally, expose > > this capability in case someone wants to support higher bit per > > component formats. > > > > This is useful for igt which depends on cairo to do the rendering. > > It can use it to convert floats internally to planar Y'CbCr formats, > > or to F16. > > > > Changes since v1: > > - Use RGBA 128 bits and RGB 96 bits memory layouts, to better match the opengl format. > > Changes since v2: > > - Add asserts in accessor and for strides to force alignment. > > - Move test changes to their own commit. > > > > Signed-off-by: Maarten Lankhorst > > --- > > pixman/pixman-access.c | 128 ++++++++++++++++++++++++++++++++++++- > > pixman/pixman-bits-image.c | 3 + > > pixman/pixman-image.c | 4 ++ > > pixman/pixman.h | 32 ++++++---- > > 4 files changed, 155 insertions(+), 12 deletions(-) > > > > diff --git a/pixman/pixman-access.c b/pixman/pixman-access.c > > index 4f0642d77785..10fa049becf4 100644 > > --- a/pixman/pixman-access.c > > +++ b/pixman/pixman-access.c > > @@ -642,6 +642,48 @@ fetch_scanline_a2r10g10b10_float (bits_image_t * image, > > } > > > > /* Expects a float buffer */ > > +#ifndef PIXMAN_FB_ACCESSORS > > +static void > > +fetch_scanline_rgb_float_float (bits_image_t *image, > > + int x, > > + int y, > > + int width, > > + uint32_t * b, > > + const uint32_t *mask) > > +{ > > + const float *bits = (float *)image->bits + y * image->rowstride; > > rowstride is in bytes, is it not? No, it's in units of uint32_t. -Chris From chris at chris-wilson.co.uk Wed Oct 3 09:11:46 2018 From: chris at chris-wilson.co.uk (Chris Wilson) Date: Wed, 03 Oct 2018 10:11:46 +0100 Subject: [Pixman] [PATCH 1/2] pixman: Add support for argb/xrgb float formats, v3. In-Reply-To: <20180801124134.27779-2-maarten.lankhorst@linux.intel.com> References: <20180801124134.27779-1-maarten.lankhorst@linux.intel.com> <20180801124134.27779-2-maarten.lankhorst@linux.intel.com> Message-ID: <153855790686.17230.10505153646903376056@skylake-alporthouse-com> Quoting Maarten Lankhorst (2018-08-01 13:41:33) > diff --git a/pixman/pixman.h b/pixman/pixman.h > index 509ba5e534a8..c9bf4faa80d4 100644 > --- a/pixman/pixman.h > +++ b/pixman/pixman.h > @@ -647,19 +647,24 @@ struct pixman_indexed > * sample implementation allows only packed RGB and GBR > * representations for data to simplify software rendering, > */ > -#define PIXMAN_FORMAT(bpp,type,a,r,g,b) (((bpp) << 24) | \ > +#define PIXMAN_FORMAT_PACKC(val) ((val) <= 10 ? (val) : \ > + (val) == 32 ? 11 : 0) > +#define PIXMAN_FORMAT_UNPACKC(val) ((val) <= 10 ? (val) : \ > + (val) == 11 ? 32 : 0) We have 4bits, why not reserve 0xf for float32? Certainly you want space for #define PIXMAN_FORMAT_PACKED_FLOAT16 0xb #define PIXMAN_FORMAT_PACKED_FLOAT32 0xc #define PIXMAN_FORMAT_PACKED_FLOAT64 0xd I just wonder if we may have 12bpc one day as well, so leaving 0xc clear has some some appeal. -Chris From maarten.lankhorst at linux.intel.com Thu Oct 25 11:25:15 2018 From: maarten.lankhorst at linux.intel.com (Maarten Lankhorst) Date: Thu, 25 Oct 2018 13:25:15 +0200 Subject: [Pixman] [PATCH 1/2] pixman: Add support for argb/xrgb float formats, v4. In-Reply-To: <153855790686.17230.10505153646903376056@skylake-alporthouse-com> References: <20180801124134.27779-1-maarten.lankhorst@linux.intel.com> <20180801124134.27779-2-maarten.lankhorst@linux.intel.com> <153855790686.17230.10505153646903376056@skylake-alporthouse-com> Message-ID: <1cfe5634-8a90-9e3b-eb45-e55a10204290@linux.intel.com> Op 03-10-18 om 11:11 schreef Chris Wilson: > Quoting Maarten Lankhorst (2018-08-01 13:41:33) >> diff --git a/pixman/pixman.h b/pixman/pixman.h >> index 509ba5e534a8..c9bf4faa80d4 100644 >> --- a/pixman/pixman.h >> +++ b/pixman/pixman.h >> @@ -647,19 +647,24 @@ struct pixman_indexed >> * sample implementation allows only packed RGB and GBR >> * representations for data to simplify software rendering, >> */ >> -#define PIXMAN_FORMAT(bpp,type,a,r,g,b) (((bpp) << 24) | \ >> +#define PIXMAN_FORMAT_PACKC(val) ((val) <= 10 ? (val) : \ >> + (val) == 32 ? 11 : 0) >> +#define PIXMAN_FORMAT_UNPACKC(val) ((val) <= 10 ? (val) : \ >> + (val) == 11 ? 32 : 0) > We have 4bits, why not reserve 0xf for float32? Certainly you > want space for > > #define PIXMAN_FORMAT_PACKED_FLOAT16 0xb > #define PIXMAN_FORMAT_PACKED_FLOAT32 0xc > #define PIXMAN_FORMAT_PACKED_FLOAT64 0xd > > I just wonder if we may have 12bpc one day as well, so leaving 0xc clear > has some some appeal. > -Chris I don't think we support double precision in pixman yet, but here's v4. :) Apply with --scissors ------8<------------------------------------ Pixman is already using the floating point formats internally, expose this capability in case someone wants to support higher bit per component formats. This is useful for igt which depends on cairo to do the rendering. It can use it to convert floats internally to planar Y'CbCr formats, or to F16. Changes since v1: - Use RGBA 128 bits and RGB 96 bits memory layouts, to better match the opengl format. Changes since v2: - Add asserts in accessor and for strides to force alignment. - Move test changes to their own commit. Changes since v3: - Define 32bpc as PIXMAN_FORMAT_PACKED_C32 - Rename pixman accessors from rgb*_float_float to rgb*f_float Signed-off-by: Maarten Lankhorst diff --git a/pixman/pixman-access.c b/pixman/pixman-access.c index 4f0642d77785..8dfd35f45063 100644 --- a/pixman/pixman-access.c +++ b/pixman/pixman-access.c @@ -642,6 +642,48 @@ fetch_scanline_a2r10g10b10_float (bits_image_t * image, } /* Expects a float buffer */ +#ifndef PIXMAN_FB_ACCESSORS +static void +fetch_scanline_rgbf_float (bits_image_t *image, + int x, + int y, + int width, + uint32_t * b, + const uint32_t *mask) +{ + const float *bits = (float *)image->bits + y * image->rowstride; + const float *pixel = bits + x * 3; + argb_t *buffer = (argb_t *)b; + + for (; width--; buffer++) { + buffer->r = *pixel++; + buffer->g = *pixel++; + buffer->b = *pixel++; + buffer->a = 1.f; + } +} + +static void +fetch_scanline_rgbaf_float (bits_image_t *image, + int x, + int y, + int width, + uint32_t * b, + const uint32_t *mask) +{ + const float *bits = (float *)image->bits + y * image->rowstride; + const float *pixel = bits + x * 4; + argb_t *buffer = (argb_t *)b; + + for (; width--; buffer++) { + buffer->r = *pixel++; + buffer->g = *pixel++; + buffer->b = *pixel++; + buffer->a = *pixel++; + } +} +#endif + static void fetch_scanline_x2r10g10b10_float (bits_image_t *image, int x, @@ -805,6 +847,40 @@ fetch_scanline_yv12 (bits_image_t *image, /**************************** Pixel wise fetching *****************************/ +#ifndef PIXMAN_FB_ACCESSORS +static argb_t +fetch_pixel_rgbf_float (bits_image_t *image, + int offset, + int line) +{ + float *bits = (float *)image->bits + line * image->rowstride; + argb_t argb; + + argb.r = bits[offset * 3]; + argb.g = bits[offset * 3 + 1]; + argb.b = bits[offset * 3 + 2]; + argb.a = 1.f; + + return argb; +} + +static argb_t +fetch_pixel_rgbaf_float (bits_image_t *image, + int offset, + int line) +{ + float *bits = (float *)image->bits + line * image->rowstride; + argb_t argb; + + argb.r = bits[offset * 4]; + argb.g = bits[offset * 4 + 1]; + argb.b = bits[offset * 4 + 2]; + argb.a = bits[offset * 4 + 3]; + + return argb; +} +#endif + static argb_t fetch_pixel_x2r10g10b10_float (bits_image_t *image, int offset, @@ -962,6 +1038,45 @@ fetch_pixel_yv12 (bits_image_t *image, /*********************************** Store ************************************/ +#ifndef PIXMAN_FB_ACCESSORS +static void +store_scanline_rgbaf_float (bits_image_t * image, + int x, + int y, + int width, + const uint32_t *v) +{ + float *bits = (float *)image->bits + image->rowstride * y + 4 * x; + const argb_t *values = (argb_t *)v; + + for (; width; width--, values++) + { + *bits++ = values->r; + *bits++ = values->g; + *bits++ = values->b; + *bits++ = values->a; + } +} + +static void +store_scanline_rgbf_float (bits_image_t * image, + int x, + int y, + int width, + const uint32_t *v) +{ + float *bits = (float *)image->bits + image->rowstride * y + 3 * x; + const argb_t *values = (argb_t *)v; + + for (; width; width--, values++) + { + *bits++ = values->r; + *bits++ = values->g; + *bits++ = values->b; + } +} +#endif + static void store_scanline_a2r10g10b10_float (bits_image_t * image, int x, @@ -1351,7 +1466,18 @@ static const format_info_t accessors[] = FORMAT_INFO (g1), /* Wide formats */ - +#ifndef PIXMAN_FB_ACCESSORS + { PIXMAN_rgba_float, + NULL, fetch_scanline_rgbaf_float, + fetch_pixel_generic_lossy_32, fetch_pixel_rgbaf_float, + NULL, store_scanline_rgbaf_float }, + + { PIXMAN_rgb_float, + NULL, fetch_scanline_rgbf_float, + fetch_pixel_generic_lossy_32, fetch_pixel_rgbf_float, + NULL, store_scanline_rgbf_float }, +#endif + { PIXMAN_a2r10g10b10, NULL, fetch_scanline_a2r10g10b10_float, fetch_pixel_generic_lossy_32, fetch_pixel_a2r10g10b10_float, diff --git a/pixman/pixman-bits-image.c b/pixman/pixman-bits-image.c index dcdcc69946de..9fb91ff5831d 100644 --- a/pixman/pixman-bits-image.c +++ b/pixman/pixman-bits-image.c @@ -948,6 +948,9 @@ _pixman_bits_image_init (pixman_image_t * image, { uint32_t *free_me = NULL; + if (PIXMAN_FORMAT_BPP (format) == 128) + return_val_if_fail(!(rowstride % 4), FALSE); + if (!bits && width && height) { int rowstride_bytes; diff --git a/pixman/pixman-image.c b/pixman/pixman-image.c index 681864eb7d17..7a851e221992 100644 --- a/pixman/pixman-image.c +++ b/pixman/pixman-image.c @@ -842,6 +842,10 @@ pixman_image_set_accessors (pixman_image_t * image, if (image->type == BITS) { + /* Accessors only work for <= 32 bpp. */ + if (PIXMAN_FORMAT_BPP(image->bits.format) > 32) + return_if_fail (!read_func && !write_func); + image->bits.read_func = read_func; image->bits.write_func = write_func; diff --git a/pixman/pixman.h b/pixman/pixman.h index 509ba5e534a8..978dc8c2d4a8 100644 --- a/pixman/pixman.h +++ b/pixman/pixman.h @@ -647,19 +647,27 @@ struct pixman_indexed * sample implementation allows only packed RGB and GBR * representations for data to simplify software rendering, */ -#define PIXMAN_FORMAT(bpp,type,a,r,g,b) (((bpp) << 24) | \ +#define PIXMAN_FORMAT_PACKED_C32 0xf + +#define PIXMAN_FORMAT_PACKC(val) ((val) == 32 ? \ + PIXMAN_FORMAT_PACKED_C32 : \ + (val)) +#define PIXMAN_FORMAT_UNPACKC(val) ((val) == PIXMAN_FORMAT_PACKED_C32 ? \ + 32 : (val)) + +#define PIXMAN_FORMAT(bpp,type,a,r,g,b) ((((uint32_t)(bpp)) << 24) | \ ((type) << 16) | \ - ((a) << 12) | \ - ((r) << 8) | \ - ((g) << 4) | \ - ((b))) + (PIXMAN_FORMAT_PACKC(a) << 12) | \ + (PIXMAN_FORMAT_PACKC(r) << 8) | \ + (PIXMAN_FORMAT_PACKC(g) << 4) | \ + (PIXMAN_FORMAT_PACKC(b))) -#define PIXMAN_FORMAT_BPP(f) (((f) >> 24) ) +#define PIXMAN_FORMAT_BPP(f) (((uint32_t)(f)) >> 24) #define PIXMAN_FORMAT_TYPE(f) (((f) >> 16) & 0xff) -#define PIXMAN_FORMAT_A(f) (((f) >> 12) & 0x0f) -#define PIXMAN_FORMAT_R(f) (((f) >> 8) & 0x0f) -#define PIXMAN_FORMAT_G(f) (((f) >> 4) & 0x0f) -#define PIXMAN_FORMAT_B(f) (((f) ) & 0x0f) +#define PIXMAN_FORMAT_A(f) PIXMAN_FORMAT_UNPACKC(((f) >> 12) & 0x0f) +#define PIXMAN_FORMAT_R(f) PIXMAN_FORMAT_UNPACKC(((f) >> 8) & 0x0f) +#define PIXMAN_FORMAT_G(f) PIXMAN_FORMAT_UNPACKC(((f) >> 4) & 0x0f) +#define PIXMAN_FORMAT_B(f) PIXMAN_FORMAT_UNPACKC(((f) >> 0) & 0x0f) #define PIXMAN_FORMAT_RGB(f) (((f) ) & 0xfff) #define PIXMAN_FORMAT_VIS(f) (((f) ) & 0xffff) #define PIXMAN_FORMAT_DEPTH(f) (PIXMAN_FORMAT_A(f) + \ @@ -685,8 +693,13 @@ struct pixman_indexed PIXMAN_FORMAT_TYPE(f) == PIXMAN_TYPE_BGRA || \ PIXMAN_FORMAT_TYPE(f) == PIXMAN_TYPE_RGBA) -/* 32bpp formats */ typedef enum { +/* 128bpp formats */ + PIXMAN_rgba_float = PIXMAN_FORMAT(128,PIXMAN_TYPE_ARGB,32,32,32,32), +/* 96bpp formats */ + PIXMAN_rgb_float = PIXMAN_FORMAT(96,PIXMAN_TYPE_ARGB,0,32,32,32), + +/* 32bpp formats */ PIXMAN_a8r8g8b8 = PIXMAN_FORMAT(32,PIXMAN_TYPE_ARGB,8,8,8,8), PIXMAN_x8r8g8b8 = PIXMAN_FORMAT(32,PIXMAN_TYPE_ARGB,0,8,8,8), PIXMAN_a8b8g8r8 = PIXMAN_FORMAT(32,PIXMAN_TYPE_ABGR,8,8,8,8), From chris at chris-wilson.co.uk Fri Oct 26 10:28:08 2018 From: chris at chris-wilson.co.uk (Chris Wilson) Date: Fri, 26 Oct 2018 11:28:08 +0100 Subject: [Pixman] [PATCH 1/2] pixman: Add support for argb/xrgb float formats, v4. In-Reply-To: <1cfe5634-8a90-9e3b-eb45-e55a10204290@linux.intel.com> References: <20180801124134.27779-1-maarten.lankhorst@linux.intel.com> <20180801124134.27779-2-maarten.lankhorst@linux.intel.com> <153855790686.17230.10505153646903376056@skylake-alporthouse-com> <1cfe5634-8a90-9e3b-eb45-e55a10204290@linux.intel.com> Message-ID: <154054968820.11861.14089240760798160774@skylake-alporthouse-com> Quoting Maarten Lankhorst (2018-10-25 12:25:15) > Op 03-10-18 om 11:11 schreef Chris Wilson: > > Quoting Maarten Lankhorst (2018-08-01 13:41:33) > >> diff --git a/pixman/pixman.h b/pixman/pixman.h > >> index 509ba5e534a8..c9bf4faa80d4 100644 > >> --- a/pixman/pixman.h > >> +++ b/pixman/pixman.h > >> @@ -647,19 +647,24 @@ struct pixman_indexed > >> * sample implementation allows only packed RGB and GBR > >> * representations for data to simplify software rendering, > >> */ > >> -#define PIXMAN_FORMAT(bpp,type,a,r,g,b) (((bpp) << 24) | \ > >> +#define PIXMAN_FORMAT_PACKC(val) ((val) <= 10 ? (val) : \ > >> + (val) == 32 ? 11 : 0) > >> +#define PIXMAN_FORMAT_UNPACKC(val) ((val) <= 10 ? (val) : \ > >> + (val) == 11 ? 32 : 0) > > We have 4bits, why not reserve 0xf for float32? Certainly you > > want space for > > > > #define PIXMAN_FORMAT_PACKED_FLOAT16 0xb > > #define PIXMAN_FORMAT_PACKED_FLOAT32 0xc > > #define PIXMAN_FORMAT_PACKED_FLOAT64 0xd > > > > I just wonder if we may have 12bpc one day as well, so leaving 0xc clear > > has some some appeal. > > -Chris > > I don't think we support double precision in pixman yet, but here's v4. :) > > Apply with --scissors > ------8<------------------------------------ > Pixman is already using the floating point formats internally, expose > this capability in case someone wants to support higher bit per > component formats. > > This is useful for igt which depends on cairo to do the rendering. > It can use it to convert floats internally to planar Y'CbCr formats, > or to F16. > > Changes since v1: > - Use RGBA 128 bits and RGB 96 bits memory layouts, to better match the opengl format. > Changes since v2: > - Add asserts in accessor and for strides to force alignment. > - Move test changes to their own commit. > Changes since v3: > - Define 32bpc as PIXMAN_FORMAT_PACKED_C32 > - Rename pixman accessors from rgb*_float_float to rgb*f_float > > Signed-off-by: Maarten Lankhorst I'm confident that we are not shooting ourselves in the foot here wrt to potential future api directions, so Reviewed-by: Chris Wilson -Chris From chris at chris-wilson.co.uk Fri Oct 26 10:37:40 2018 From: chris at chris-wilson.co.uk (Chris Wilson) Date: Fri, 26 Oct 2018 11:37:40 +0100 Subject: [Pixman] [PATCH 2/2] pixman: Add tests for xrgb/argb formats. In-Reply-To: <20180801124134.27779-3-maarten.lankhorst@linux.intel.com> References: <20180801124134.27779-1-maarten.lankhorst@linux.intel.com> <20180801124134.27779-3-maarten.lankhorst@linux.intel.com> Message-ID: <154055026070.14741.17734038650336188246@skylake-alporthouse-com> Quoting Maarten Lankhorst (2018-08-01 13:41:34) > Signed-off-by: Maarten Lankhorst Reviewed-by: Chris Wilson -Chris From siarhei.siamashka at gmail.com Mon Oct 29 08:16:47 2018 From: siarhei.siamashka at gmail.com (Siarhei Siamashka) Date: Mon, 29 Oct 2018 10:16:47 +0200 Subject: [Pixman] [PATCH 1/2] pixman: Add support for argb/xrgb float formats, v3. In-Reply-To: <153855790686.17230.10505153646903376056@skylake-alporthouse-com> References: <20180801124134.27779-1-maarten.lankhorst@linux.intel.com> <20180801124134.27779-2-maarten.lankhorst@linux.intel.com> <153855790686.17230.10505153646903376056@skylake-alporthouse-com> Message-ID: <20181029101647.13a95687@i7> On Wed, 03 Oct 2018 10:11:46 +0100 Chris Wilson wrote: > Quoting Maarten Lankhorst (2018-08-01 13:41:33) > > diff --git a/pixman/pixman.h b/pixman/pixman.h > > index 509ba5e534a8..c9bf4faa80d4 100644 > > --- a/pixman/pixman.h > > +++ b/pixman/pixman.h > > @@ -647,19 +647,24 @@ struct pixman_indexed > > * sample implementation allows only packed RGB and GBR > > * representations for data to simplify software rendering, > > */ > > -#define PIXMAN_FORMAT(bpp,type,a,r,g,b) (((bpp) << 24) | \ > > +#define PIXMAN_FORMAT_PACKC(val) ((val) <= 10 ? (val) : \ > > + (val) == 32 ? 11 : 0) > > +#define PIXMAN_FORMAT_UNPACKC(val) ((val) <= 10 ? (val) : \ > > + (val) == 11 ? 32 : 0) > > We have 4bits, why not reserve 0xf for float32? Certainly you > want space for > > #define PIXMAN_FORMAT_PACKED_FLOAT16 0xb > #define PIXMAN_FORMAT_PACKED_FLOAT32 0xc > #define PIXMAN_FORMAT_PACKED_FLOAT64 0xd > > I just wonder if we may have 12bpc one day as well, so leaving 0xc clear > has some some appeal. We could probably also try to do something like this: /* * While the protocol is generous in format support, the * sample implementation allows only packed RGB and GBR * representations for data to simplify software rendering, * * Bit 23 selects the granularity of channel color depth * 0: 1-bit granularity (allows up to 15 bits per channel) * 1: 1-byte granularity (allows up to 120 bits per channel) */ #define PIXMAN_FORMAT(bpp,type,a,r,g,b) \ (((bpp) << 24) | \ ((type) << 16) | \ (((a) < 16) ? ((a) << 12) : (((a / 8) << 12) | (1 << 23))) | \ (((r) < 16) ? ((r) << 8) : (((r / 8) << 8) | (1 << 23))) | \ (((g) < 16) ? ((g) << 4) : (((g / 8) << 4) | (1 << 23))) | \ (((b) < 16) ? ((b)) : (((b / 8)) | (1 << 23)))) /* 0 for 1-bit granularity and 3 for 1-byte granularity */ #define PIXMAN_FORMAT_CHANDEPTH_SHIFT(f) \ ((((f) >> 23) & 1) | ((((f) >> 23) & 1) << 1)) #define PIXMAN_FORMAT_A(f) \ ((((f) >> 12) & 0x0f) << PIXMAN_FORMAT_CHANDEPTH_SHIFT(f)) #define PIXMAN_FORMAT_R(f) \ ((((f) >> 8) & 0x0f) << PIXMAN_FORMAT_CHANDEPTH_SHIFT(f)) #define PIXMAN_FORMAT_G(f) \ ((((f) >> 4) & 0x0f) << PIXMAN_FORMAT_CHANDEPTH_SHIFT(f)) #define PIXMAN_FORMAT_B(f) \ ((((f) ) & 0x0f) << PIXMAN_FORMAT_CHANDEPTH_SHIFT(f)) #define PIXMAN_FORMAT_BPP(f) (((uint32_t)(f)) >> 24) #define PIXMAN_FORMAT_TYPE(f) (((f) >> 16) & 0x7f) #define PIXMAN_FORMAT_RGB(f) (((f) ) & 0xfff) #define PIXMAN_FORMAT_VIS(f) (((f) ) & 0xffff) #define PIXMAN_FORMAT_DEPTH(f) (PIXMAN_FORMAT_A(f) + \ PIXMAN_FORMAT_R(f) + \ PIXMAN_FORMAT_G(f) + \ PIXMAN_FORMAT_B(f)) Right now the format type occupies 8 bits. The highest bit could be repurposed as a flag for storing channel depth as bytes instead of bits. This way 16-bit and 64-bit per color component will be also supported. The limitation of this approach is that the depth of every color component has to be a multiple of 8 bits if any of them is 16 bits or larger. I don't feel very comfortable about the fact that some applications are using the PIXMAN_FORMAT_A/R/G/B macros and this code gets compiled as part of these application binaries. Are there any other interesting >32bpp formats that we may need to support in the future? -- Best regards, Siarhei Siamashka From maarten.lankhorst at linux.intel.com Mon Oct 29 09:18:47 2018 From: maarten.lankhorst at linux.intel.com (Maarten Lankhorst) Date: Mon, 29 Oct 2018 10:18:47 +0100 Subject: [Pixman] [PATCH 1/2] pixman: Add support for argb/xrgb float formats, v3. In-Reply-To: <20181029101647.13a95687@i7> References: <20180801124134.27779-1-maarten.lankhorst@linux.intel.com> <20180801124134.27779-2-maarten.lankhorst@linux.intel.com> <153855790686.17230.10505153646903376056@skylake-alporthouse-com> <20181029101647.13a95687@i7> Message-ID: <3cf55ee2-113d-6b1a-1b78-8824b8aa40c8@linux.intel.com> Op 29-10-18 om 09:16 schreef Siarhei Siamashka: > On Wed, 03 Oct 2018 10:11:46 +0100 > Chris Wilson wrote: > >> Quoting Maarten Lankhorst (2018-08-01 13:41:33) >>> diff --git a/pixman/pixman.h b/pixman/pixman.h >>> index 509ba5e534a8..c9bf4faa80d4 100644 >>> --- a/pixman/pixman.h >>> +++ b/pixman/pixman.h >>> @@ -647,19 +647,24 @@ struct pixman_indexed >>> * sample implementation allows only packed RGB and GBR >>> * representations for data to simplify software rendering, >>> */ >>> -#define PIXMAN_FORMAT(bpp,type,a,r,g,b) (((bpp) << 24) | \ >>> +#define PIXMAN_FORMAT_PACKC(val) ((val) <= 10 ? (val) : \ >>> + (val) == 32 ? 11 : 0) >>> +#define PIXMAN_FORMAT_UNPACKC(val) ((val) <= 10 ? (val) : \ >>> + (val) == 11 ? 32 : 0) >> We have 4bits, why not reserve 0xf for float32? Certainly you >> want space for >> >> #define PIXMAN_FORMAT_PACKED_FLOAT16 0xb >> #define PIXMAN_FORMAT_PACKED_FLOAT32 0xc >> #define PIXMAN_FORMAT_PACKED_FLOAT64 0xd >> >> I just wonder if we may have 12bpc one day as well, so leaving 0xc clear >> has some some appeal. > We could probably also try to do something like this: > > /* > * While the protocol is generous in format support, the > * sample implementation allows only packed RGB and GBR > * representations for data to simplify software rendering, > * > * Bit 23 selects the granularity of channel color depth > * 0: 1-bit granularity (allows up to 15 bits per channel) > * 1: 1-byte granularity (allows up to 120 bits per channel) > */ > #define PIXMAN_FORMAT(bpp,type,a,r,g,b) \ > (((bpp) << 24) | \ > ((type) << 16) | \ > (((a) < 16) ? ((a) << 12) : (((a / 8) << 12) | (1 << 23))) | \ > (((r) < 16) ? ((r) << 8) : (((r / 8) << 8) | (1 << 23))) | \ > (((g) < 16) ? ((g) << 4) : (((g / 8) << 4) | (1 << 23))) | \ > (((b) < 16) ? ((b)) : (((b / 8)) | (1 << 23)))) > > /* 0 for 1-bit granularity and 3 for 1-byte granularity */ > #define PIXMAN_FORMAT_CHANDEPTH_SHIFT(f) \ > ((((f) >> 23) & 1) | ((((f) >> 23) & 1) << 1)) I would use 2 bits then, 6 is still plenty for the rest of the type. Perhaps make a separate PIXMAN_FORMAT_TYPE_RGBA_FLOAT and PIXMAN_FORMAT_TYPE_RGB_FLOAT? > #define PIXMAN_FORMAT_A(f) \ > ((((f) >> 12) & 0x0f) << PIXMAN_FORMAT_CHANDEPTH_SHIFT(f)) > #define PIXMAN_FORMAT_R(f) \ > ((((f) >> 8) & 0x0f) << PIXMAN_FORMAT_CHANDEPTH_SHIFT(f)) > #define PIXMAN_FORMAT_G(f) \ > ((((f) >> 4) & 0x0f) << PIXMAN_FORMAT_CHANDEPTH_SHIFT(f)) > #define PIXMAN_FORMAT_B(f) \ > ((((f) ) & 0x0f) << PIXMAN_FORMAT_CHANDEPTH_SHIFT(f)) > > #define PIXMAN_FORMAT_BPP(f) (((uint32_t)(f)) >> 24) > #define PIXMAN_FORMAT_TYPE(f) (((f) >> 16) & 0x7f) > #define PIXMAN_FORMAT_RGB(f) (((f) ) & 0xfff) > #define PIXMAN_FORMAT_VIS(f) (((f) ) & 0xffff) > #define PIXMAN_FORMAT_DEPTH(f) (PIXMAN_FORMAT_A(f) + \ > PIXMAN_FORMAT_R(f) + \ > PIXMAN_FORMAT_G(f) + \ > PIXMAN_FORMAT_B(f)) > > > Right now the format type occupies 8 bits. The highest bit could be > repurposed as a flag for storing channel depth as bytes instead > of bits. This way 16-bit and 64-bit per color component will be > also supported. The limitation of this approach is that the depth > of every color component has to be a multiple of 8 bits if any of > them is 16 bits or larger. > > I don't feel very comfortable about the fact that some applications > are using the PIXMAN_FORMAT_A/R/G/B macros and this code gets compiled > as part of these application binaries. > > Are there any other interesting >32bpp formats that we may need > to support in the future? > Doubt it, pixman doesn't have that accuracy currently, but F16 might be interesting at some point.. ~Maarten From spitzak at gmail.com Mon Oct 29 17:06:19 2018 From: spitzak at gmail.com (Bill Spitzak) Date: Mon, 29 Oct 2018 10:06:19 -0700 Subject: [Pixman] [PATCH 1/2] pixman: Add support for argb/xrgb float formats, v3. In-Reply-To: <3cf55ee2-113d-6b1a-1b78-8824b8aa40c8@linux.intel.com> References: <20180801124134.27779-1-maarten.lankhorst@linux.intel.com> <20180801124134.27779-2-maarten.lankhorst@linux.intel.com> <153855790686.17230.10505153646903376056@skylake-alporthouse-com> <20181029101647.13a95687@i7> <3cf55ee2-113d-6b1a-1b78-8824b8aa40c8@linux.intel.com> Message-ID: I think an indicator for float can double as indicating the size is multiplied by 8. All float formats I am familiar with take a mulitple of 8 bits, including an 8-bit format that is sometimes used in CG. On Mon, Oct 29, 2018 at 2:18 AM Maarten Lankhorst < maarten.lankhorst at linux.intel.com> wrote: > Op 29-10-18 om 09:16 schreef Siarhei Siamashka: > > On Wed, 03 Oct 2018 10:11:46 +0100 > > Chris Wilson wrote: > > > >> Quoting Maarten Lankhorst (2018-08-01 13:41:33) > >>> diff --git a/pixman/pixman.h b/pixman/pixman.h > >>> index 509ba5e534a8..c9bf4faa80d4 100644 > >>> --- a/pixman/pixman.h > >>> +++ b/pixman/pixman.h > >>> @@ -647,19 +647,24 @@ struct pixman_indexed > >>> * sample implementation allows only packed RGB and GBR > >>> * representations for data to simplify software rendering, > >>> */ > >>> -#define PIXMAN_FORMAT(bpp,type,a,r,g,b) (((bpp) << 24) | \ > >>> +#define PIXMAN_FORMAT_PACKC(val) ((val) <= 10 ? (val) : \ > >>> + (val) == 32 ? 11 : 0) > >>> +#define PIXMAN_FORMAT_UNPACKC(val) ((val) <= 10 ? (val) : \ > >>> + (val) == 11 ? 32 : 0) > >> We have 4bits, why not reserve 0xf for float32? Certainly you > >> want space for > >> > >> #define PIXMAN_FORMAT_PACKED_FLOAT16 0xb > >> #define PIXMAN_FORMAT_PACKED_FLOAT32 0xc > >> #define PIXMAN_FORMAT_PACKED_FLOAT64 0xd > >> > >> I just wonder if we may have 12bpc one day as well, so leaving 0xc clear > >> has some some appeal. > > We could probably also try to do something like this: > > > > /* > > * While the protocol is generous in format support, the > > * sample implementation allows only packed RGB and GBR > > * representations for data to simplify software rendering, > > * > > * Bit 23 selects the granularity of channel color depth > > * 0: 1-bit granularity (allows up to 15 bits per channel) > > * 1: 1-byte granularity (allows up to 120 bits per channel) > > */ > > #define PIXMAN_FORMAT(bpp,type,a,r,g,b) \ > > (((bpp) << 24) | \ > > ((type) << 16) | \ > > (((a) < 16) ? ((a) << 12) : (((a / 8) << 12) | (1 << 23))) | \ > > (((r) < 16) ? ((r) << 8) : (((r / 8) << 8) | (1 << 23))) | \ > > (((g) < 16) ? ((g) << 4) : (((g / 8) << 4) | (1 << 23))) | \ > > (((b) < 16) ? ((b)) : (((b / 8)) | (1 << 23)))) > > > > /* 0 for 1-bit granularity and 3 for 1-byte granularity */ > > #define PIXMAN_FORMAT_CHANDEPTH_SHIFT(f) \ > > ((((f) >> 23) & 1) | ((((f) >> 23) & 1) << 1)) > I would use 2 bits then, 6 is still plenty for the rest of the type. > > Perhaps make a separate PIXMAN_FORMAT_TYPE_RGBA_FLOAT and > PIXMAN_FORMAT_TYPE_RGB_FLOAT? > > > #define PIXMAN_FORMAT_A(f) \ > > ((((f) >> 12) & 0x0f) << PIXMAN_FORMAT_CHANDEPTH_SHIFT(f)) > > #define PIXMAN_FORMAT_R(f) \ > > ((((f) >> 8) & 0x0f) << PIXMAN_FORMAT_CHANDEPTH_SHIFT(f)) > > #define PIXMAN_FORMAT_G(f) \ > > ((((f) >> 4) & 0x0f) << PIXMAN_FORMAT_CHANDEPTH_SHIFT(f)) > > #define PIXMAN_FORMAT_B(f) \ > > ((((f) ) & 0x0f) << PIXMAN_FORMAT_CHANDEPTH_SHIFT(f)) > > > > #define PIXMAN_FORMAT_BPP(f) (((uint32_t)(f)) >> 24) > > #define PIXMAN_FORMAT_TYPE(f) (((f) >> 16) & 0x7f) > > #define PIXMAN_FORMAT_RGB(f) (((f) ) & 0xfff) > > #define PIXMAN_FORMAT_VIS(f) (((f) ) & 0xffff) > > #define PIXMAN_FORMAT_DEPTH(f) (PIXMAN_FORMAT_A(f) + \ > > PIXMAN_FORMAT_R(f) + \ > > PIXMAN_FORMAT_G(f) + \ > > PIXMAN_FORMAT_B(f)) > > > > > > Right now the format type occupies 8 bits. The highest bit could be > > repurposed as a flag for storing channel depth as bytes instead > > of bits. This way 16-bit and 64-bit per color component will be > > also supported. The limitation of this approach is that the depth > > of every color component has to be a multiple of 8 bits if any of > > them is 16 bits or larger. > > > > I don't feel very comfortable about the fact that some applications > > are using the PIXMAN_FORMAT_A/R/G/B macros and this code gets compiled > > as part of these application binaries. > > > > Are there any other interesting >32bpp formats that we may need > > to support in the future? > > > Doubt it, pixman doesn't have that accuracy currently, but F16 might be > interesting at some point.. > > ~Maarten > > _______________________________________________ > Pixman mailing list > Pixman at lists.freedesktop.org > https://lists.freedesktop.org/mailman/listinfo/pixman > -------------- next part -------------- An HTML attachment was scrubbed... URL: From maarten.lankhorst at linux.intel.com Wed Oct 31 11:20:44 2018 From: maarten.lankhorst at linux.intel.com (Maarten Lankhorst) Date: Wed, 31 Oct 2018 12:20:44 +0100 Subject: [Pixman] pixman: Add support for argb/xrgb float formats, v5. In-Reply-To: References: <20180801124134.27779-1-maarten.lankhorst@linux.intel.com> <20180801124134.27779-2-maarten.lankhorst@linux.intel.com> <153855790686.17230.10505153646903376056@skylake-alporthouse-com> <20181029101647.13a95687@i7> <3cf55ee2-113d-6b1a-1b78-8824b8aa40c8@linux.intel.com> Message-ID: <937b03d6-fdc4-12af-90bf-bac92924da8a@linux.intel.com> Op 29-10-18 om 18:06 schreef Bill Spitzak: > I think an indicator for float can double as indicating the size is multiplied by 8. All float formats I am familiar with take a mulitple of 8 bits, including an 8-bit format that is sometimes used in CG. What about this, then? ----------------->8------------ Pixman is already using the floating point formats internally, expose this capability in case someone wants to support higher bit per component formats. This is useful for igt which depends on cairo to do the rendering. It can use it to convert floats internally to planar Y'CbCr formats, or to F16. Changes since v1: - Use RGBA 128 bits and RGB 96 bits memory layouts, to better match the opengl format. Changes since v2: - Add asserts in accessor and for strides to force alignment. - Move test changes to their own commit. Changes since v3: - Define 32bpc as PIXMAN_FORMAT_PACKED_C32 - Rename pixman accessors from rgb*_float_float to rgb*f_float Changes since v4: - Create a new PIXMAN_FORMAT_BYTE for fitting up to 64 bits per component. (based on Siarhei Siamashka's suggestion) - Use new format type PIXMAN_TYPE_RGBA_FLOAT Signed-off-by: Maarten Lankhorst Reviewed-by: Chris Wilson #v4 --- pixman/pixman-access.c | 128 ++++++++++++++++++++++++++++++++++++- pixman/pixman-bits-image.c | 3 + pixman/pixman-image.c | 4 ++ pixman/pixman.c | 5 ++ pixman/pixman.h | 35 +++++++--- 5 files changed, 166 insertions(+), 9 deletions(-) diff --git a/pixman/pixman-access.c b/pixman/pixman-access.c index 4f0642d77785..8dfd35f45063 100644 --- a/pixman/pixman-access.c +++ b/pixman/pixman-access.c @@ -642,6 +642,48 @@ fetch_scanline_a2r10g10b10_float (bits_image_t * image, } /* Expects a float buffer */ +#ifndef PIXMAN_FB_ACCESSORS +static void +fetch_scanline_rgbf_float (bits_image_t *image, + int x, + int y, + int width, + uint32_t * b, + const uint32_t *mask) +{ + const float *bits = (float *)image->bits + y * image->rowstride; + const float *pixel = bits + x * 3; + argb_t *buffer = (argb_t *)b; + + for (; width--; buffer++) { + buffer->r = *pixel++; + buffer->g = *pixel++; + buffer->b = *pixel++; + buffer->a = 1.f; + } +} + +static void +fetch_scanline_rgbaf_float (bits_image_t *image, + int x, + int y, + int width, + uint32_t * b, + const uint32_t *mask) +{ + const float *bits = (float *)image->bits + y * image->rowstride; + const float *pixel = bits + x * 4; + argb_t *buffer = (argb_t *)b; + + for (; width--; buffer++) { + buffer->r = *pixel++; + buffer->g = *pixel++; + buffer->b = *pixel++; + buffer->a = *pixel++; + } +} +#endif + static void fetch_scanline_x2r10g10b10_float (bits_image_t *image, int x, @@ -805,6 +847,40 @@ fetch_scanline_yv12 (bits_image_t *image, /**************************** Pixel wise fetching *****************************/ +#ifndef PIXMAN_FB_ACCESSORS +static argb_t +fetch_pixel_rgbf_float (bits_image_t *image, + int offset, + int line) +{ + float *bits = (float *)image->bits + line * image->rowstride; + argb_t argb; + + argb.r = bits[offset * 3]; + argb.g = bits[offset * 3 + 1]; + argb.b = bits[offset * 3 + 2]; + argb.a = 1.f; + + return argb; +} + +static argb_t +fetch_pixel_rgbaf_float (bits_image_t *image, + int offset, + int line) +{ + float *bits = (float *)image->bits + line * image->rowstride; + argb_t argb; + + argb.r = bits[offset * 4]; + argb.g = bits[offset * 4 + 1]; + argb.b = bits[offset * 4 + 2]; + argb.a = bits[offset * 4 + 3]; + + return argb; +} +#endif + static argb_t fetch_pixel_x2r10g10b10_float (bits_image_t *image, int offset, @@ -962,6 +1038,45 @@ fetch_pixel_yv12 (bits_image_t *image, /*********************************** Store ************************************/ +#ifndef PIXMAN_FB_ACCESSORS +static void +store_scanline_rgbaf_float (bits_image_t * image, + int x, + int y, + int width, + const uint32_t *v) +{ + float *bits = (float *)image->bits + image->rowstride * y + 4 * x; + const argb_t *values = (argb_t *)v; + + for (; width; width--, values++) + { + *bits++ = values->r; + *bits++ = values->g; + *bits++ = values->b; + *bits++ = values->a; + } +} + +static void +store_scanline_rgbf_float (bits_image_t * image, + int x, + int y, + int width, + const uint32_t *v) +{ + float *bits = (float *)image->bits + image->rowstride * y + 3 * x; + const argb_t *values = (argb_t *)v; + + for (; width; width--, values++) + { + *bits++ = values->r; + *bits++ = values->g; + *bits++ = values->b; + } +} +#endif + static void store_scanline_a2r10g10b10_float (bits_image_t * image, int x, @@ -1351,7 +1466,18 @@ static const format_info_t accessors[] = FORMAT_INFO (g1), /* Wide formats */ - +#ifndef PIXMAN_FB_ACCESSORS + { PIXMAN_rgba_float, + NULL, fetch_scanline_rgbaf_float, + fetch_pixel_generic_lossy_32, fetch_pixel_rgbaf_float, + NULL, store_scanline_rgbaf_float }, + + { PIXMAN_rgb_float, + NULL, fetch_scanline_rgbf_float, + fetch_pixel_generic_lossy_32, fetch_pixel_rgbf_float, + NULL, store_scanline_rgbf_float }, +#endif + { PIXMAN_a2r10g10b10, NULL, fetch_scanline_a2r10g10b10_float, fetch_pixel_generic_lossy_32, fetch_pixel_a2r10g10b10_float, diff --git a/pixman/pixman-bits-image.c b/pixman/pixman-bits-image.c index dcdcc69946de..9fb91ff5831d 100644 --- a/pixman/pixman-bits-image.c +++ b/pixman/pixman-bits-image.c @@ -948,6 +948,9 @@ _pixman_bits_image_init (pixman_image_t * image, { uint32_t *free_me = NULL; + if (PIXMAN_FORMAT_BPP (format) == 128) + return_val_if_fail(!(rowstride % 4), FALSE); + if (!bits && width && height) { int rowstride_bytes; diff --git a/pixman/pixman-image.c b/pixman/pixman-image.c index 681864eb7d17..7a851e221992 100644 --- a/pixman/pixman-image.c +++ b/pixman/pixman-image.c @@ -842,6 +842,10 @@ pixman_image_set_accessors (pixman_image_t * image, if (image->type == BITS) { + /* Accessors only work for <= 32 bpp. */ + if (PIXMAN_FORMAT_BPP(image->bits.format) > 32) + return_if_fail (!read_func && !write_func); + image->bits.read_func = read_func; image->bits.write_func = write_func; diff --git a/pixman/pixman.c b/pixman/pixman.c index f932eac3c1b6..c09b5280831f 100644 --- a/pixman/pixman.c +++ b/pixman/pixman.c @@ -777,6 +777,11 @@ color_to_pixel (const pixman_color_t *color, { uint32_t c = color_to_uint32 (color); + if (PIXMAN_FORMAT_TYPE (format) == PIXMAN_TYPE_RGBA_FLOAT) + { + return FALSE; + } + if (!(format == PIXMAN_a8r8g8b8 || format == PIXMAN_x8r8g8b8 || format == PIXMAN_a8b8g8r8 || diff --git a/pixman/pixman.h b/pixman/pixman.h index 509ba5e534a8..04d7504729e2 100644 --- a/pixman/pixman.h +++ b/pixman/pixman.h @@ -654,12 +654,24 @@ struct pixman_indexed ((g) << 4) | \ ((b))) -#define PIXMAN_FORMAT_BPP(f) (((f) >> 24) ) -#define PIXMAN_FORMAT_TYPE(f) (((f) >> 16) & 0xff) -#define PIXMAN_FORMAT_A(f) (((f) >> 12) & 0x0f) -#define PIXMAN_FORMAT_R(f) (((f) >> 8) & 0x0f) -#define PIXMAN_FORMAT_G(f) (((f) >> 4) & 0x0f) -#define PIXMAN_FORMAT_B(f) (((f) ) & 0x0f) +#define PIXMAN_FORMAT_BYTE(bpp,type,a,r,g,b) \ + (((bpp >> 3) << 24) | \ + (3 << 22) | ((type) << 16) | \ + ((a >> 3) << 12) | \ + ((r >> 3) << 8) | \ + ((g >> 3) << 4) | \ + ((b >> 3))) + +#define PIXMAN_FORMAT_RESHIFT(val, ofs, num) \ + ((val >> (ofs)) & ((1 << (num)) - 1) << ((val >> 22) & 3)) + +#define PIXMAN_FORMAT_BPP(f) PIXMAN_FORMAT_RESHIFT(f, 24, 8) +#define PIXMAN_FORMAT_SHIFT(f) ((uint32_t)((f >> 22) & 3)) +#define PIXMAN_FORMAT_TYPE(f) (((f) >> 16) & 0x3f) +#define PIXMAN_FORMAT_A(f) PIXMAN_FORMAT_RESHIFT(f, 12, 4) +#define PIXMAN_FORMAT_R(f) PIXMAN_FORMAT_RESHIFT(f, 8, 4) +#define PIXMAN_FORMAT_G(f) PIXMAN_FORMAT_RESHIFT(f, 4, 4) +#define PIXMAN_FORMAT_B(f) PIXMAN_FORMAT_RESHIFT(f, 0, 4) #define PIXMAN_FORMAT_RGB(f) (((f) ) & 0xfff) #define PIXMAN_FORMAT_VIS(f) (((f) ) & 0xffff) #define PIXMAN_FORMAT_DEPTH(f) (PIXMAN_FORMAT_A(f) + \ @@ -678,15 +690,22 @@ struct pixman_indexed #define PIXMAN_TYPE_BGRA 8 #define PIXMAN_TYPE_RGBA 9 #define PIXMAN_TYPE_ARGB_SRGB 10 +#define PIXMAN_TYPE_RGBA_FLOAT 11 #define PIXMAN_FORMAT_COLOR(f) \ (PIXMAN_FORMAT_TYPE(f) == PIXMAN_TYPE_ARGB || \ PIXMAN_FORMAT_TYPE(f) == PIXMAN_TYPE_ABGR || \ PIXMAN_FORMAT_TYPE(f) == PIXMAN_TYPE_BGRA || \ - PIXMAN_FORMAT_TYPE(f) == PIXMAN_TYPE_RGBA) + PIXMAN_FORMAT_TYPE(f) == PIXMAN_TYPE_RGBA || \ + PIXMAN_FORMAT_TYPE(f) == PIXMAN_TYPE_RGBA_FLOAT) -/* 32bpp formats */ typedef enum { +/* 128bpp formats */ + PIXMAN_rgba_float = PIXMAN_FORMAT_BYTE(128,PIXMAN_TYPE_RGBA_FLOAT,32,32,32,32), +/* 96bpp formats */ + PIXMAN_rgb_float = PIXMAN_FORMAT_BYTE(96,PIXMAN_TYPE_RGBA_FLOAT,0,32,32,32), + +/* 32bpp formats */ PIXMAN_a8r8g8b8 = PIXMAN_FORMAT(32,PIXMAN_TYPE_ARGB,8,8,8,8), PIXMAN_x8r8g8b8 = PIXMAN_FORMAT(32,PIXMAN_TYPE_ARGB,0,8,8,8), PIXMAN_a8b8g8r8 = PIXMAN_FORMAT(32,PIXMAN_TYPE_ABGR,8,8,8,8), -- 2.19.1 From spitzak at gmail.com Wed Oct 31 19:04:55 2018 From: spitzak at gmail.com (Bill Spitzak) Date: Wed, 31 Oct 2018 12:04:55 -0700 Subject: [Pixman] pixman: Add support for argb/xrgb float formats, v5. In-Reply-To: <937b03d6-fdc4-12af-90bf-bac92924da8a@linux.intel.com> References: <20180801124134.27779-1-maarten.lankhorst@linux.intel.com> <20180801124134.27779-2-maarten.lankhorst@linux.intel.com> <153855790686.17230.10505153646903376056@skylake-alporthouse-com> <20181029101647.13a95687@i7> <3cf55ee2-113d-6b1a-1b78-8824b8aa40c8@linux.intel.com> <937b03d6-fdc4-12af-90bf-bac92924da8a@linux.intel.com> Message-ID: I don't like the fact that the design which allows the rgba to be different sizes cannot make them vary between float and decimal. The main reason is so that an integer for Alpha can be supported. I think maybe there should be a bit that changes the interpretation of the bit widths to a 16-valued type enumeration. For n-bit integers use n-1 as now, but remove the unusual ones and replace them with floating point and signed types. Use a lookup table to get type + width. I really don't think there are more than 16 of them: 8, 16, 32, 64 bit unsigned 8, 16, 32, 64 bit float this set leaves 8 unused values, which maybe could be allocated in the future for signed types or 128-bit types. You could also provide a few more unsigned widths (1,2,4,10,12?) -------------- next part -------------- An HTML attachment was scrubbed... URL: