/*
 * Copyright © 2004 David Reveman
 *
 * Permission to use, copy, modify, distribute, and sell this software
 * and its documentation for any purpose is hereby granted without
 * fee, provided that the above copyright notice appear in all copies
 * and that both that copyright notice and this permission notice
 * appear in supporting documentation, and that the name of
 * David Reveman not be used in advertising or publicity pertaining to
 * distribution of the software without specific, written prior permission.
 * David Reveman makes no representations about the suitability of this
 * software for any purpose. It is provided "as is" without express or
 * implied warranty.
 *
 * DAVID REVEMAN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
 * NO EVENT SHALL DAVID REVEMAN BE LIABLE FOR ANY SPECIAL, 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.
 *
 * Author: David Reveman <davidr@novell.com>
 */

#ifdef HAVE_CONFIG_H
#  include "../config.h"
#endif

#include "glitzint.h"


static glitz_gl_enum_t
_glitz_data_type (glitz_data_type_t type)
{
    switch (type) {
    case GLITZ_DATA_TYPE_SHORT:
	return GLITZ_GL_SHORT;
    case GLITZ_DATA_TYPE_INT:
	return GLITZ_GL_INT;
    case GLITZ_DATA_TYPE_DOUBLE:
	return GLITZ_GL_DOUBLE;
    default:
	return GLITZ_GL_FLOAT;
    }
}

void
glitz_set_geometry (glitz_surface_t         *dst,
		    glitz_geometry_type_t   type,
		    glitz_geometry_format_t *format,
		    glitz_buffer_t          *buffer)
{
    switch (type) {
    case GLITZ_GEOMETRY_TYPE_VERTEX:
    {
	glitz_buffer_reference (buffer);
	if (dst->geometry.buffer)
	    glitz_buffer_destroy (dst->geometry.buffer);
	dst->geometry.buffer = buffer;

	dst->geometry.type = GLITZ_GEOMETRY_TYPE_VERTEX;

	switch (format->vertex.primitive) {
	case GLITZ_PRIMITIVE_POINTS:
	    dst->geometry.u.v.prim = GLITZ_GL_POINTS;
	    break;
	case GLITZ_PRIMITIVE_LINES:
	    dst->geometry.u.v.prim = GLITZ_GL_LINES;
	    break;
	case GLITZ_PRIMITIVE_LINE_STRIP:
	    dst->geometry.u.v.prim = GLITZ_GL_LINE_STRIP;
	    break;
	case GLITZ_PRIMITIVE_LINE_LOOP:
	    dst->geometry.u.v.prim = GLITZ_GL_LINE_LOOP;
	    break;
	case GLITZ_PRIMITIVE_TRIANGLES:
	    dst->geometry.u.v.prim = GLITZ_GL_TRIANGLES;
	    break;
	case GLITZ_PRIMITIVE_TRIANGLE_STRIP:
	    dst->geometry.u.v.prim = GLITZ_GL_TRIANGLE_STRIP;
	    break;
	case GLITZ_PRIMITIVE_TRIANGLE_FAN:
	    dst->geometry.u.v.prim = GLITZ_GL_TRIANGLE_FAN;
	    break;
	case GLITZ_PRIMITIVE_QUADS:
	    dst->geometry.u.v.prim = GLITZ_GL_QUADS;
	    break;
	case GLITZ_PRIMITIVE_QUAD_STRIP:
	    dst->geometry.u.v.prim = GLITZ_GL_QUAD_STRIP;
	    break;
	default:
	    dst->geometry.u.v.prim = GLITZ_GL_POLYGON;
	    break;
	}

	dst->geometry.u.v.type = _glitz_data_type (format->vertex.type);
	dst->geometry.stride = format->vertex.bytes_per_vertex;
	dst->geometry.attributes = format->vertex.attributes;

	if (format->vertex.attributes & GLITZ_VERTEX_ATTRIBUTE_SRC_COORD_MASK)
	{
	    dst->geometry.u.v.src.type =
		_glitz_data_type (format->vertex.src.type);
	    dst->geometry.u.v.src.offset = format->vertex.src.offset;

	    if (format->vertex.src.size == GLITZ_COORDINATE_SIZE_XY)
		dst->geometry.u.v.src.size = 2;
	    else
		dst->geometry.u.v.src.size = 1;
	}

	if (format->vertex.attributes & GLITZ_VERTEX_ATTRIBUTE_MASK_COORD_MASK)
	{
	    dst->geometry.u.v.mask.type =
		_glitz_data_type (format->vertex.mask.type);
	    dst->geometry.u.v.mask.offset = format->vertex.mask.offset;

	    if (format->vertex.mask.size == GLITZ_COORDINATE_SIZE_XY)
		dst->geometry.u.v.mask.size = 2;
	    else
		dst->geometry.u.v.mask.size = 1;
	}
    } break;
    case GLITZ_GEOMETRY_TYPE_BITMAP:
	glitz_buffer_reference (buffer);
	if (dst->geometry.buffer)
	    glitz_buffer_destroy (dst->geometry.buffer);
	dst->geometry.buffer = buffer;

	dst->geometry.type = GLITZ_GEOMETRY_TYPE_BITMAP;

	if (format->bitmap.scanline_order ==
	    GLITZ_PIXEL_SCANLINE_ORDER_TOP_DOWN)
	    dst->geometry.u.b.top_down = 1;
	else
	    dst->geometry.u.b.top_down = 0;

	switch (format->bitmap.pad) {
	case 2:
	    dst->geometry.u.b.pad = 2;
	    break;
	case 4:
	    dst->geometry.u.b.pad = 4;
	    break;
	case 8:
	    dst->geometry.u.b.pad = 8;
	    break;
	default:
	    dst->geometry.u.b.pad = 1;
	    break;
	}

	dst->geometry.stride = format->bitmap.bytes_per_line;
	dst->geometry.attributes = 0;
	break;
    default:
	dst->geometry.type = GLITZ_GEOMETRY_TYPE_NONE;
	if (dst->geometry.buffer)
	    glitz_buffer_destroy (dst->geometry.buffer);

	dst->geometry.buffer = NULL;
	dst->geometry.attributes = 0;
	break;
    }
}
slim_hidden_def(glitz_set_geometry);

