lib/gfx/gfx.c

/*
 * Copyright (c) 2008-2010 Travis Geiselbrecht
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files
 * (the "Software"), to deal in the Software without restriction,
 * including without limitation the rights to use, copy, modify, merge,
 * publish, distribute, sublicense, and/or sell copies of the Software,
 * and to permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

/**
 * @defgroup graphics Graphics
 *
 * @{
 */

/**
 * @file
 * @brief  Graphics drawing library
 */

#include <debug.h>
#include <string.h>
#include <stdlib.h>
#include <arch/ops.h>
#include <sys/types.h>
#include <lib/gfx.h>
#include <dev/display.h>

#define LOCAL_TRACE 0

static uint16_t ARGB8888_to_RGB565(uint32_t in)
{
	uint16_t out;

	out = (in >> 3) & 0x1f;    // b
	out |= ((in >> 10) & 0x3f) << 5;  // g
	out |= ((in >> 19) & 0x1f) << 11;  // r

	return out;
}

/**
 * @brief  Copy a rectangle of pixels from one part of the display to another.
 */
void gfx_copyrect(gfx_surface *surface, uint x, uint y, uint width, uint height, uint x2, uint y2)
{
	// trim
	if (x >= surface->width)
		return;
	if (x2 >= surface->width)
		return;
	if (y >= surface->height)
		return;
	if (y2 >= surface->height)
		return;
	if (width == 0 || height == 0)
		return;

	// clip the width to src or dest
	if (x + width > surface->width)
		width = surface->width - x;
	if (x2 + width > surface->width)
		width = surface->width - x2;

	// clip the height to src or dest
	if (y + height > surface->height)
		height = surface->height - y;
	if (y2 + height > surface->height)
		height = surface->height - y2;

	surface->copyrect(surface, x, y, width, height, x2, y2);
}

/**
 * @brief  Fill a rectangle on the screen with a constant color.
 */
void gfx_fillrect(gfx_surface *surface, uint x, uint y, uint width, uint height, uint color)
{
	LTRACEF("surface %p, x %u y %u w %u h %u c %u\n", surface, x, y, width, height, color);
	// trim
	if (unlikely(x >= surface->width))
		return;
	if (y >= surface->height)
		return;
	if (width == 0 || height == 0)
		return;

	// clip the width
	if (x + width > surface->width)
		width = surface->width - x;

	// clip the height
	if (y + height > surface->height)
		height = surface->height - y;

	surface->fillrect(surface, x, y, width, height, color);
}

/**
 * @brief  Write a single pixel to the screen.
 */
void gfx_putpixel(gfx_surface *surface, uint x, uint y, uint color)
{
	if (unlikely(x >= surface->width))
		return;
	if (y >= surface->height)
		return;

	surface->putpixel(surface, x, y, color);
}

static void putpixel16(gfx_surface *surface, uint x, uint y, uint color)
{
	uint16_t *dest = &((uint16_t *)surface->ptr)[x + y * surface->stride];

	// colors come in in ARGB 8888 form, flatten them
	*dest = ARGB8888_to_RGB565(color);
}

static void putpixel32(gfx_surface *surface, uint x, uint y, uint color)
{
	uint32_t *dest = &((uint32_t *)surface->ptr)[x + y * surface->stride];

	*dest = color;
}

static void copyrect16(gfx_surface *surface, uint x, uint y, uint width, uint height, uint x2, uint y2)
{
	// copy
	const uint16_t *src = &((const uint16_t *)surface->ptr)[x + y * surface->stride];
	uint16_t *dest = &((uint16_t *)surface->ptr)[x2 + y2 * surface->stride];
	uint stride_diff = surface->stride - width;

	if (dest < src) {
		uint i, j;
		for (i=0; i < height; i++) {
			for (j=0; j < width; j++) {
				*dest = *src;
				dest++;
				src++;
			}
			dest += stride_diff;
			src += stride_diff;
		}
	} else {
		// copy backwards
		src += height * surface->stride + width;
		dest += height * surface->stride + width;

		uint i, j;
		for (i=0; i < height; i++) {
			for (j=0; j < width; j++) {
				*dest = *src;
				dest--;
				src--;
			}
			dest -= stride_diff;
			src -= stride_diff;
		}
	}
}

