forked from rpms/plymouth
250 lines
11 KiB
Diff
250 lines
11 KiB
Diff
From 0e4e268844ea38075535eb5b233dda325da4481d Mon Sep 17 00:00:00 2001
|
|
From: Hans de Goede <hdegoede@redhat.com>
|
|
Date: Wed, 6 Dec 2017 17:37:12 +0100
|
|
Subject: [PATCH 3/6] pixel-buffer: Add the concept of device rotation
|
|
|
|
On some devices the LCD panel is mounted in the casing in such a way
|
|
that the up/top side of the panel does not match with the top side of
|
|
the device (e.g. it is mounted upside-down).
|
|
|
|
This commit adds support to the ply-pixel-buffer code to create
|
|
buffers which take device rotation into account and which will rotate
|
|
the picture to compensate.
|
|
|
|
https://bugs.freedesktop.org/show_bug.cgi?id=104714
|
|
---
|
|
src/libply-splash-core/ply-pixel-buffer.c | 109 ++++++++++++++++++++--
|
|
src/libply-splash-core/ply-pixel-buffer.h | 9 ++
|
|
2 files changed, 110 insertions(+), 8 deletions(-)
|
|
|
|
diff --git a/src/libply-splash-core/ply-pixel-buffer.c b/src/libply-splash-core/ply-pixel-buffer.c
|
|
index 52a3f86..a337407 100644
|
|
--- a/src/libply-splash-core/ply-pixel-buffer.c
|
|
+++ b/src/libply-splash-core/ply-pixel-buffer.c
|
|
@@ -50,6 +50,7 @@ struct _ply_pixel_buffer
|
|
ply_region_t *updated_areas; /* in device pixels */
|
|
uint32_t is_opaque : 1;
|
|
int device_scale;
|
|
+ int device_rotation;
|
|
};
|
|
|
|
static inline void ply_pixel_buffer_blend_value_at_pixel (ply_pixel_buffer_t *buffer,
|
|
@@ -153,6 +154,52 @@ make_pixel_value_translucent (uint32_t pixel_value,
|
|
return (alpha << 24) | (red << 16) | (green << 8) | blue;
|
|
}
|
|
|
|
+static inline void ply_pixel_buffer_set_pixel (ply_pixel_buffer_t *buffer,
|
|
+ int x,
|
|
+ int y,
|
|
+ uint32_t pixel_value)
|
|
+{
|
|
+ switch (buffer->device_rotation) {
|
|
+ case PLY_PIXEL_BUFFER_ROTATE_UPRIGHT:
|
|
+ buffer->bytes[y * buffer->area.width + x] = pixel_value;
|
|
+ break;
|
|
+ case PLY_PIXEL_BUFFER_ROTATE_UPSIDE_DOWN:
|
|
+ x = (buffer->area.width - 1) - x;
|
|
+ y = (buffer->area.height - 1) - y;
|
|
+ buffer->bytes[y * buffer->area.width + x] = pixel_value;
|
|
+ break;
|
|
+ case PLY_PIXEL_BUFFER_ROTATE_CLOCKWISE:
|
|
+ y = (buffer->area.height - 1) - y;
|
|
+ buffer->bytes[x * buffer->area.height + y] = pixel_value;
|
|
+ break;
|
|
+ case PLY_PIXEL_BUFFER_ROTATE_COUNTER_CLOCKWISE:
|
|
+ x = (buffer->area.width - 1) - x;
|
|
+ buffer->bytes[x * buffer->area.height + y] = pixel_value;
|
|
+ break;
|
|
+ }
|
|
+}
|
|
+
|
|
+static inline uint32_t ply_pixel_buffer_get_pixel (ply_pixel_buffer_t *buffer,
|
|
+ int x,
|
|
+ int y)
|
|
+{
|
|
+ switch (buffer->device_rotation) {
|
|
+ case PLY_PIXEL_BUFFER_ROTATE_UPRIGHT:
|
|
+ return buffer->bytes[y * buffer->area.width + x];
|
|
+ case PLY_PIXEL_BUFFER_ROTATE_UPSIDE_DOWN:
|
|
+ x = (buffer->area.width - 1) - x;
|
|
+ y = (buffer->area.height - 1) - y;
|
|
+ return buffer->bytes[y * buffer->area.width + x];
|
|
+ case PLY_PIXEL_BUFFER_ROTATE_CLOCKWISE:
|
|
+ y = (buffer->area.height - 1) - y;
|
|
+ return buffer->bytes[x * buffer->area.height + y];
|
|
+ case PLY_PIXEL_BUFFER_ROTATE_COUNTER_CLOCKWISE:
|
|
+ x = (buffer->area.width - 1) - x;
|
|
+ return buffer->bytes[x * buffer->area.height + y];
|
|
+ }
|
|
+ return 0;
|
|
+}
|
|
+
|
|
static inline void
|
|
ply_pixel_buffer_blend_value_at_pixel (ply_pixel_buffer_t *buffer,
|
|
int x,
|
|
@@ -162,12 +209,12 @@ ply_pixel_buffer_blend_value_at_pixel (ply_pixel_buffer_t *buffer,
|
|
uint32_t old_pixel_value;
|
|
|
|
if ((pixel_value >> 24) != 0xff) {
|
|
- old_pixel_value = buffer->bytes[y * buffer->area.width + x];
|
|
+ old_pixel_value = ply_pixel_buffer_get_pixel (buffer, x, y);
|
|
|
|
pixel_value = blend_two_pixel_values (pixel_value, old_pixel_value);
|
|
}
|
|
|
|
- buffer->bytes[y * buffer->area.width + x] = pixel_value;
|
|
+ ply_pixel_buffer_set_pixel (buffer, x, y, pixel_value);
|
|
}
|
|
|
|
static void
|
|
@@ -222,6 +269,35 @@ ply_pixel_buffer_crop_area_to_clip_area (ply_pixel_buffer_t *buffer,
|
|
}
|
|
}
|
|
|
|
+static void ply_pixel_buffer_add_updated_area (ply_pixel_buffer_t *buffer,
|
|
+ ply_rectangle_t *area)
|
|
+{
|
|
+ ply_rectangle_t updated_area = *area;
|
|
+
|
|
+ switch (buffer->device_rotation) {
|
|
+ case PLY_PIXEL_BUFFER_ROTATE_UPRIGHT:
|
|
+ break;
|
|
+ case PLY_PIXEL_BUFFER_ROTATE_UPSIDE_DOWN:
|
|
+ updated_area.x = buffer->area.width - area->width - area->x;
|
|
+ updated_area.y = buffer->area.height - area->height - area->y;
|
|
+ break;
|
|
+ case PLY_PIXEL_BUFFER_ROTATE_CLOCKWISE:
|
|
+ updated_area.x = buffer->area.height - area->height - area->y;
|
|
+ updated_area.y = area->x;
|
|
+ updated_area.height = area->width;
|
|
+ updated_area.width = area->height;
|
|
+ break;
|
|
+ case PLY_PIXEL_BUFFER_ROTATE_COUNTER_CLOCKWISE:
|
|
+ updated_area.x = area->y;
|
|
+ updated_area.y = buffer->area.width - area->width - area->x;
|
|
+ updated_area.height = area->width;
|
|
+ updated_area.width = area->height;
|
|
+ break;
|
|
+ }
|
|
+
|
|
+ ply_region_add_rectangle (buffer->updated_areas, &updated_area);
|
|
+}
|
|
+
|
|
static void
|
|
ply_pixel_buffer_fill_area_with_pixel_value (ply_pixel_buffer_t *buffer,
|
|
ply_rectangle_t *fill_area,
|
|
@@ -251,7 +327,7 @@ ply_pixel_buffer_fill_area_with_pixel_value (ply_pixel_buffer_t *buffer,
|
|
}
|
|
}
|
|
|
|
- ply_region_add_rectangle (buffer->updated_areas, &cropped_area);
|
|
+ ply_pixel_buffer_add_updated_area (buffer, &cropped_area);
|
|
}
|
|
|
|
void
|
|
@@ -281,9 +357,24 @@ ply_pixel_buffer_pop_clip_area (ply_pixel_buffer_t *buffer)
|
|
ply_pixel_buffer_t *
|
|
ply_pixel_buffer_new (unsigned long width,
|
|
unsigned long height)
|
|
+{
|
|
+ return ply_pixel_buffer_new_with_device_rotation (
|
|
+ width, height, PLY_PIXEL_BUFFER_ROTATE_UPRIGHT);
|
|
+}
|
|
+
|
|
+ply_pixel_buffer_t *
|
|
+ply_pixel_buffer_new_with_device_rotation (unsigned long width,
|
|
+ unsigned long height,
|
|
+ int device_rotation)
|
|
{
|
|
ply_pixel_buffer_t *buffer;
|
|
|
|
+ if (device_rotation >= PLY_PIXEL_BUFFER_ROTATE_CLOCKWISE) {
|
|
+ unsigned long tmp = width;
|
|
+ width = height;
|
|
+ height = tmp;
|
|
+ }
|
|
+
|
|
buffer = calloc (1, sizeof(ply_pixel_buffer_t));
|
|
|
|
buffer->updated_areas = ply_region_new ();
|
|
@@ -292,6 +383,7 @@ ply_pixel_buffer_new (unsigned long width,
|
|
buffer->area.height = height;
|
|
buffer->logical_area = buffer->area;
|
|
buffer->device_scale = 1;
|
|
+ buffer->device_rotation = device_rotation;
|
|
|
|
buffer->clip_areas = ply_list_new ();
|
|
ply_pixel_buffer_push_clip_area (buffer, &buffer->area);
|
|
@@ -447,7 +539,7 @@ ply_pixel_buffer_fill_with_gradient (ply_pixel_buffer_t *buffer,
|
|
|
|
for (y = buffer->area.y; y < buffer->area.y + buffer->area.height; y++) {
|
|
if (cropped_area.y <= y && y < cropped_area.y + cropped_area.height) {
|
|
- if (cropped_area.width < UNROLLED_PIXEL_COUNT) {
|
|
+ if (cropped_area.width < UNROLLED_PIXEL_COUNT || buffer->device_rotation) {
|
|
for (x = cropped_area.x; x < cropped_area.x + cropped_area.width; x++) {
|
|
pixel = 0xff000000;
|
|
RANDOMIZE (noise);
|
|
@@ -457,7 +549,7 @@ ply_pixel_buffer_fill_with_gradient (ply_pixel_buffer_t *buffer,
|
|
RANDOMIZE (noise);
|
|
pixel |= (((blue + noise) & COLOR_MASK) >> BLUE_SHIFT);
|
|
|
|
- buffer->bytes[y * buffer->area.width + x] = pixel;
|
|
+ ply_pixel_buffer_set_pixel (buffer, x, y, pixel);
|
|
}
|
|
} else {
|
|
uint32_t shaded_set[UNROLLED_PIXEL_COUNT];
|
|
@@ -485,7 +577,7 @@ ply_pixel_buffer_fill_with_gradient (ply_pixel_buffer_t *buffer,
|
|
blue += blue_step;
|
|
}
|
|
|
|
- ply_region_add_rectangle (buffer->updated_areas, &cropped_area);
|
|
+ ply_pixel_buffer_add_updated_area (buffer, &cropped_area);
|
|
}
|
|
|
|
void
|
|
@@ -671,7 +763,7 @@ ply_pixel_buffer_fill_with_argb32_data_at_opacity_with_clip_and_scale (ply_pixel
|
|
}
|
|
}
|
|
|
|
- ply_region_add_rectangle (buffer->updated_areas, &cropped_area);
|
|
+ ply_pixel_buffer_add_updated_area (buffer, &cropped_area);
|
|
}
|
|
|
|
void
|
|
@@ -756,7 +848,8 @@ ply_pixel_buffer_fill_with_buffer_at_opacity_with_clip (ply_pixel_buffer_t *canv
|
|
|
|
/* Fast path to memcpy if we need no blending or scaling */
|
|
if (opacity == 1.0 && ply_pixel_buffer_is_opaque (source) &&
|
|
- canvas->device_scale == source->device_scale) {
|
|
+ canvas->device_scale == source->device_scale &&
|
|
+ canvas->device_rotation == PLY_PIXEL_BUFFER_ROTATE_UPRIGHT) {
|
|
ply_rectangle_t cropped_area;
|
|
|
|
cropped_area.x = x_offset;
|
|
diff --git a/src/libply-splash-core/ply-pixel-buffer.h b/src/libply-splash-core/ply-pixel-buffer.h
|
|
index 595e9bd..7736dd3 100644
|
|
--- a/src/libply-splash-core/ply-pixel-buffer.h
|
|
+++ b/src/libply-splash-core/ply-pixel-buffer.h
|
|
@@ -37,9 +37,18 @@ typedef struct _ply_pixel_buffer ply_pixel_buffer_t;
|
|
| ((uint8_t) (CLAMP (g * 255.0, 0.0, 255.0)) << 8) \
|
|
| ((uint8_t) (CLAMP (b * 255.0, 0.0, 255.0))))
|
|
|
|
+#define PLY_PIXEL_BUFFER_ROTATE_UPRIGHT 0
|
|
+#define PLY_PIXEL_BUFFER_ROTATE_UPSIDE_DOWN 1
|
|
+#define PLY_PIXEL_BUFFER_ROTATE_CLOCKWISE 2
|
|
+#define PLY_PIXEL_BUFFER_ROTATE_COUNTER_CLOCKWISE 3
|
|
+
|
|
#ifndef PLY_HIDE_FUNCTION_DECLARATIONS
|
|
ply_pixel_buffer_t *ply_pixel_buffer_new (unsigned long width,
|
|
unsigned long height);
|
|
+ply_pixel_buffer_t *
|
|
+ply_pixel_buffer_new_with_device_rotation (unsigned long width,
|
|
+ unsigned long height,
|
|
+ int device_rotation);
|
|
void ply_pixel_buffer_free (ply_pixel_buffer_t *buffer);
|
|
void ply_pixel_buffer_get_size (ply_pixel_buffer_t *buffer,
|
|
ply_rectangle_t *size);
|
|
--
|
|
2.17.0
|
|
|