/* vim: ts=4 sw=2 expandtab autoindent cindent cino={1s,(0
- * ply-video-buffer.c - framebuffer abstraction
+ * ply-frame-buffer.c - framebuffer abstraction
*
* Copyright (C) 2006, 2007 Red Hat, Inc.
*
* Ray Strode <rstrode@redhat.com>
*/
#include "config.h"
-#include "ply-video-buffer.h"
+#include "ply-frame-buffer.h"
#include <arpa/inet.h>
#include <assert.h>
#include <linux/fb.h>
-#ifndef PLY_VIDEO_BUFFER_DEFAULT_FB_DEVICE_NAME
-#define PLY_VIDEO_BUFFER_DEFAULT_FB_DEVICE_NAME "/dev/fb"
+#ifndef PLY_FRAME_BUFFER_DEFAULT_FB_DEVICE_NAME
+#define PLY_FRAME_BUFFER_DEFAULT_FB_DEVICE_NAME "/dev/fb"
#endif
-struct _PlyVideoBuffer
+struct _PlyFrameBuffer
{
char *device_name;
int device_fd;
unsigned int bits_per_pixel;
unsigned int bytes_per_pixel;
- PlyVideoBufferArea area;
- PlyVideoBufferArea area_to_flush;
+ PlyFrameBufferArea area;
+ PlyFrameBufferArea area_to_flush;
uint32_t is_paused : 1;
};
-static bool ply_video_buffer_open_device (PlyVideoBuffer *buffer);
-static void ply_video_buffer_close_device (PlyVideoBuffer *buffer);
-static bool ply_video_buffer_query_device (PlyVideoBuffer *buffer);
-static bool ply_video_buffer_map_to_device (PlyVideoBuffer *buffer);
-static uint_least32_t ply_video_buffer_pixel_value_to_device_pixel_value (
- PlyVideoBuffer *buffer,
+static bool ply_frame_buffer_open_device (PlyFrameBuffer *buffer);
+static void ply_frame_buffer_close_device (PlyFrameBuffer *buffer);
+static bool ply_frame_buffer_query_device (PlyFrameBuffer *buffer);
+static bool ply_frame_buffer_map_to_device (PlyFrameBuffer *buffer);
+static uint_least32_t ply_frame_buffer_pixel_value_to_device_pixel_value (
+ PlyFrameBuffer *buffer,
uint32_t pixel_value);
-static void ply_video_buffer_blend_value_at_pixel (PlyVideoBuffer *buffer,
+static void ply_frame_buffer_blend_value_at_pixel (PlyFrameBuffer *buffer,
int x,
int y,
uint32_t pixel_value);
-static void ply_video_buffer_fill_area_with_pixel_value (
- PlyVideoBuffer *buffer,
- PlyVideoBufferArea *area,
+static void ply_frame_buffer_fill_area_with_pixel_value (
+ PlyFrameBuffer *buffer,
+ PlyFrameBufferArea *area,
uint32_t pixel_value);
-static void ply_video_buffer_add_area_to_flush_area (PlyVideoBuffer *buffer,
- PlyVideoBufferArea *area);
-static bool ply_video_buffer_copy_to_device (PlyVideoBuffer *buffer,
+static void ply_frame_buffer_add_area_to_flush_area (PlyFrameBuffer *buffer,
+ PlyFrameBufferArea *area);
+static bool ply_frame_buffer_copy_to_device (PlyFrameBuffer *buffer,
unsigned long x,
unsigned long y,
unsigned long width,
unsigned long height);
-static bool ply_video_buffer_flush (PlyVideoBuffer *buffer);
+static bool ply_frame_buffer_flush (PlyFrameBuffer *buffer);
static bool
-ply_video_buffer_open_device (PlyVideoBuffer *buffer)
+ply_frame_buffer_open_device (PlyFrameBuffer *buffer)
{
assert (buffer != NULL);
assert (buffer->device_name != NULL);
}
static void
-ply_video_buffer_close_device (PlyVideoBuffer *buffer)
+ply_frame_buffer_close_device (PlyFrameBuffer *buffer)
{
assert (buffer != NULL);
}
static bool
-ply_video_buffer_query_device (PlyVideoBuffer *buffer)
+ply_frame_buffer_query_device (PlyFrameBuffer *buffer)
{
struct fb_var_screeninfo variable_screen_info;
struct fb_fix_screeninfo fixed_screen_info;
}
static bool
-ply_video_buffer_map_to_device (PlyVideoBuffer *buffer)
+ply_frame_buffer_map_to_device (PlyFrameBuffer *buffer)
{
assert (buffer != NULL);
assert (buffer->device_fd >= 0);
}
static uint_least32_t
-ply_video_buffer_pixel_value_to_device_pixel_value (PlyVideoBuffer *buffer,
+ply_frame_buffer_pixel_value_to_device_pixel_value (PlyFrameBuffer *buffer,
uint32_t pixel_value)
{
uint8_t r, g, b, a;
blue = blue + blue_2 * (1.0 - alpha);
alpha = alpha + alpha_2 * (1.0 - alpha);
- return PLY_VIDEO_BUFFER_COLOR_TO_PIXEL_VALUE (red, green, blue, alpha);
+ return PLY_FRAME_BUFFER_COLOR_TO_PIXEL_VALUE (red, green, blue, alpha);
}
static uint32_t
blue *= opacity;
alpha *= opacity;
- return PLY_VIDEO_BUFFER_COLOR_TO_PIXEL_VALUE (red, green, blue, alpha);
+ return PLY_FRAME_BUFFER_COLOR_TO_PIXEL_VALUE (red, green, blue, alpha);
}
static void
-ply_video_buffer_blend_value_at_pixel (PlyVideoBuffer *buffer,
+ply_frame_buffer_blend_value_at_pixel (PlyFrameBuffer *buffer,
int x,
int y,
uint32_t pixel_value)
}
static void
-ply_video_buffer_fill_area_with_pixel_value (PlyVideoBuffer *buffer,
- PlyVideoBufferArea *area,
+ply_frame_buffer_fill_area_with_pixel_value (PlyFrameBuffer *buffer,
+ PlyFrameBufferArea *area,
uint32_t pixel_value)
{
long row, column;
{
for (column = area->x; column < area->x + area->width; column++)
{
- ply_video_buffer_blend_value_at_pixel (buffer,
+ ply_frame_buffer_blend_value_at_pixel (buffer,
column, row,
pixel_value);
}
}
static void
-ply_video_buffer_add_area_to_flush_area (PlyVideoBuffer *buffer,
- PlyVideoBufferArea *area)
+ply_frame_buffer_add_area_to_flush_area (PlyFrameBuffer *buffer,
+ PlyFrameBufferArea *area)
{
assert (buffer != NULL);
assert (area != NULL);
}
static bool
-ply_video_buffer_copy_to_device (PlyVideoBuffer *buffer,
+ply_frame_buffer_copy_to_device (PlyFrameBuffer *buffer,
unsigned long x,
unsigned long y,
unsigned long width,
pixel_value = buffer->shadow_buffer[width * row + column];
device_pixel_value =
- ply_video_buffer_pixel_value_to_device_pixel_value (buffer,
+ ply_frame_buffer_pixel_value_to_device_pixel_value (buffer,
pixel_value);
offset = row * bytes_per_row + column * buffer->bytes_per_pixel;
}
static bool
-ply_video_buffer_flush (PlyVideoBuffer *buffer)
+ply_frame_buffer_flush (PlyFrameBuffer *buffer)
{
assert (buffer != NULL);
unsigned long start_offset;
+ (buffer->area_to_flush.x * 4);
size = buffer->area_to_flush.width * buffer->area_to_flush.height;
- if (!ply_video_buffer_copy_to_device (buffer,
+ if (!ply_frame_buffer_copy_to_device (buffer,
buffer->area_to_flush.x,
buffer->area_to_flush.y,
buffer->area_to_flush.width,
return true;
}
-PlyVideoBuffer *
-ply_video_buffer_new (const char *device_name)
+PlyFrameBuffer *
+ply_frame_buffer_new (const char *device_name)
{
- PlyVideoBuffer *buffer;
+ PlyFrameBuffer *buffer;
- buffer = calloc (1, sizeof (PlyVideoBuffer));
+ buffer = calloc (1, sizeof (PlyFrameBuffer));
if (device_name != NULL)
buffer->device_name = strdup (device_name);
else
buffer->device_name =
- strdup (PLY_VIDEO_BUFFER_DEFAULT_FB_DEVICE_NAME);
+ strdup (PLY_FRAME_BUFFER_DEFAULT_FB_DEVICE_NAME);
buffer->map_address = MAP_FAILED;
buffer->shadow_buffer = NULL;
}
void
-ply_video_buffer_free (PlyVideoBuffer *buffer)
+ply_frame_buffer_free (PlyFrameBuffer *buffer)
{
assert (buffer != NULL);
- if (ply_video_buffer_device_is_open (buffer))
- ply_video_buffer_close (buffer);
+ if (ply_frame_buffer_device_is_open (buffer))
+ ply_frame_buffer_close (buffer);
free (buffer->device_name);
free (buffer->shadow_buffer);
}
bool
-ply_video_buffer_open (PlyVideoBuffer *buffer)
+ply_frame_buffer_open (PlyFrameBuffer *buffer)
{
bool is_open;
is_open = false;
- if (!ply_video_buffer_open_device (buffer))
+ if (!ply_frame_buffer_open_device (buffer))
{
goto out;
}
- if (!ply_video_buffer_query_device (buffer))
+ if (!ply_frame_buffer_query_device (buffer))
{
goto out;
}
- if (!ply_video_buffer_map_to_device (buffer))
+ if (!ply_frame_buffer_map_to_device (buffer))
{
goto out;
}
4 * buffer->area.width * buffer->area.height);
memset (buffer->shadow_buffer, 0,
4 * buffer->area.width * buffer->area.height);
- ply_video_buffer_fill_with_color (buffer, NULL, 0.0, 0.0, 0.0, 1.0);
+ ply_frame_buffer_fill_with_color (buffer, NULL, 0.0, 0.0, 0.0, 1.0);
is_open = true;
int saved_errno;
saved_errno = errno;
- ply_video_buffer_close_device (buffer);
+ ply_frame_buffer_close_device (buffer);
errno = saved_errno;
}
}
void
-ply_video_buffer_pause_updates (PlyVideoBuffer *buffer)
+ply_frame_buffer_pause_updates (PlyFrameBuffer *buffer)
{
assert (buffer != NULL);
}
bool
-ply_video_buffer_unpause_updates (PlyVideoBuffer *buffer)
+ply_frame_buffer_unpause_updates (PlyFrameBuffer *buffer)
{
assert (buffer != NULL);
buffer->is_paused = false;
- return ply_video_buffer_flush (buffer);
+ return ply_frame_buffer_flush (buffer);
}
bool
-ply_video_buffer_device_is_open (PlyVideoBuffer *buffer)
+ply_frame_buffer_device_is_open (PlyFrameBuffer *buffer)
{
assert (buffer != NULL);
return buffer->device_fd >= 0 && buffer->map_address != MAP_FAILED;
}
char *
-ply_video_buffer_get_device_name (PlyVideoBuffer *buffer)
+ply_frame_buffer_get_device_name (PlyFrameBuffer *buffer)
{
assert (buffer != NULL);
- assert (ply_video_buffer_device_is_open (buffer));
+ assert (ply_frame_buffer_device_is_open (buffer));
assert (buffer->device_name != NULL);
return strdup (buffer->device_name);
}
void
-ply_video_buffer_set_device_name (PlyVideoBuffer *buffer,
+ply_frame_buffer_set_device_name (PlyFrameBuffer *buffer,
const char *device_name)
{
assert (buffer != NULL);
- assert (!ply_video_buffer_device_is_open (buffer));
+ assert (!ply_frame_buffer_device_is_open (buffer));
assert (device_name != NULL);
assert (buffer->device_name != NULL);
}
void
-ply_video_buffer_close (PlyVideoBuffer *buffer)
+ply_frame_buffer_close (PlyFrameBuffer *buffer)
{
assert (buffer != NULL);
- assert (ply_video_buffer_device_is_open (buffer));
- ply_video_buffer_close_device (buffer);
+ assert (ply_frame_buffer_device_is_open (buffer));
+ ply_frame_buffer_close_device (buffer);
buffer->bytes_per_pixel = 0;
buffer->area.x = 0;
}
void
-ply_video_buffer_get_size (PlyVideoBuffer *buffer,
- PlyVideoBufferArea *size)
+ply_frame_buffer_get_size (PlyFrameBuffer *buffer,
+ PlyFrameBufferArea *size)
{
assert (buffer != NULL);
- assert (ply_video_buffer_device_is_open (buffer));
+ assert (ply_frame_buffer_device_is_open (buffer));
assert (size != NULL);
*size = buffer->area;
}
bool
-ply_video_buffer_fill_with_color (PlyVideoBuffer *buffer,
- PlyVideoBufferArea *area,
+ply_frame_buffer_fill_with_color (PlyFrameBuffer *buffer,
+ PlyFrameBufferArea *area,
double red,
double green,
double blue,
uint32_t pixel_value;
assert (buffer != NULL);
- assert (ply_video_buffer_device_is_open (buffer));
+ assert (ply_frame_buffer_device_is_open (buffer));
if (area == NULL)
area = &buffer->area;
green *= alpha;
blue *= alpha;
- pixel_value = PLY_VIDEO_BUFFER_COLOR_TO_PIXEL_VALUE (red, green, blue, alpha);
+ pixel_value = PLY_FRAME_BUFFER_COLOR_TO_PIXEL_VALUE (red, green, blue, alpha);
- ply_video_buffer_fill_area_with_pixel_value (buffer, area, pixel_value);
+ ply_frame_buffer_fill_area_with_pixel_value (buffer, area, pixel_value);
- ply_video_buffer_add_area_to_flush_area (buffer, area);
+ ply_frame_buffer_add_area_to_flush_area (buffer, area);
- return ply_video_buffer_flush (buffer);
+ return ply_frame_buffer_flush (buffer);
}
bool
-ply_video_buffer_fill_with_argb32_data_at_opacity (PlyVideoBuffer *buffer,
- PlyVideoBufferArea *area,
+ply_frame_buffer_fill_with_argb32_data_at_opacity (PlyFrameBuffer *buffer,
+ PlyFrameBufferArea *area,
unsigned long x,
unsigned long y,
unsigned long width,
long row, column;
assert (buffer != NULL);
- assert (ply_video_buffer_device_is_open (buffer));
+ assert (ply_frame_buffer_device_is_open (buffer));
if (area == NULL)
area = &buffer->area;
pixel_value = data[width * row + column];
pixel_value = make_pixel_value_translucent (pixel_value, opacity);
- ply_video_buffer_blend_value_at_pixel (buffer,
+ ply_frame_buffer_blend_value_at_pixel (buffer,
area->x + (column - x),
area->y + (row - y),
pixel_value);
}
}
- ply_video_buffer_add_area_to_flush_area (buffer, area);
+ ply_frame_buffer_add_area_to_flush_area (buffer, area);
- return ply_video_buffer_flush (buffer);
+ return ply_frame_buffer_flush (buffer);
}
bool
-ply_video_buffer_fill_with_argb32_data (PlyVideoBuffer *buffer,
- PlyVideoBufferArea *area,
+ply_frame_buffer_fill_with_argb32_data (PlyFrameBuffer *buffer,
+ PlyFrameBufferArea *area,
unsigned long x,
unsigned long y,
unsigned long width,
unsigned long height,
uint32_t *data)
{
- return ply_video_buffer_fill_with_argb32_data_at_opacity (buffer, area,
+ return ply_frame_buffer_fill_with_argb32_data_at_opacity (buffer, area,
x, y, width,
height, data, 1.0);
}
-#ifdef PLY_VIDEO_BUFFER_ENABLE_TEST
+#ifdef PLY_FRAME_BUFFER_ENABLE_TEST
#include <math.h>
#include <stdio.h>
}
static void
-animate_at_time (PlyVideoBuffer *buffer,
+animate_at_time (PlyFrameBuffer *buffer,
double time)
{
int x, y;
}
}
- ply_video_buffer_fill_with_argb32_data (buffer, NULL, 0, 0, 1024, 768, data);
+ ply_frame_buffer_fill_with_argb32_data (buffer, NULL, 0, 0, 1024, 768, data);
}
int
char **argv)
{
static unsigned int seed = 0;
- PlyVideoBuffer *buffer;
+ PlyFrameBuffer *buffer;
int exit_code;
exit_code = 0;
- buffer = ply_video_buffer_new (NULL);
+ buffer = ply_frame_buffer_new (NULL);
- if (!ply_video_buffer_open (buffer))
+ if (!ply_frame_buffer_open (buffer))
{
exit_code = errno;
perror ("could not open frame buffer");
usleep (1000000/30.);
}
- ply_video_buffer_close (buffer);
- ply_video_buffer_free (buffer);
+ ply_frame_buffer_close (buffer);
+ ply_frame_buffer_free (buffer);
return main (argc, argv);
}
-#endif /* PLY_VIDEO_BUFFER_ENABLE_TEST */
+#endif /* PLY_FRAME_BUFFER_ENABLE_TEST */
/* vim: ts=4 sw=2 expandtab autoindent cindent
- * ply-video-buffer.h - framebuffer abstraction
+ * ply-frame-buffer.h - framebuffer abstraction
*
* Copyright (C) 2007 Red Hat, Inc.
*
*
* Written By: Ray Strode <rstrode@redhat.com>
*/
-#ifndef PLY_VIDEO_BUFFER_H
-#define PLY_VIDEO_BUFFER_H
+#ifndef PLY_FRAME_BUFFER_H
+#define PLY_FRAME_BUFFER_H
#include <stdbool.h>
#include <stdint.h>
#include "ply-utils.h"
-typedef struct _PlyVideoBuffer PlyVideoBuffer;
-typedef struct _PlyVideoBufferArea PlyVideoBufferArea;
+typedef struct _PlyFrameBuffer PlyFrameBuffer;
+typedef struct _PlyFrameBufferArea PlyFrameBufferArea;
-struct _PlyVideoBufferArea
+struct _PlyFrameBufferArea
{
unsigned long x;
unsigned long y;
unsigned long height;
};
-#define PLY_VIDEO_BUFFER_COLOR_TO_PIXEL_VALUE(r,g,b,a) \
+#define PLY_FRAME_BUFFER_COLOR_TO_PIXEL_VALUE(r,g,b,a) \
(((uint8_t) (CLAMP (a * 255.0, 0.0, 255.0)) << 24) \
| ((uint8_t) (CLAMP (r * 255.0, 0.0, 255.0)) << 16) \
| ((uint8_t) (CLAMP (g * 255.0, 0.0, 255.0)) << 8) \
| ((uint8_t) (CLAMP (b * 255.0, 0.0, 255.0))))
#ifndef PLY_HIDE_FUNCTION_DECLARATIONS
-PlyVideoBuffer *ply_video_buffer_new (const char *device_name);
-void ply_video_buffer_free (PlyVideoBuffer *buffer);
-bool ply_video_buffer_open (PlyVideoBuffer *buffer);
-void ply_video_buffer_pause_updates (PlyVideoBuffer *buffer);
-bool ply_video_buffer_unpause_updates (PlyVideoBuffer *buffer);
-bool ply_video_buffer_device_is_open (PlyVideoBuffer *buffer);
-char *ply_video_buffer_get_device_name (PlyVideoBuffer *buffer);
-void ply_video_buffer_set_device_name (PlyVideoBuffer *buffer,
+PlyFrameBuffer *ply_frame_buffer_new (const char *device_name);
+void ply_frame_buffer_free (PlyFrameBuffer *buffer);
+bool ply_frame_buffer_open (PlyFrameBuffer *buffer);
+void ply_frame_buffer_pause_updates (PlyFrameBuffer *buffer);
+bool ply_frame_buffer_unpause_updates (PlyFrameBuffer *buffer);
+bool ply_frame_buffer_device_is_open (PlyFrameBuffer *buffer);
+char *ply_frame_buffer_get_device_name (PlyFrameBuffer *buffer);
+void ply_frame_buffer_set_device_name (PlyFrameBuffer *buffer,
const char *device_name);
-void ply_video_buffer_close (PlyVideoBuffer *buffer);
-void ply_video_buffer_get_size (PlyVideoBuffer *buffer,
- PlyVideoBufferArea *size);
-bool ply_video_buffer_fill_with_color (PlyVideoBuffer *buffer,
- PlyVideoBufferArea *area,
+void ply_frame_buffer_close (PlyFrameBuffer *buffer);
+void ply_frame_buffer_get_size (PlyFrameBuffer *buffer,
+ PlyFrameBufferArea *size);
+bool ply_frame_buffer_fill_with_color (PlyFrameBuffer *buffer,
+ PlyFrameBufferArea *area,
double red,
double green,
double blue,
double alpha);
-bool ply_video_buffer_fill_with_argb32_data (PlyVideoBuffer *buffer,
- PlyVideoBufferArea *area,
+bool ply_frame_buffer_fill_with_argb32_data (PlyFrameBuffer *buffer,
+ PlyFrameBufferArea *area,
unsigned long x,
unsigned long y,
unsigned long width,
unsigned long height,
uint32_t *data);
-bool ply_video_buffer_fill_with_argb32_data_at_opacity (PlyVideoBuffer *buffer,
- PlyVideoBufferArea *area,
+bool ply_frame_buffer_fill_with_argb32_data_at_opacity (PlyFrameBuffer *buffer,
+ PlyFrameBufferArea *area,
unsigned long x,
unsigned long y,
unsigned long width,
#endif
-#endif /* PLY_VIDEO_BUFFER_H */
+#endif /* PLY_FRAME_BUFFER_H */
projects / thirdparty / plymouth.git / commitdiff