static void fillrect16(gfx_surface *surface, uint x, uint y, uint width, uint height, uint color)
{
	uint16_t *dest = &((uint16_t *)surface->ptr)[x + y * surface->stride];
	uint stride_diff = surface->stride - width;

	uint16_t color16 = ARGB8888_to_RGB565(color);
	
	uint i, j;
	for (i=0; i < height; i++) {
		for (j=0; j < width; j++) {
			*dest = color16;
			dest++;
		}
		dest += stride_diff;
	}
}

static void copyrect32(gfx_surface *surface, uint x, uint y, uint width, uint height, uint x2, uint y2)
{
	// copy
	const uint32_t *src = &((const uint32_t *)surface->ptr)[x + y * surface->stride];
	uint32_t *dest = &((uint32_t *)surface->ptr)[x2 + y2 * surface->stride];
	uint stride_diff = surface->stride - width;

	if (dest < src) {
		uint i, j;
		for (i=0; i < height; i++) {
			for (j=0; j < width; j++) {
				*dest = *src;
				dest++;
				src++;
			}
			dest += stride_diff;
			src += stride_diff;
		}
	} else {
		// copy backwards
		src += height * surface->stride + width;
		dest += height * surface->stride + width;

		uint i, j;
		for (i=0; i < height; i++) {
			for (j=0; j < width; j++) {
				*dest = *src;
				dest--;
				src--;
			}
			dest -= stride_diff;
			src -= stride_diff;
		}
	}
}

static void fillrect32(gfx_surface *surface, uint x, uint y, uint width, uint height, uint color)
{
	uint32_t *dest = &((uint32_t *)surface->ptr)[x + y * surface->stride];
	uint stride_diff = surface->stride - width;
	
	uint i, j;
	for (i=0; i < height; i++) {
		for (j=0; j < width; j++) {
			*dest = color;
			dest++;
		}
		dest += stride_diff;
	}
}

uint32_t alpha32_add_ignore_destalpha(uint32_t dest, uint32_t src)
{
	uint32_t cdest[3];
	uint32_t csrc[3];

	uint32_t srca;
	uint32_t srcainv;

	srca = (src >> 24) & 0xff;
	if (srca == 0) {
		return dest;
	} else if (srca == 255) {
		return src;
	}
	srca++;
	srcainv = (255 - srca);

	cdest[0] = (dest >> 16) & 0xff;
	cdest[1] = (dest >> 8) & 0xff;
	cdest[2] = (dest >> 0) & 0xff;

	csrc[0] = (src >> 16) & 0xff;
	csrc[1] = (src >> 8) & 0xff;
	csrc[2] = (src >> 0) & 0xff;

//	if (srca > 0)
//		printf("s %d %d %d d %d %d %d a %d ai %d\n", csrc[0], csrc[1], csrc[2], cdest[0], cdest[1], cdest[2], srca, srcainv);

	uint32_t cres[3];

	cres[0] = ((csrc[0] * srca) / 256) + ((cdest[0] * srcainv) / 256);
	cres[1] = ((csrc[1] * srca) / 256) + ((cdest[1] * srcainv) / 256);
	cres[2] = ((csrc[2] * srca) / 256) + ((cdest[2] * srcainv) / 256);

	return (srca << 24) | (cres[0] << 16) | (cres[1] << 8) | (cres[2]);
}

/**
 * @brief  Copy pixels from source to dest.
 *
 * Currently does not support alpha channel.
 */