void
glitz_set_array (glitz_surface_t    *dst,
		 int                first,
		 int                size,
		 unsigned int       count,
		 glitz_fixed16_16_t x_off,
		 glitz_fixed16_16_t y_off)
{
    if (dst->geometry.array)
    {
	glitz_multi_array_destroy (dst->geometry.array);
	dst->geometry.array = NULL;
    }

    dst->geometry.first    = first;
    dst->geometry.size     = size;
    dst->geometry.count    = count;
    dst->geometry.off.v[0] = FIXED_TO_FLOAT (x_off);
    dst->geometry.off.v[1] = FIXED_TO_FLOAT (y_off);
}
slim_hidden_def(glitz_set_array);

glitz_multi_array_t *
glitz_multi_array_create (unsigned int size)
{
    glitz_multi_array_t *array;
    int                 alloc_size;

    if (!size)
	return NULL;

    alloc_size = sizeof (glitz_multi_array_t) + (sizeof (int) +
						 sizeof (int) +
						 sizeof (unsigned int) +
						 sizeof (glitz_vec2_t) +
						 sizeof (int)) * (size);

    array = (glitz_multi_array_t *) malloc (alloc_size);
    if (array == NULL)
	return NULL;

    array->ref_count = 1;
    array->size      = size;
    array->first     = (int *)          (array + 1);
    array->sizes     = (int *)          (array->first + size);
    array->count     = (int *)          (array->sizes + size);
    array->off       = (glitz_vec2_t *) (array->count + size);
    array->span      = (int *)          (array->off   + size);

    array->n_arrays = 0;

    return array;
}
slim_hidden_def(glitz_multi_array_create);

