RPJosh
/
neatvnc
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
neatvnc/src/pixels.c

666 lines
17 KiB
C
Raw Normal View History

zrle: Extract pixel conversion function into own file
2019-09-09 19:15:02 +00:00
/*
pixels: Handle different endianness for alpha mask
2022-02-06 17:36:19 +00:00
* Copyright (c) 2019 - 2022 Andri Yngvason
zrle: Extract pixel conversion function into own file
2019-09-09 19:15:02 +00:00
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
* REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
* AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
* INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
* LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
* OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*/
#include "rfb-proto.h"
use static for functions not used outside this compile unit Add static for all functions only used inside the individual compile units. This helps the compiler to potentially inline these functions. This allows to use neatvnc as a Meson subproject in Weston which has -Wmissing-prototypes enabled by default.
2020-05-17 23:42:55 +00:00
#include "pixels.h"
zrle: Extract pixel conversion function into own file
2019-09-09 19:15:02 +00:00
#include <stdlib.h>
#include <assert.h>
server: Extract pixel format functions into pixels.c
2019-12-30 20:13:40 +00:00
#include <libdrm/drm_fourcc.h>
zrle: Extract pixel conversion function into own file
2019-09-09 19:15:02 +00:00
Re-format using clang-format
2019-10-20 22:13:51 +00:00
#define POPCOUNT(x) __builtin_popcount(x)
pixels: Add function to extract alpha mask
2022-02-06 15:01:33 +00:00
#define UDIV_UP(a, b) (((a) + (b) - 1) / (b))
pixels: Add function to convert drm format to string
2022-02-12 12:30:12 +00:00
#define XSTR(s) STR(s)
#define STR(s) #s
zrle: Extract pixel conversion function into own file
2019-09-09 19:15:02 +00:00
Implement 24 bit pixel formats for raw and tight
2023-09-21 14:25:10 +00:00
static void pixel32_to_cpixel(uint8_t* restrict dst,
const struct rfb_pixel_format* dst_fmt,
const uint32_t* restrict src,
const struct rfb_pixel_format* src_fmt,
size_t bytes_per_cpixel, size_t len)
zrle: Extract pixel conversion function into own file
2019-09-09 19:15:02 +00:00
{
assert(src_fmt->true_colour_flag);
assert(src_fmt->depth <= 32);
assert(dst_fmt->true_colour_flag);
assert(dst_fmt->bits_per_pixel <= 32);
pixels: Add 10-bits-per-colour formats
2022-01-27 22:11:51 +00:00
assert(dst_fmt->depth <= 32);
raw-encoding: Do proper pixel conversion
2019-10-14 10:33:43 +00:00
assert(bytes_per_cpixel <= 4 && bytes_per_cpixel >= 1);
zrle: Extract pixel conversion function into own file
2019-09-09 19:15:02 +00:00
uint32_t src_red_shift = src_fmt->red_shift;
uint32_t src_green_shift = src_fmt->green_shift;
uint32_t src_blue_shift = src_fmt->blue_shift;
uint32_t dst_red_shift = dst_fmt->red_shift;
uint32_t dst_green_shift = dst_fmt->green_shift;
uint32_t dst_blue_shift = dst_fmt->blue_shift;
uint32_t src_red_max = src_fmt->red_max;
uint32_t src_green_max = src_fmt->green_max;
uint32_t src_blue_max = src_fmt->blue_max;
uint32_t src_red_bits = POPCOUNT(src_fmt->red_max);
uint32_t src_green_bits = POPCOUNT(src_fmt->green_max);
uint32_t src_blue_bits = POPCOUNT(src_fmt->blue_max);
uint32_t dst_red_bits = POPCOUNT(dst_fmt->red_max);
uint32_t dst_green_bits = POPCOUNT(dst_fmt->green_max);
uint32_t dst_blue_bits = POPCOUNT(dst_fmt->blue_max);
uint32_t dst_endian_correction;
Re-format using clang-format
2019-10-20 22:13:51 +00:00
#define CONVERT_PIXELS(cpx, px) \
{ \
uint32_t r, g, b; \
r = ((px >> src_red_shift) & src_red_max) << dst_red_bits \
>> src_red_bits << dst_red_shift; \
g = ((px >> src_green_shift) & src_green_max) << dst_green_bits\
>> src_green_bits << dst_green_shift; \
b = ((px >> src_blue_shift) & src_blue_max) << dst_blue_bits \
>> src_blue_bits << dst_blue_shift; \
cpx = r | g | b; \
zrle: Extract pixel conversion function into own file
2019-09-09 19:15:02 +00:00
}
switch (bytes_per_cpixel) {
pixels: Make it work for 4 bytes per cpixel
2020-01-19 21:30:49 +00:00
case 4:
if (dst_fmt->big_endian_flag) {
while (len--) {
uint32_t cpx, px = *src++;
CONVERT_PIXELS(cpx, px)
*dst++ = (cpx >> 24) & 0xff;
*dst++ = (cpx >> 16) & 0xff;
*dst++ = (cpx >> 8) & 0xff;
*dst++ = (cpx >> 0) & 0xff;
}
} else {
while (len--) {
uint32_t cpx, px = *src++;
CONVERT_PIXELS(cpx, px)
*dst++ = (cpx >> 0) & 0xff;
*dst++ = (cpx >> 8) & 0xff;
*dst++ = (cpx >> 16) & 0xff;
*dst++ = (cpx >> 24) & 0xff;
}
}
break;
zrle: Extract pixel conversion function into own file
2019-09-09 19:15:02 +00:00
case 3:
if (dst_fmt->bits_per_pixel == 32 && dst_fmt->depth <= 24) {
uint32_t min_dst_shift = dst_red_shift;
if (min_dst_shift > dst_green_shift)
min_dst_shift = dst_green_shift;
if (min_dst_shift > dst_blue_shift)
min_dst_shift = dst_blue_shift;
dst_red_shift -= min_dst_shift;
dst_green_shift -= min_dst_shift;
dst_blue_shift -= min_dst_shift;
}
dst_endian_correction = dst_fmt->big_endian_flag ? 16 : 0;
while (len--) {
uint32_t cpx, px = *src++;
CONVERT_PIXELS(cpx, px)
*dst++ = (cpx >> (0 ^ dst_endian_correction)) & 0xff;
pixels: Fix rfb_pixfmt_from_fourcc
2020-01-19 23:13:12 +00:00
*dst++ = (cpx >> 8) & 0xff;
*dst++ = (cpx >> (16 ^ dst_endian_correction)) & 0xff;
zrle: Extract pixel conversion function into own file
2019-09-09 19:15:02 +00:00
}
break;
case 2:
dst_endian_correction = dst_fmt->big_endian_flag ? 8 : 0;
while (len--) {
uint32_t cpx, px = *src++;
CONVERT_PIXELS(cpx, px)
*dst++ = (cpx >> (0 ^ dst_endian_correction)) & 0xff;
pixels: Fix rfb_pixfmt_from_fourcc
2020-01-19 23:13:12 +00:00
*dst++ = (cpx >> (8 ^ dst_endian_correction)) & 0xff;
zrle: Extract pixel conversion function into own file
2019-09-09 19:15:02 +00:00
}
break;
case 1:
while (len--) {
uint32_t cpx, px = *src++;
CONVERT_PIXELS(cpx, px)
*dst++ = cpx & 0xff;
}
break;
default:
abort();
}
#undef CONVERT_PIXELS
}
server: Extract pixel format functions into pixels.c
2019-12-30 20:13:40 +00:00
Implement 24 bit pixel formats for raw and tight
2023-09-21 14:25:10 +00:00
void pixel_to_cpixel(uint8_t* restrict dst,
const struct rfb_pixel_format* dst_fmt,
const uint8_t* restrict src,
const struct rfb_pixel_format* src_fmt,
size_t bytes_per_cpixel, size_t len)
{
if (src_fmt->bits_per_pixel == 32) {
pixel32_to_cpixel(dst, dst_fmt, (uint32_t*)src, src_fmt, bytes_per_cpixel, len);
return;
}
assert(src_fmt->true_colour_flag);
assert(src_fmt->depth <= 32);
assert(dst_fmt->true_colour_flag);
assert(dst_fmt->bits_per_pixel <= 32);
assert(dst_fmt->depth <= 32);
assert(bytes_per_cpixel <= 4 && bytes_per_cpixel >= 1);
uint32_t src_bpp = src_fmt->bits_per_pixel / 8;
uint32_t src_red_shift = src_fmt->red_shift;
uint32_t src_green_shift = src_fmt->green_shift;
uint32_t src_blue_shift = src_fmt->blue_shift;
uint32_t dst_red_shift = dst_fmt->red_shift;
uint32_t dst_green_shift = dst_fmt->green_shift;
uint32_t dst_blue_shift = dst_fmt->blue_shift;
uint32_t src_red_max = src_fmt->red_max;
uint32_t src_green_max = src_fmt->green_max;
uint32_t src_blue_max = src_fmt->blue_max;
uint32_t src_red_bits = POPCOUNT(src_fmt->red_max);
uint32_t src_green_bits = POPCOUNT(src_fmt->green_max);
uint32_t src_blue_bits = POPCOUNT(src_fmt->blue_max);
uint32_t dst_red_bits = POPCOUNT(dst_fmt->red_max);
uint32_t dst_green_bits = POPCOUNT(dst_fmt->green_max);
uint32_t dst_blue_bits = POPCOUNT(dst_fmt->blue_max);
uint32_t dst_endian_correction;
#define CONVERT_PIXELS(cpx, px) \
{ \
uint32_t r, g, b; \
r = ((px >> src_red_shift) & src_red_max) << dst_red_bits \
>> src_red_bits << dst_red_shift; \
g = ((px >> src_green_shift) & src_green_max) << dst_green_bits\
>> src_green_bits << dst_green_shift; \
b = ((px >> src_blue_shift) & src_blue_max) << dst_blue_bits \
>> src_blue_bits << dst_blue_shift; \
cpx = r | g | b; \
}
switch (bytes_per_cpixel) {
case 4:
if (dst_fmt->big_endian_flag) {
while (len--) {
uint32_t cpx, px = 0;
memcpy(&px, src, src_bpp);
src += src_bpp;
CONVERT_PIXELS(cpx, px)
*dst++ = (cpx >> 24) & 0xff;
*dst++ = (cpx >> 16) & 0xff;
*dst++ = (cpx >> 8) & 0xff;
*dst++ = (cpx >> 0) & 0xff;
}
} else {
while (len--) {
uint32_t cpx, px = 0;
memcpy(&px, src, src_bpp);
src += src_bpp;
CONVERT_PIXELS(cpx, px)
*dst++ = (cpx >> 0) & 0xff;
*dst++ = (cpx >> 8) & 0xff;
*dst++ = (cpx >> 16) & 0xff;
*dst++ = (cpx >> 24) & 0xff;
}
}
break;
case 3:
if (dst_fmt->bits_per_pixel == 32 && dst_fmt->depth <= 24) {
uint32_t min_dst_shift = dst_red_shift;
if (min_dst_shift > dst_green_shift)
min_dst_shift = dst_green_shift;
if (min_dst_shift > dst_blue_shift)
min_dst_shift = dst_blue_shift;
dst_red_shift -= min_dst_shift;
dst_green_shift -= min_dst_shift;
dst_blue_shift -= min_dst_shift;
}
dst_endian_correction = dst_fmt->big_endian_flag ? 16 : 0;
while (len--) {
uint32_t cpx, px = 0;
memcpy(&px, src, src_bpp);
src += src_bpp;
CONVERT_PIXELS(cpx, px)
*dst++ = (cpx >> (0 ^ dst_endian_correction)) & 0xff;
*dst++ = (cpx >> 8) & 0xff;
*dst++ = (cpx >> (16 ^ dst_endian_correction)) & 0xff;
}
break;
case 2:
dst_endian_correction = dst_fmt->big_endian_flag ? 8 : 0;
while (len--) {
uint32_t cpx, px = 0;
memcpy(&px, src, src_bpp);
src += src_bpp;
CONVERT_PIXELS(cpx, px)
*dst++ = (cpx >> (0 ^ dst_endian_correction)) & 0xff;
*dst++ = (cpx >> (8 ^ dst_endian_correction)) & 0xff;
}
break;
case 1:
while (len--) {
uint32_t cpx, px = 0;
memcpy(&px, src, src_bpp);
src += src_bpp;
CONVERT_PIXELS(cpx, px)
*dst++ = cpx & 0xff;
}
break;
default:
abort();
}
#undef CONVERT_PIXELS
}
server: Extract pixel format functions into pixels.c
2019-12-30 20:13:40 +00:00
/* clang-format off */
int rfb_pixfmt_from_fourcc(struct rfb_pixel_format *dst, uint32_t src) {
switch (src & ~DRM_FORMAT_BIG_ENDIAN) {
pixels: Add 10-bits-per-colour formats
2022-01-27 22:11:51 +00:00
case DRM_FORMAT_RGBA1010102:
case DRM_FORMAT_RGBX1010102:
dst->red_shift = 22;
dst->green_shift = 12;
dst->blue_shift = 2;
goto bpp_32_10bit;
case DRM_FORMAT_BGRA1010102:
case DRM_FORMAT_BGRX1010102:
dst->red_shift = 2;
dst->green_shift = 12;
dst->blue_shift = 22;
goto bpp_32_10bit;
case DRM_FORMAT_ARGB2101010:
case DRM_FORMAT_XRGB2101010:
dst->red_shift = 20;
dst->green_shift = 10;
dst->blue_shift = 0;
goto bpp_32_10bit;
case DRM_FORMAT_ABGR2101010:
case DRM_FORMAT_XBGR2101010:
dst->red_shift = 0;
dst->green_shift = 10;
dst->blue_shift = 20;
bpp_32_10bit:
dst->bits_per_pixel = 32;
dst->depth = 30;
dst->red_max = 0x3ff;
dst->green_max = 0x3ff;
dst->blue_max = 0x3ff;
break;
server: Extract pixel format functions into pixels.c
2019-12-30 20:13:40 +00:00
case DRM_FORMAT_RGBA8888:
case DRM_FORMAT_RGBX8888:
dst->red_shift = 24;
dst->green_shift = 16;
dst->blue_shift = 8;
goto bpp_32;
case DRM_FORMAT_BGRA8888:
case DRM_FORMAT_BGRX8888:
dst->red_shift = 8;
dst->green_shift = 16;
dst->blue_shift = 24;
goto bpp_32;
case DRM_FORMAT_ARGB8888:
case DRM_FORMAT_XRGB8888:
pixels: Fix rfb_pixfmt_from_fourcc
2020-01-19 23:13:12 +00:00
dst->red_shift = 16;
server: Extract pixel format functions into pixels.c
2019-12-30 20:13:40 +00:00
dst->green_shift = 8;
pixels: Fix rfb_pixfmt_from_fourcc
2020-01-19 23:13:12 +00:00
dst->blue_shift = 0;
server: Extract pixel format functions into pixels.c
2019-12-30 20:13:40 +00:00
goto bpp_32;
case DRM_FORMAT_ABGR8888:
case DRM_FORMAT_XBGR8888:
pixels: Fix rfb_pixfmt_from_fourcc
2020-01-19 23:13:12 +00:00
dst->red_shift = 0;
server: Extract pixel format functions into pixels.c
2019-12-30 20:13:40 +00:00
dst->green_shift = 8;
pixels: Fix rfb_pixfmt_from_fourcc
2020-01-19 23:13:12 +00:00
dst->blue_shift = 16;
server: Extract pixel format functions into pixels.c
2019-12-30 20:13:40 +00:00
bpp_32:
dst->bits_per_pixel = 32;
dst->depth = 24;
dst->red_max = 0xff;
dst->green_max = 0xff;
dst->blue_max = 0xff;
break;
Implement 24 bit pixel formats for raw and tight
2023-09-21 14:25:10 +00:00
case DRM_FORMAT_BGR888:
dst->red_shift = 0;
dst->green_shift = 8;
dst->blue_shift = 16;
goto bpp_24;
case DRM_FORMAT_RGB888:
dst->red_shift = 16;
dst->green_shift = 8;
dst->blue_shift = 0;
bpp_24:
dst->bits_per_pixel = 24;
dst->depth = 24;
dst->red_max = 0xff;
dst->green_max = 0xff;
dst->blue_max = 0xff;
break;
server: Extract pixel format functions into pixels.c
2019-12-30 20:13:40 +00:00
case DRM_FORMAT_RGBA4444:
case DRM_FORMAT_RGBX4444:
dst->red_shift = 12;
dst->green_shift = 8;
dst->blue_shift = 4;
goto bpp_16;
case DRM_FORMAT_BGRA4444:
case DRM_FORMAT_BGRX4444:
dst->red_shift = 4;
dst->green_shift = 8;
dst->blue_shift = 12;
goto bpp_16;
case DRM_FORMAT_ARGB4444:
case DRM_FORMAT_XRGB4444:
dst->red_shift = 8;
dst->green_shift = 4;
dst->blue_shift = 0;
goto bpp_16;
case DRM_FORMAT_ABGR4444:
case DRM_FORMAT_XBGR4444:
dst->red_shift = 0;
dst->green_shift = 4;
dst->blue_shift = 8;
bpp_16:
dst->bits_per_pixel = 16;
dst->depth = 12;
dst->red_max = 0x7f;
dst->green_max = 0x7f;
dst->blue_max = 0x7f;
break;
default:
return -1;
}
dst->big_endian_flag = !!(src & DRM_FORMAT_BIG_ENDIAN);
dst->true_colour_flag = 1;
return 0;
Add a API function to get the pixel size of nvnc_fb
2021-09-05 00:20:05 +00:00
}
int pixel_size_from_fourcc(uint32_t fourcc)
{
switch (fourcc & ~DRM_FORMAT_BIG_ENDIAN) {
pixels: Add 10-bits-per-colour formats
2022-01-27 22:11:51 +00:00
case DRM_FORMAT_RGBA1010102:
case DRM_FORMAT_RGBX1010102:
case DRM_FORMAT_BGRA1010102:
case DRM_FORMAT_BGRX1010102:
case DRM_FORMAT_ARGB2101010:
case DRM_FORMAT_XRGB2101010:
case DRM_FORMAT_ABGR2101010:
case DRM_FORMAT_XBGR2101010:
Add a API function to get the pixel size of nvnc_fb
2021-09-05 00:20:05 +00:00
case DRM_FORMAT_RGBA8888:
case DRM_FORMAT_RGBX8888:
case DRM_FORMAT_BGRA8888:
case DRM_FORMAT_BGRX8888:
case DRM_FORMAT_ARGB8888:
case DRM_FORMAT_XRGB8888:
case DRM_FORMAT_ABGR8888:
case DRM_FORMAT_XBGR8888:
return 4;
Implement 24 bit pixel formats for raw and tight
2023-09-21 14:25:10 +00:00
case DRM_FORMAT_BGR888:
case DRM_FORMAT_RGB888:
return 3;
Add a API function to get the pixel size of nvnc_fb
2021-09-05 00:20:05 +00:00
case DRM_FORMAT_RGBA4444:
case DRM_FORMAT_RGBX4444:
case DRM_FORMAT_BGRA4444:
case DRM_FORMAT_BGRX4444:
case DRM_FORMAT_ARGB4444:
case DRM_FORMAT_XRGB4444:
case DRM_FORMAT_ABGR4444:
case DRM_FORMAT_XBGR4444:
return 2;
}
return 0;
}
pixels: Add fourcc_to_pixman_fmt
2021-09-19 19:54:23 +00:00
bool fourcc_to_pixman_fmt(pixman_format_code_t* dst, uint32_t src)
{
assert(!(src & DRM_FORMAT_BIG_ENDIAN));
#define LOWER_R r
#define LOWER_G g
#define LOWER_B b
#define LOWER_A a
#define LOWER_X x
#define LOWER_
#define LOWER(x) LOWER_##x
#define CONCAT_(a, b) a ## b
#define CONCAT(a, b) CONCAT_(a, b)
#define FMT_DRM(x, y, z, v, a, b, c, d) DRM_FORMAT_##x##y##z##v##a##b##c##d
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
#define FMT_PIXMAN(x, y, z, v, a, b, c, d) \
CONCAT(CONCAT(CONCAT(CONCAT(CONCAT(CONCAT(CONCAT(CONCAT(\
PIXMAN_, LOWER(x)), a), LOWER(y)), b), LOWER(z)), c), LOWER(v)), d)
#else
#define FMT_PIXMAN(x, y, z, v, a, b, c, d) \
CONCAT(CONCAT(CONCAT(CONCAT(CONCAT(CONCAT(CONCAT(CONCAT(\
PIXMAN_, LOWER(v)), d), LOWER(z)), c), LOWER(y)), b), LOWER(x)), a)
#endif
switch (src) {
#define X(...) \
case FMT_DRM(__VA_ARGS__): *dst = FMT_PIXMAN(__VA_ARGS__); break
/* 32 bits */
X(A,R,G,B,8,8,8,8);
X(A,B,G,R,8,8,8,8);
X(X,R,G,B,8,8,8,8);
X(X,B,G,R,8,8,8,8);
X(R,G,B,A,8,8,8,8);
X(B,G,R,A,8,8,8,8);
X(R,G,B,X,8,8,8,8);
X(B,G,R,X,8,8,8,8);
/* 24 bits */
X(R,G,B,,8,8,8,);
X(B,G,R,,8,8,8,);
/* 16 bits */
X(R,G,B,,5,6,5,);
X(B,G,R,,5,6,5,);
/* These are incompatible on big endian */
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
pixels: Add 10-bits-per-colour formats
2022-01-27 22:11:51 +00:00
X(A,R,G,B,2,10,10,10);
X(X,R,G,B,2,10,10,10);
X(A,B,G,R,2,10,10,10);
X(X,B,G,R,2,10,10,10);
pixels: Add fourcc_to_pixman_fmt
2021-09-19 19:54:23 +00:00
X(A,R,G,B,1,5,5,5);
X(A,B,G,R,1,5,5,5);
X(X,R,G,B,1,5,5,5);
X(X,B,G,R,1,5,5,5);
X(A,R,G,B,4,4,4,4);
X(A,B,G,R,4,4,4,4);
X(X,R,G,B,4,4,4,4);
X(X,B,G,R,4,4,4,4);
#endif
#undef X
default: return false;
}
return true;
}
pixels: Add function to extract alpha mask
2022-02-06 15:01:33 +00:00
static bool extract_alpha_mask_rgba32(uint8_t* dst, const uint32_t* src,
size_t len, int alpha_shift, uint32_t alpha_max)
{
for (size_t i = 0; i < len; i++) {
uint8_t alpha = (src[i] >> alpha_shift) & alpha_max;
uint8_t binary = !!(alpha > alpha_max / 2);
dst[i / 8] |= binary << (7 - (i % 8));
}
return true;
}
static bool extract_alpha_mask_rgba16(uint8_t* dst, const uint16_t* src,
size_t len, int alpha_shift)
{
for (size_t i = 0; i < len; i++) {
uint8_t alpha = (src[i] >> alpha_shift) & 0xf;
uint8_t binary = !!(alpha > 0xf / 2);
dst[i / 8] |= binary << (7 - (i % 8));
}
return true;
}
// Note: The destination buffer must be at least UDIV_UP(len, 8) long.
bool extract_alpha_mask(uint8_t* dst, const void* src, uint32_t format,
size_t len)
{
memset(dst, 0, UDIV_UP(len, 8));
switch (format & ~DRM_FORMAT_BIG_ENDIAN) {
pixels: Handle different endianness for alpha mask
2022-02-06 17:36:19 +00:00
#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
pixels: Add function to extract alpha mask
2022-02-06 15:01:33 +00:00
case DRM_FORMAT_RGBA1010102:
case DRM_FORMAT_BGRA1010102:
return extract_alpha_mask_rgba32(dst, src, len, 0, 3);
case DRM_FORMAT_ARGB2101010:
case DRM_FORMAT_ABGR2101010:
return extract_alpha_mask_rgba32(dst, src, len, 30, 3);
case DRM_FORMAT_RGBA8888:
case DRM_FORMAT_BGRA8888:
return extract_alpha_mask_rgba32(dst, src, len, 0, 0xff);
case DRM_FORMAT_ARGB8888:
case DRM_FORMAT_ABGR8888:
return extract_alpha_mask_rgba32(dst, src, len, 24, 0xff);
case DRM_FORMAT_RGBA4444:
case DRM_FORMAT_BGRA4444:
return extract_alpha_mask_rgba16(dst, src, len, 0);
case DRM_FORMAT_ARGB4444:
case DRM_FORMAT_ABGR4444:
return extract_alpha_mask_rgba16(dst, src, len, 12);
pixels: Handle different endianness for alpha mask
2022-02-06 17:36:19 +00:00
#else
case DRM_FORMAT_RGBA1010102:
case DRM_FORMAT_BGRA1010102:
return extract_alpha_mask_rgba32(dst, src, len, 30, 3);
case DRM_FORMAT_ARGB2101010:
case DRM_FORMAT_ABGR2101010:
return extract_alpha_mask_rgba32(dst, src, len, 0, 3);
case DRM_FORMAT_RGBA8888:
case DRM_FORMAT_BGRA8888:
return extract_alpha_mask_rgba32(dst, src, len, 24, 0xff);
case DRM_FORMAT_ARGB8888:
case DRM_FORMAT_ABGR8888:
return extract_alpha_mask_rgba32(dst, src, len, 0, 0xff);
case DRM_FORMAT_RGBA4444:
case DRM_FORMAT_BGRA4444:
return extract_alpha_mask_rgba16(dst, src, len, 12);
case DRM_FORMAT_ARGB4444:
case DRM_FORMAT_ABGR4444:
return extract_alpha_mask_rgba16(dst, src, len, 0);
#endif
pixels: Add function to extract alpha mask
2022-02-06 15:01:33 +00:00
}
return false;
}
pixels: Add function to convert drm format to string
2022-02-12 12:30:12 +00:00
const char* drm_format_to_string(uint32_t fmt)
{
switch (fmt) {
#define X(x) case DRM_FORMAT_ ## x: return XSTR(x);
X(RGBA1010102) \
X(RGBX1010102) \
X(BGRA1010102) \
X(BGRX1010102) \
X(ARGB2101010) \
X(XRGB2101010) \
X(ABGR2101010) \
X(XBGR2101010) \
X(RGBA8888) \
X(RGBX8888) \
X(BGRA8888) \
X(BGRX8888) \
X(ARGB8888) \
X(XRGB8888) \
X(ABGR8888) \
X(XBGR8888) \
Implement 24 bit pixel formats for raw and tight
2023-09-21 14:25:10 +00:00
X(RGB888) \
X(BGR888) \
pixels: Add function to convert drm format to string
2022-02-12 12:30:12 +00:00
X(RGBA4444) \
X(RGBX4444) \
X(BGRA4444) \
X(BGRX4444) \
X(ARGB4444) \
X(XRGB4444) \
X(ABGR4444) \
X(XBGR4444) \
X(RGB565)
#undef X
}
return "UNKNOWN";
}
pixels: Add function to get rfb pixel format name
2022-02-12 13:15:30 +00:00
// Not exact, but close enough for debugging
const char* rfb_pixfmt_to_string(const struct rfb_pixel_format* fmt)
{
if (!(fmt->red_max == fmt->green_max && fmt->red_max == fmt->blue_max))
goto failure;
uint32_t profile = (fmt->red_shift << 16) | (fmt->green_shift << 8)
| (fmt->blue_shift);
switch (profile) {
#define CASE(r, g, b) case ((r << 16) | (g << 8) | b)
CASE(22, 10, 2): return "RGBX1010102";
CASE(2, 12, 22): return "BGRX1010102";
CASE(20, 10, 0): return "XRGB2101010";
CASE(0, 10, 20): return "XBGR2101010";
CASE(24, 16, 8): return "RGBX8888";
CASE(8, 16, 24): return "BGRX8888";
CASE(16, 8, 0): return "XRGB8888";
CASE(0, 8, 16): return "XBGR8888";
CASE(12, 8, 4): return "RGBX4444";
CASE(4, 8, 12): return "BGRX4444";
CASE(8, 4, 0): return "XRGB4444";
CASE(0, 4, 8): return "XBGR4444";
CASE(11, 5, 0): return "RGB565";
#undef CASE
}
failure:
return "UNKNOWN";
}