void gfx_surface_blend(struct gfx_surface *target, struct gfx_surface *source, uint destx, uint desty)
{
	DEBUG_ASSERT(target->format == source->format);

	LTRACEF("target %p, source %p, destx %u, desty %u\n", target, source, destx, desty);

	if (destx >= target->width)
		return;
	if (desty >= target->height)
		return;

	uint width = source->width;
	if (destx + width > target->width)
		width = target->width - destx;

	uint height = source->height;
	if (desty + height > target->height)
		height = target->height - desty;

	// XXX total hack to deal with various blends
	if (source->format == GFX_FORMAT_RGB_565 && target->format == GFX_FORMAT_RGB_565) {
		// 16 bit to 16 bit
		const uint16_t *src = (const uint16_t *)source->ptr;
		uint16_t *dest = &((uint16_t *)target->ptr)[destx + desty * target->stride];
		uint dest_stride_diff = target->stride - width;
		uint source_stride_diff = source->stride - width;

		LTRACEF("w %u h %u dstride %u sstride %u\n", width, height, dest_stride_diff, source_stride_diff);

		uint i, j;
		for (i=0; i < height; i++) {
			for (j=0; j < width; j++) {
				*dest = *src;
				dest++;
				src++;
			}
			dest += dest_stride_diff;
			src += source_stride_diff;
		}
	} else if (source->format == GFX_FORMAT_ARGB_8888 && target->format == GFX_FORMAT_ARGB_8888) {
		// both are 32 bit modes, both alpha
		const uint32_t *src = (const uint32_t *)source->ptr;
		uint32_t *dest = &((uint32_t *)target->ptr)[destx + desty * target->stride];
		uint dest_stride_diff = target->stride - width;
		uint source_stride_diff = source->stride - width;

		LTRACEF("w %u h %u dstride %u sstride %u\n", width, height, dest_stride_diff, source_stride_diff);

		uint i, j;
		for (i=0; i < height; i++) {
			for (j=0; j < width; j++) {
				// XXX ignores destination alpha
				*dest = alpha32_add_ignore_destalpha(*dest, *src);
				dest++;
				src++;
			}
			dest += dest_stride_diff;
			src += source_stride_diff;
		}
	} else if (source->format == GFX_FORMAT_RGB_x888 && target->format == GFX_FORMAT_RGB_x888) {
		// both are 32 bit modes, no alpha
		const uint32_t *src = (const uint32_t *)source->ptr;
		uint32_t *dest = &((uint32_t *)target->ptr)[destx + desty * target->stride];
		uint dest_stride_diff = target->stride - width;
		uint source_stride_diff = source->stride - width;

		LTRACEF("w %u h %u dstride %u sstride %u\n", width, height, dest_stride_diff, source_stride_diff);

		uint i, j;
		for (i=0; i < height; i++) {
			for (j=0; j < width; j++) {
				*dest = *src;
				dest++;
				src++;
			}
			dest += dest_stride_diff;
			src += source_stride_diff;
		}
	} else {
		panic("gfx_surface_blend: unimplemented colorspace combination (source %d target %d)\n", source->format, target->format);
	}
}

/**
 * @brief  Ensure all graphics rendering is sent to display
 */
void gfx_flush(gfx_surface *surface)
{
	arch_clean_cache_range((addr_t)surface->ptr, surface->len);

	if (surface->flush)
		surface->flush(0, surface->height-1);
}

/**
 * @brief  Ensure that a sub-region of the display is up to date.
 */
void gfx_flush_rows(struct gfx_surface *surface, uint start, uint end)
{
	if (start > end) {
		uint temp = start;
		start = end;
		end = temp;
	}

	if (start >= surface->height)
		return;
	if (end >= surface->height)
		end = surface->height - 1;

	arch_clean_cache_range((addr_t)surface->ptr + start * surface->stride * surface->pixelsize, (end - start + 1) * surface->stride * surface->pixelsize);

	if (surface->flush)
		surface->flush(start, end);

}


/**
 * @brief  Create a new graphics surface object
 */
gfx_surface *gfx_create_surface(void *ptr, uint width, uint height, uint stride, gfx_format format)
{
	DEBUG_ASSERT(width > 0);
	DEBUG_ASSERT(height > 0);
	DEBUG_ASSERT(stride >= width);
	DEBUG_ASSERT(format < GFX_FORMAT_MAX);

	gfx_surface *surface = malloc(sizeof(gfx_surface));

	surface->free_on_destroy = false;
	surface->format = format;
	surface->width = width;
	surface->height = height;
	surface->stride = stride;
	surface->alpha = MAX_ALPHA;

	// set up some function pointers
	switch (format) {
		case GFX_FORMAT_RGB_565:
			surface->copyrect = &copyrect16;
			surface->fillrect = &fillrect16;
			surface->putpixel = &putpixel16;
			surface->pixelsize = 2;
			surface->len = surface->height * surface->stride * surface->pixelsize;
			break;
		case GFX_FORMAT_RGB_x888:
		case GFX_FORMAT_ARGB_8888:
			surface->copyrect = &copyrect32;
			surface->fillrect = &fillrect32;
			surface->putpixel = &putpixel32;
			surface->pixelsize = 4;
			surface->len = surface->height * surface->stride * surface->pixelsize;
			break;
		default:
			dprintf(INFO, "invalid graphics format\n");
			DEBUG_ASSERT(0);
			free(surface);
			return NULL;
	}

	if (ptr == NULL) {
		// allocate a buffer
		ptr = malloc(surface->len);
		DEBUG_ASSERT(ptr);
		surface->free_on_destroy = true;
	}
	surface->ptr = ptr;

	return surface;
}