void
glitz_multi_array_destroy (glitz_multi_array_t *array)
{
    if (!array)
	return;

    array->ref_count--;
    if (array->ref_count)
	return;

    free (array);
}

void
glitz_multi_array_reference (glitz_multi_array_t *array)
{
    if (array == NULL)
	return;

    array->ref_count++;
}

void
glitz_multi_array_add (glitz_multi_array_t *array,
		       int                 first,
		       int                 size,
		       unsigned int        count,
		       glitz_fixed16_16_t  x_off,
		       glitz_fixed16_16_t  y_off)
{
    int i;

    if (array->size == array->n_arrays)
	return;

    i = array->n_arrays++;

    array->first[i] = first;
    array->sizes[i] = size;
    array->count[i] = count;
    array->span[i]  = 0;

    if (i == 0 || x_off || y_off)
    {
	array->off[i].v[0]  = FIXED_TO_FLOAT (x_off);
	array->off[i].v[1]  = FIXED_TO_FLOAT (y_off);
	array->current_span = &array->span[i];
    }

    (*array->current_span)++;
}
slim_hidden_def(glitz_multi_array_add);

void
glitz_multi_array_reset (glitz_multi_array_t *array)
{
    array->n_arrays = 0;
}
slim_hidden_def(glitz_multi_array_reset);

void
glitz_set_multi_array (glitz_surface_t     *dst,
		       glitz_multi_array_t *array,
		       glitz_fixed16_16_t  x_off,
		       glitz_fixed16_16_t  y_off)
{
    glitz_multi_array_reference (array);

    if (dst->geometry.array)
	glitz_multi_array_destroy (dst->geometry.array);

    dst->geometry.array = array;
    dst->geometry.count = array->n_arrays;
    dst->geometry.off.v[0] = FIXED_TO_FLOAT (x_off);
    dst->geometry.off.v[1] = FIXED_TO_FLOAT (y_off);
}
slim_hidden_def(glitz_set_multi_array);

void
glitz_geometry_enable_none (glitz_gl_proc_address_list_t *gl,
			    glitz_surface_t              *dst,
			    glitz_box_t                  *box)
{
    dst->geometry.data[0] = (glitz_float_t) box->x1;
    dst->geometry.data[1] = (glitz_float_t) box->y1;
    dst->geometry.data[2] = (glitz_float_t) box->x2;
    dst->geometry.data[3] = (glitz_float_t) box->y1;
    dst->geometry.data[4] = (glitz_float_t) box->x2;
    dst->geometry.data[5] = (glitz_float_t) box->y2;
    dst->geometry.data[6] = (glitz_float_t) box->x1;
    dst->geometry.data[7] = (glitz_float_t) box->y2;

    gl->vertex_pointer (2, GLITZ_GL_FLOAT, 0, dst->geometry.data);
}

void
glitz_geometry_enable (glitz_gl_proc_address_list_t *gl,
		       glitz_surface_t              *dst,
		       glitz_box_t                  *box)
{
    switch (dst->geometry.type) {
    case GLITZ_GEOMETRY_TYPE_VERTEX:
	gl->vertex_pointer (2, dst->geometry.u.v.type, dst->geometry.stride,
			    glitz_buffer_bind (dst->geometry.buffer,
					       GLITZ_GL_ARRAY_BUFFER));
	break;
    case GLITZ_GEOMETRY_TYPE_BITMAP:
	dst->geometry.u.b.base =
	    glitz_buffer_bind (dst->geometry.buffer,
			       GLITZ_GL_PIXEL_UNPACK_BUFFER);

	gl->pixel_store_i (GLITZ_GL_UNPACK_SKIP_PIXELS, 0);
	gl->pixel_store_i (GLITZ_GL_UNPACK_SKIP_ROWS, 0);

#if BITMAP_BIT_ORDER == MSBFirst
	gl->pixel_store_i (GLITZ_GL_UNPACK_LSB_FIRST, GLITZ_GL_FALSE);
#else
	gl->pixel_store_i (GLITZ_GL_UNPACK_LSB_FIRST, GLITZ_GL_TRUE);
#endif

	break;
    case GLITZ_GEOMETRY_TYPE_NONE:
	glitz_geometry_enable_none (gl, dst, box);
    }
}