/**
 * @brief  Create a new graphics surface object from a display
 */
gfx_surface *gfx_create_surface_from_display(struct display_info *info)
{
	gfx_surface* surface;
	surface = gfx_create_surface(info->framebuffer, info->width, info->height, info->stride, info->format);

	surface->flush = info->flush;

	return surface;
}

/**
 * @brief  Destroy a graphics surface and free all resources allocated to it.
 *
 * @param  surface  Surface to destroy.  This pointer is no longer valid after
 * 		this call.
 */
void gfx_surface_destroy(struct gfx_surface *surface)
{
	if (surface->free_on_destroy)
		free(surface->ptr);
	free(surface);
}

/**
 * @brief  Write a test pattern to the default display.
 */
void gfx_draw_pattern(void)
{
	struct display_info info;
	display_get_info(&info);

	gfx_surface *surface = gfx_create_surface_from_display(&info);

	uint x, y;
	for (y = 0; y < surface->height; y++) {
		for (x = 0; x < surface->width; x++) {
			uint scaledx;
			uint scaledy;

			scaledx = x * 256 / surface->width;
			scaledy = y * 256 / surface->height;

			gfx_putpixel(surface, x, y, (scaledx * scaledy) << 16 | (scaledx >> 1) << 8 | scaledy >> 1);
		}
	}

	if (surface->flush)
		surface->flush(0, surface->height-1);

	gfx_surface_destroy(surface);
}

/**
 * @brief  Fill default display with white
 */
void gfx_draw_pattern_white(void)
{
	struct display_info info;
	display_get_info(&info);

	gfx_surface *surface = gfx_create_surface_from_display(&info);

	uint x, y;
	for (y = 0; y < surface->height; y++) {
		for (x = 0; x < surface->width; x++) {
			gfx_putpixel(surface, x, y, 0xFFFFFF);
		}
	}

	if (surface->flush)
		surface->flush(0, surface->height-1);

	gfx_surface_destroy(surface);
}

#if defined(WITH_LIB_CONSOLE)

#if DEBUGLEVEL > 1
#include <lib/console.h>

static int cmd_gfx(int argc, const cmd_args *argv);

STATIC_COMMAND_START
STATIC_COMMAND("gfx", "gfx commands", &cmd_gfx)
STATIC_COMMAND_END(gfx);

static int gfx_draw_rgb_bars(gfx_surface *surface)
{
	uint x, y;

	int step32 = surface->height*100 / 32;
	int step64 = surface->height*100 / 64;
	int color;

	for (y = 0; y < surface->height; y++) {
		//R
		for (x = 0; x < surface->width/3; x++) {
			color = y*100 / step32;
			gfx_putpixel(surface, x, y, color << 16);
		}
		//G
		for (;x < 2*(surface->width/3); x++) {
			color = y*100 / step64;
			gfx_putpixel(surface, x, y, color << 8);
		}
		//B
		for (;x < surface->width; x++) {
			color = y*100 / step32;
			gfx_putpixel(surface, x, y, color);
		}
	}

	return 0;
}


static int cmd_gfx(int argc, const cmd_args *argv)
{
	if (argc < 2) {
		printf("not enough arguments:\n");
usage:
		printf("%s rgb_bars		: Fill frame buffer with rgb bars\n", argv[0].str);
		printf("%s fill r g b	: Fill frame buffer with RGB565 value and force update\n", argv[0].str);

		return -1;
	}

	struct display_info info;
	display_get_info(&info);

	gfx_surface *surface = gfx_create_surface_from_display(&info);

	if (!strcmp(argv[1].str, "rgb_bars"))
	{
		gfx_draw_rgb_bars(surface);
	}
	else if (!strcmp(argv[1].str, "fill"))
	{
		uint x, y;

		for (y = 0; y < surface->height; y++)
		{
			for (x = 0; x < surface->width; x++)
			{
				/* write pixel to frame buffer */
				gfx_putpixel(surface, x, y, (argv[2].i << 16) | (argv[3].i << 8) | argv[4].i);
			}
		}
	}

	 if (surface->flush)
	 		surface->flush(0, surface->height-1);

	 gfx_surface_destroy(surface);

	 return 0;
}

#endif
#endif