void
glitz_geometry_disable (glitz_surface_t *dst)
{
    if (dst->geometry.buffer)
	glitz_buffer_unbind (dst->geometry.buffer);
}

static void
_glitz_draw_rectangle (glitz_gl_proc_address_list_t *gl,
		       glitz_surface_t              *dst,
		       glitz_box_t                  *bounds,
		       int                          damage)
{
    glitz_box_t *clip = dst->clip;
    int         n_clip = dst->n_clip;
    glitz_box_t box;

    while (n_clip--)
    {
	box.x1 = clip->x1 + dst->x_clip;
	box.y1 = clip->y1 + dst->y_clip;
	box.x2 = clip->x2 + dst->x_clip;
	box.y2 = clip->y2 + dst->y_clip;
	if (bounds->x1 > box.x1)
	    box.x1 = bounds->x1;
	if (bounds->y1 > box.y1)
	    box.y1 = bounds->y1;
	if (bounds->x2 < box.x2)
	    box.x2 = bounds->x2;
	if (bounds->y2 < box.y2)
	    box.y2 = bounds->y2;

	if (box.x1 < box.x2 && box.y1 < box.y2)
	{
	    gl->scissor (box.x1 + dst->x,
			 dst->attached->height - dst->y - box.y2,
			 box.x2 - box.x1, box.y2 - box.y1);

	    gl->draw_arrays (GLITZ_GL_QUADS, 0, 4);

	    if (damage)
		glitz_surface_damage (dst, &box, damage);
	}

	clip++;
    }
}

#define MULTI_DRAW_ARRAYS(surface)                      \
    ((surface)->drawable->backend->feature_mask &       \
     GLITZ_FEATURE_MULTI_DRAW_ARRAYS_MASK)

static void
_glitz_draw_vertex_arrays (glitz_gl_proc_address_list_t *gl,
			   glitz_surface_t              *dst,
			   glitz_box_t                  *bounds,
			   int                          damage)
{
    glitz_multi_array_t *array = dst->geometry.array;
    glitz_box_t         *clip = dst->clip;
    int                 i, n_clip = dst->n_clip;
    glitz_box_t         box;

    while (n_clip--)
    {
	box.x1 = clip->x1 + dst->x_clip;
	box.y1 = clip->y1 + dst->y_clip;
	box.x2 = clip->x2 + dst->x_clip;
	box.y2 = clip->y2 + dst->y_clip;
	if (bounds->x1 > box.x1)
	    box.x1 = bounds->x1;
	if (bounds->y1 > box.y1)
	    box.y1 = bounds->y1;
	if (bounds->x2 < box.x2)
	    box.x2 = bounds->x2;
	if (bounds->y2 < box.y2)
	    box.y2 = bounds->y2;

	if (box.x1 < box.x2 && box.y1 < box.y2)
	{
	    gl->scissor (box.x1 + dst->x,
			 dst->attached->height - dst->y - box.y2,
			 box.x2 - box.x1, box.y2 - box.y1);

	    gl->push_matrix ();

	    if (dst->geometry.off.v[0] || dst->geometry.off.v[1])
		gl->translate_f (dst->geometry.off.v[0],
				 dst->geometry.off.v[1], 0.0f);

	    if (array)
	    {
		for (i = 0; i < array->n_arrays;)
		{
		    gl->translate_f (array->off[i].v[0],
				     array->off[i].v[1], 0.0f);

		    if (MULTI_DRAW_ARRAYS (dst))
		    {
			gl->multi_draw_arrays (dst->geometry.u.v.prim,
					       &array->first[i],
					       &array->count[i],
					       array->span[i]);
			i += array->span[i];
		    }
		    else
		    {
			do {
			    if (array->count[i])
				gl->draw_arrays (dst->geometry.u.v.prim,
						 array->first[i],
						 array->count[i]);

			} while (array->span[++i] == 0);
		    }
		}
	    } else
		gl->draw_arrays (dst->geometry.u.v.prim,
				 dst->geometry.first,
				 dst->geometry.count);

	    gl->pop_matrix ();

	    if (damage)
		glitz_surface_damage (dst, &box, damage);
	}

	clip++;
    }
}

#define N_STACK_BITMAP 128

#define BITMAP_PAD 4
#define BITMAP_STRIDE(x, w, a)                                  \
    (((((x) & 3) + (w) + (((a) << 3) - 1)) / ((a) << 3)) * (a))

#define BITMAP_SETUP(dst, first, size, count, _w, _h, _b_off, _p_off)   \
    (_w)     = (size);                                                  \
    (_h)     = (count);                                                 \
    (_b_off) = (first) >> 3;                                            \
    if ((_p_off) != ((first) & 3))                                      \
    {                                                                   \
	(_p_off) = (first) & 3;                                         \
	gl->pixel_store_i (GLITZ_GL_UNPACK_SKIP_PIXELS, _p_off);        \
    }                                                                   \
    if ((dst)->geometry.u.b.top_down)                                   \
    {                                                                   \
	dst_stride = BITMAP_STRIDE ((first), _w, BITMAP_PAD);           \
	if ((dst)->geometry.stride)                                     \
	    src_stride = (dst)->geometry.stride;                        \
	else                                                            \
	    src_stride = BITMAP_STRIDE ((first), _w,                    \
					(dst)->geometry.u.b.pad);       \
	min_stride = MIN (src_stride, dst_stride);                      \
	base = (dst)->geometry.u.b.base + (_b_off);                     \
	y = (_h);                                                       \
	while (y--)                                                     \
	    memcpy (bitmap + ((_h) - 1 - y) * dst_stride,               \
		    base + y * src_stride,                              \
		    min_stride);                                        \
	(_b_off) = 0;                                                   \
    }

/* TODO: clipping could be done without glScissor, that might be
   faster. Other then solid colors can be used if bitmap fits into a
   stipple pattern. Maybe we should add a repeat parameter to
   glitz_bitmap_format_t as 2, 4, 8, 16 and 32 sized bitmaps can be tiled.
*/
static void
_glitz_draw_bitmap_arrays (glitz_gl_proc_address_list_t *gl,
			   glitz_surface_t              *dst,
			   glitz_box_t                  *bounds,
			   int                          damage)
{
    glitz_multi_array_t *array = dst->geometry.array;
    glitz_box_t         *clip = dst->clip;
    int                 n, i, n_clip = dst->n_clip;
    int                 x, y, w, h, min_stride, dst_stride, src_stride;
    glitz_gl_ubyte_t    *heap_bitmap = NULL;
    glitz_gl_ubyte_t    stack_bitmap[N_STACK_BITMAP];
    glitz_gl_ubyte_t    *base, *bitmap = dst->geometry.u.b.base;
    int                 byte_offset, pixel_offset = 0;
    glitz_float_t       x_off, y_off;
    glitz_box_t         box;

    if (dst->geometry.u.b.top_down)
    {
	int max_size = 0;

	if (array)
	{
	    int size;

	    for (i = 0, n = array->n_arrays; n--; i++)
	    {
		x = array->first[i];
		w = array->sizes[i];
		size = BITMAP_STRIDE (x, w, BITMAP_PAD) * array->count[i];
		if (size > max_size)
		    max_size = size;
	    }
	}
	else
	{
	    x = dst->geometry.first;
	    w = dst->geometry.size;
	    max_size = BITMAP_STRIDE (x, w, BITMAP_PAD) * dst->geometry.count;
	}

	if (max_size > N_STACK_BITMAP)
	{
	    heap_bitmap = malloc (max_size);
	    if (!heap_bitmap)
	    {
		glitz_surface_status_add (dst, GLITZ_STATUS_NO_MEMORY_MASK);
		return;
	    }
	    bitmap = heap_bitmap;
	} else
	    bitmap = stack_bitmap;

	gl->pixel_store_i (GLITZ_GL_UNPACK_ALIGNMENT, BITMAP_PAD);
	gl->pixel_store_i (GLITZ_GL_UNPACK_ROW_LENGTH, 0);
    }
    else
    {
	gl->pixel_store_i (GLITZ_GL_UNPACK_ALIGNMENT, dst->geometry.u.b.pad);
	gl->pixel_store_i (GLITZ_GL_UNPACK_ROW_LENGTH,
			   dst->geometry.stride * 8);
    }

    while (n_clip--)
    {
	box.x1 = clip->x1 + dst->x_clip;
	box.y1 = clip->y1 + dst->y_clip;
	box.x2 = clip->x2 + dst->x_clip;
	box.y2 = clip->y2 + dst->y_clip;
	if (bounds->x1 > box.x1)
	    box.x1 = bounds->x1;
	if (bounds->y1 > box.y1)
	    box.y1 = bounds->y1;
	if (bounds->x2 < box.x2)
	    box.x2 = bounds->x2;
	if (bounds->y2 < box.y2)
	    box.y2 = bounds->y2;

	if (box.x1 < box.x2 && box.y1 < box.y2)
	{
	    gl->scissor (box.x1 + dst->x,
			 dst->attached->height - dst->y - box.y2,
			 box.x2 - box.x1, box.y2 - box.y1);

	    x_off = dst->x + dst->geometry.off.v[0];
	    y_off = dst->y + dst->geometry.off.v[1];

	    if (array)
	    {
		x_off += array->off->v[0];
		y_off += array->off->v[1];

		glitz_set_raster_pos (gl, x_off,
				      dst->attached->height - y_off);

		for (i = 0, n = array->n_arrays; n--; i++)
		{
		    if (n)
		    {
			x_off = array->off[i + 1].v[0];
			y_off = array->off[i + 1].v[1];
		    }

		    BITMAP_SETUP (dst,
				  array->first[i],
				  array->sizes[i],
				  array->count[i],
				  w, h, byte_offset, pixel_offset);

		    gl->bitmap (w, h,
				0.0f, (glitz_gl_float_t) array->count[i],
				x_off, -y_off,
				bitmap + byte_offset);
		}
	    }
	    else
	    {
		glitz_set_raster_pos (gl, x_off,
				      dst->attached->height - y_off);

		BITMAP_SETUP (dst,
			      dst->geometry.first,
			      dst->geometry.size,
			      dst->geometry.count,
			      w, h, byte_offset, pixel_offset);

		gl->bitmap (w, h,
			    0.0f, (glitz_gl_float_t) dst->geometry.count,
			    0.0f, 0.0f,
			    bitmap + byte_offset);
	    }

	    if (damage)
		glitz_surface_damage (dst, &box, damage);
	}

	clip++;
    }

    if (heap_bitmap)
	free (heap_bitmap);
}

void
glitz_geometry_draw_arrays (glitz_gl_proc_address_list_t *gl,
			    glitz_surface_t              *dst,
			    glitz_geometry_type_t        type,
			    glitz_box_t                  *bounds,
			    int                          damage)
{
    switch (type) {
    case GLITZ_GEOMETRY_TYPE_VERTEX:
	_glitz_draw_vertex_arrays (gl, dst, bounds, damage);
	break;
    case GLITZ_GEOMETRY_TYPE_BITMAP:
	_glitz_draw_bitmap_arrays (gl, dst, bounds, damage);
	break;
    case GLITZ_GEOMETRY_TYPE_NONE:
	_glitz_draw_rectangle (gl, dst, bounds, damage);
	break;
    }
}