diff Plugins/Visualization/paranormal/pn/pnimage.c @ 1507:0c5fdcf3f947 trunk

[svn] - incomplete stuff

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Plugins/Visualization/paranormal/pn/pnimage.c	Sun Aug 06 01:53:29 2006 -0700
@@ -0,0 +1,683 @@
+/* Paranormal - A highly customizable audio visualization library
+ * Copyright (C) 2001  Jamie Gennis <[e-mail]>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <config.h>
+
+#include <glib.h>
+#include "pnimage.h"
+#include "pnerror.h"
+#include "pncpu.h"
+
+static void         pn_image_class_init       (PnImageClass *class);
+static void         pn_image_init             (PnImage *image,
+					       PnImageClass *class);
+
+/* GObject signals */
+static void         pn_image_finalize         (GObject *gobject);
+
+static PnObjectClass *parent_class = NULL;
+
+const gchar *pn_image_blend_mode_strings[] =
+{
+  "Ignore",
+  "Replace",
+  "50/50"
+};
+const guint pn_image_blend_mode_count = 3;
+
+GType
+pn_image_get_type (void)
+{
+  static GType image_type = 0;
+
+  if (! image_type)
+    {
+      static const GTypeInfo image_info =
+      {
+	sizeof (PnImageClass),
+	NULL,		/* base_init */
+	NULL,		/* base_finalize */
+	(GClassInitFunc) pn_image_class_init,
+	NULL,		/* class_finalize */
+	NULL,		/* class_data */
+        sizeof (PnImage),
+	0,              /* n_preallocs */
+	(GInstanceInitFunc) pn_image_init
+      };
+
+      /* FIXME: should this be dynamic? */
+      image_type = g_type_register_static (PN_TYPE_OBJECT,
+					 "PnImage",
+					 &image_info,
+					 0);
+    }
+  return image_type;
+}
+
+static void
+pn_image_class_init (PnImageClass *class)
+{
+  GObjectClass *gobject_class;
+  PnObjectClass *object_class;
+
+  parent_class = g_type_class_peek_parent (class);
+
+  gobject_class = (GObjectClass *) class;
+  object_class = (PnObjectClass *) class;
+
+  /* GObject signals */
+  gobject_class->finalize = pn_image_finalize;
+}
+
+static void
+pn_image_init (PnImage *image, PnImageClass *class)
+{
+  image->render_mode = PN_BLEND_MODE_REPLACE;
+  image->transform_mode = PN_BLEND_MODE_REPLACE;
+}
+
+static void
+pn_image_finalize (GObject *gobject)
+{
+  PnImage *image;
+
+  image = (PnImage *) gobject;
+
+  if (image->image_buffer)
+    g_free (image->image_buffer);
+
+  if (image->transform_buffer)
+    g_free (image->transform_buffer);
+}
+
+/**
+ * pn_image_new
+ *
+ * Creates a new #PnImage object
+ *
+ * Returns: The new #PnImage object
+ */
+PnImage*
+pn_image_new (void)
+{
+  return (PnImage *) g_object_new (PN_TYPE_IMAGE, NULL);
+}
+
+/**
+ * pn_image_new_width_size
+ * @width: the width of the new image
+ * @height: the hight of the new image
+ *
+ * Creates a new #PnImage object with the given dimensions
+ *
+ * Returns: The new #PnImage object
+ */
+PnImage*
+pn_image_new_with_size (guint width, guint height)
+{
+  PnImage *image;
+
+  image = (PnImage *) g_object_new (PN_TYPE_IMAGE, NULL);
+
+  pn_image_set_size (image, width, height);
+
+  return image;
+}
+
+/**
+ * pn_image_set_size
+ * @image: a #PnImage
+ * @width: the new width of the image
+ * @height: the new height of the image
+ *
+ * Sets the size of the image contained in a #PnImage object
+ */
+void
+pn_image_set_size (PnImage *image, guint width, guint height)
+{
+  guint pitch;
+
+  g_return_if_fail (image != NULL);
+  g_return_if_fail (PN_IS_IMAGE (image));
+  g_return_if_fail (width > 0 && height > 0);
+
+  pitch = width * sizeof (PnColor);
+
+  /* Align each row to 8 bytes */
+  if (pitch & 0x00000007)
+    pitch = (pitch & 0xfffffff8) + 8;
+
+  if (image->image_buffer)
+    g_free (image->image_buffer);
+
+  if (image->transform_buffer)
+    g_free (image->transform_buffer);
+
+  image->pitch = pitch;
+  image->width = width;
+  image->height = height;
+  image->image_buffer = g_malloc0 (pitch * height);
+  image->transform_buffer = g_malloc0 (pitch * height);
+}
+
+/**
+ * pn_image_get_width
+ * @image: a #PnImage
+ *
+ * Gets the width of a #PnImage
+ *
+ * Returns: The width of the image
+ */
+guint
+pn_image_get_width (PnImage *image)
+{
+  g_return_val_if_fail (image != NULL, 0);
+  g_return_val_if_fail (PN_IS_IMAGE (image), 0);
+
+  return image->width;
+}
+
+/**
+ * pn_image_get_height
+ * @image: a #PnImage
+ *
+ * Gets the height of a #PnImage
+ *
+ * Returns: The height of the image
+ */
+guint
+pn_image_get_height (PnImage *image)
+{
+  g_return_val_if_fail (image != NULL, 0);
+  g_return_val_if_fail (PN_IS_IMAGE (image), 0);
+
+  return image->height;
+}
+
+/**
+ * pn_image_get_pitch
+ * @image: a #PnImage
+ *
+ * Gets the pitch (width in bytes) of a #PnImage
+ *
+ * Returns: The pitch of the image
+ */
+guint
+pn_image_get_pitch (PnImage *image)
+{
+  g_return_val_if_fail (image != NULL, 0);
+  g_return_val_if_fail (PN_IS_IMAGE (image), 0);
+
+  return image->pitch;
+}
+
+/**
+ * pn_image_set_render_mode
+ * @image: a #PnImage
+ * @render_mode: the blend mode to use
+ *
+ * Sets the blend mode to be used by render functions.  The
+ * render functions are pn_image_render_pixel(),
+ * pn_image_render_pixel_by_offset(), and pn_image_render_line().
+ */
+void
+pn_image_set_render_mode (PnImage *image, PnBlendMode render_mode)
+{
+  g_return_if_fail (image != NULL);
+  g_return_if_fail (PN_IS_IMAGE (image));
+  g_return_if_fail (render_mode < PN_BLEND_MODE_LAST);
+
+  image->render_mode = render_mode;
+}
+
+/**
+ * pn_image_set_transform_mode
+ * @image: a #PnImage
+ * @transform_mode: the blend mode to use
+ *
+ * Sets the blend mode to be used by pn_image_apply_transform().
+ */
+void
+pn_image_set_transform_mode (PnImage *image, PnBlendMode transform_mode)
+{
+  g_return_if_fail (image != NULL);
+  g_return_if_fail (PN_IS_IMAGE (image));
+  g_return_if_fail (transform_mode < PN_BLEND_MODE_LAST);
+
+  image->transform_mode = transform_mode;
+}
+
+/**
+ * pn_image_get_image_buffer
+ * @image: a #PnImage
+ *
+ * Retrieves the image buffer (the 'front buffer') of a #PnImage.
+ *
+ * Returns: A pointer to the image buffer
+ */
+PnColor*
+pn_image_get_image_buffer (PnImage *image)
+{
+  g_return_val_if_fail (image != NULL, NULL);
+  g_return_val_if_fail (PN_IS_IMAGE (image), NULL);
+
+  return image->image_buffer;
+}
+
+/**
+ * pn_image_get_transform_buffer
+ * @image: a #PnImage
+ *
+ * Retrieves the transform buffer (the 'back buffer') of a #PnImage.
+ * The transform buffer should only be used internally by transform
+ * actuators.  *EVERY* pixel in the transform buffer *MUST* be set.
+ * The transform buffer can be 'copied' to the image buffer using
+ * pn_image_apply_transform().
+ *
+ * Returns: A pointer to the transform buffer
+ */
+PnColor*
+pn_image_get_transform_buffer (PnImage *image)
+{
+  g_return_val_if_fail (image != NULL, NULL);
+  g_return_val_if_fail (PN_IS_IMAGE (image), NULL);
+
+  return image->transform_buffer;
+}
+
+/**
+ * pn_image_render_pixel
+ * @image: a #PnImage
+ * @x: the x coordinate (left being 0)
+ * @y: the y coordinate (top being 0)
+ * @color: the color
+ *
+ * Renders a pixel to the image buffer of a #PnImage.  pn_image_set_render_mode()
+ * can be used to set the blend mode that is used by this function.
+ */
+void
+pn_image_render_pixel (PnImage *image, guint x, guint y, PnColor color)
+{
+  g_return_if_fail (image != NULL);
+  g_return_if_fail (PN_IS_IMAGE (image));
+  g_return_if_fail (image->image_buffer != NULL);
+
+  if (x > image->width || y > image->height)
+    return;
+
+  switch (image->render_mode)
+    {
+    case PN_BLEND_MODE_LAST: break;
+    case PN_BLEND_MODE_IGNORE:
+      break;
+
+    case PN_BLEND_MODE_REPLACE:
+      image->image_buffer[(y * (image->pitch>>2)) + x] = color;
+      break;
+
+    case PN_BLEND_MODE_5050:
+      image->image_buffer[(y * (image->pitch>>2)) + x].red =
+	(image->image_buffer[(y * (image->pitch>>2)) + x].red + color.red) >> 1;
+      image->image_buffer[(y * (image->pitch>>2)) + x].green =
+	(image->image_buffer[(y * (image->pitch>>2)) + x].green + color.green) >> 1;
+      image->image_buffer[(y * (image->pitch>>2)) + x].blue =
+	(image->image_buffer[(y * (image->pitch>>2)) + x].blue + color.blue) >> 1;
+      break;
+    }
+}
+
+/**
+ * pn_image_render_pixel_by_offset
+ * @image: a #PnImage
+ * @offset: the pixel offset (0 being the top left) NOTE: Use (pitch>>2) rather
+ * than width
+ * @color: the color
+ *
+ * Renders a pixel to the image buffer of a #PnImage based on a pixel offset rather than
+ * rectangular coordinates.  This function should be used if there is a more optimum way
+ * to calculate the offset than multiplying at every pixel.  pn_image_set_render_mode()
+ * can be used to set the blend mode that is used by this function.
+ */
+void
+pn_image_render_pixel_by_offset (PnImage *image, guint offset, PnColor color)
+{
+  g_return_if_fail (image != NULL);
+  g_return_if_fail (PN_IS_IMAGE (image));
+  g_return_if_fail (image->image_buffer != NULL);
+
+  if (offset > (image->pitch>>2) * image->height)
+    return;
+
+  switch (image->render_mode)
+    {
+    case PN_BLEND_MODE_LAST: break;
+    case PN_BLEND_MODE_IGNORE:
+      break;
+
+    case PN_BLEND_MODE_REPLACE:
+      image->image_buffer[offset] = color;
+      break;
+
+    case PN_BLEND_MODE_5050:
+      image->image_buffer[offset].red =
+	(image->image_buffer[offset].red + color.red) >> 1;
+      image->image_buffer[offset].green =
+	(image->image_buffer[offset].green + color.green) >> 1;
+      image->image_buffer[offset].blue =
+	(image->image_buffer[offset].blue + color.blue) >> 1;
+      break;
+    }
+}
+
+/* FIXME: Add clipping to this */
+/**
+ * pn_image_render_line
+ * @image: a #PnImage
+ * @x0: the x coordinate of the first point
+ * @y0: the y coordinate of the first point
+ * @x1: the x coordinate of the second point
+ * @y1: the y coordinate of the second point
+ * @color: the color
+ *
+ * Renders a line from (x0,y0) to (x1,y1) to the image buffer of a #PnImage.
+ * Currently ***NO CLIPPING IS CURRENTLY DONE!!!***
+ */
+void
+pn_image_render_line (PnImage *image, guint _x0, guint _y0, guint _x1, guint _y1, PnColor color)
+{
+  gint x0 = _x0;
+  gint y0 = _y0;
+  gint x1 = _x1;
+  gint y1 = _y1;
+
+  gint dy = y1 - y0;
+  gint dx = x1 - x0;
+  gint stepx, stepy;
+  gint fraction;
+
+  g_return_if_fail (image != NULL);
+  g_return_if_fail (PN_IS_IMAGE (image));
+  g_return_if_fail (image->image_buffer != NULL);
+
+  if (dy < 0)
+    {
+      dy = -dy;
+      stepy = -(image->pitch>>2);
+    }
+  else
+    {
+      stepy = image->pitch>>2;
+    }
+  if (dx < 0)
+    {
+      dx = -dx;
+      stepx = -1;
+    }
+  else
+    {
+      stepx = 1;
+    }
+  dy <<= 1;
+  dx <<= 1;
+
+  y0 *= image->pitch>>2;
+  y1 *= image->pitch>>2;
+  pn_image_render_pixel_by_offset(image, x0+y0, color);
+  if (dx > dy)
+    {
+      fraction = dy - (dx >> 1);
+      while (x0 != x1)
+	{
+	  if (fraction >= 0)
+	    {
+	      y0 += stepy;
+	      fraction -= dx;
+	    }
+	  x0 += stepx;
+	  fraction += dy;
+	  pn_image_render_pixel_by_offset (image, x0+y0, color);
+	}
+    }
+  else
+    {
+      fraction = dx - (dy >> 1);
+      while (y0 != y1)
+	{
+	  if (fraction >= 0)
+	    {
+	      x0 += stepx;
+	      fraction -= dy;
+	    }
+	  y0 += stepy;
+	  fraction += dx;
+	  pn_image_render_pixel_by_offset (image, x0+y0, color);
+	}
+    }
+}
+
+static void
+pn_image_bufcopy_5050 (PnColor *dest, PnColor *src, guint bufsize)
+{
+  register guint i;
+  register PnColor *d, *s;
+
+  d = dest;
+  s = src;
+
+  for (i=0; i<bufsize; i++)
+    {
+      d->red = (s->red + d->red) >> 1;
+      d->green = (s->green + d->green) >> 1;
+      d->blue = (s->blue + d->blue) >> 1;
+      d++;
+      s++;
+    }
+}
+
+#ifdef PN_USE_MMX
+static void
+pn_image_bufcopy_5050_mmx (PnColor *dest, PnColor *src, guint bufsize)
+{
+  __asm__ __volatile__ (
+			"pxor %%mm7,%%mm7\n\t"      /* zero mm7 */
+
+			"10:\n\t"                   /* The start of the loop */
+
+			"movq (%0),%%mm0\n\t"       /* Read the pixels */
+			"movq (%1),%%mm2\n\t"
+			"movq %%mm0,%%mm1\n\t"
+			"movq %%mm2,%%mm3\n\t"
+
+			"punpcklbw %%mm7,%%mm0\n\t" /* Unpack the pixels */
+			"punpckhbw %%mm7,%%mm1\n\t"
+			"punpcklbw %%mm7,%%mm2\n\t"
+			"punpckhbw %%mm7,%%mm3\n\t"
+
+			"paddw %%mm2,%%mm0\n\t"     /* Add the pixels */
+			"paddw %%mm3,%%mm1\n\t"
+
+			"psrlw $1,%%mm0\n\t"        /* Divide the pixels by 2 */
+			"psrlw $1,%%mm1\n\t"
+
+			"packuswb %%mm1,%%mm0\n\t"  /* Pack it up & write it */
+			"movq %%mm0,(%0)\n\t"
+
+			"addl $8,%0\n\t"            /* Advance the pointers */
+			"addl $8,%1\n\t"
+
+			"decl %2\n\t"               /* See if we're done */
+			"jnz 10b\n\t"
+
+			"emms"
+			: /* no outputs */
+			: "r" (dest), "r" (src), "r" (bufsize >> 1)
+			);
+}
+
+/* FIXME: Should this be in a separate #define PN_USE_MMXEXT ? */
+static void
+pn_image_bufcopy_5050_mmxext (PnColor *dest, PnColor *src, guint bufsize)
+{
+  
+
+  __asm__ __volatile__ (
+			"10:\n\t"                   /* The non-unrolled loop */
+
+			"decl %2\n\t"               /* See if we're done */
+			"js 20f\n\t"
+
+			"movq (%0),%%mm0\n\t"       /* Read the pixels */
+			"movq (%1),%%mm1\n\t"
+			"pavgb %%mm1,%%mm0\n\t"     /* Average the pixels */
+
+			"movq %%mm0,(%0)\n\t"       /* Write the pixels */
+
+			"addl $8,%0\n\t"            /* Advance the pointers */
+			"addl $8,%1\n\t"
+
+			"20:\n\t"                   /* The unrolled loop */
+
+			"decl %3\n\t"               /* See if we're done */
+			"js 30f\n\t"
+
+			/* First 2 pixels */
+			"movq (%0),%%mm0\n\t"       /* Read the pixels */
+			"movq (%1),%%mm1\n\t"
+			"pavgb %%mm1,%%mm0\n\t"     /* Average the pixels */
+
+			/* Second 2 pixels */
+			"movq 8(%0),%%mm2\n\t"      /* Read the pixels */
+			"movq 8(%1),%%mm3\n\t"
+			"pavgb %%mm3,%%mm2\n\t"     /* Average the pixels */
+
+			/* Third 2 pixels */
+			"movq 16(%0),%%mm4\n\t"     /* Read the pixels */
+			"movq 16(%1),%%mm5\n\t"
+			"pavgb %%mm5,%%mm4\n\t"     /* Average the pixels */
+
+			/* Fourth 2 pixels */
+			"movq 24(%0),%%mm6\n\t"     /* Read the pixels */
+			"movq 24(%1),%%mm7\n\t"
+			"pavgb %%mm7,%%mm6\n\t"     /* Average the pixels */
+
+			/* Write them all */
+			"movq %%mm0,(%0)\n\t"
+			"movq %%mm2,8(%0)\n\t"
+			"movq %%mm4,16(%0)\n\t"
+			"movq %%mm6,24(%0)\n\t"
+
+			"addl $32,%0\n\t"           /* Advance the pointers */
+			"addl $32,%1\n\t"
+
+			"jmp 20b\n\t"               /* And again */
+
+			"30:\n\t"
+
+			"emms"
+			: /* no outputs */
+			: "r" (dest), "r" (src), "r" ((bufsize >> 1) & 0x3), "r" (bufsize >> 3)
+			);
+}
+
+#endif /* PN_USE_MMX */
+
+/**
+ * pn_image_apply_transform
+ * @image: a #PnImage
+ *
+ * Renders the transform buffer onto the image buffer.
+ * pn_image_set_transform_mode() may be used to set the blend mode that is
+ * used by this function.
+ */
+void
+pn_image_apply_transform (PnImage *image)
+{
+  g_return_if_fail (image != NULL);
+  g_return_if_fail (PN_IS_IMAGE (image));
+
+  switch (image->transform_mode)
+    {
+    case PN_BLEND_MODE_LAST:
+    case PN_BLEND_MODE_IGNORE:
+      return;
+
+    case PN_BLEND_MODE_REPLACE:
+      {
+	PnColor *tmp = image->image_buffer;
+	image->image_buffer = image->transform_buffer;
+	image->transform_buffer = tmp;
+      }
+      break;
+
+    case PN_BLEND_MODE_5050:
+#ifdef PN_USE_MMX
+      if (pn_cpu_get_caps () & PN_CPU_CAP_MMXEXT)
+	pn_image_bufcopy_5050_mmxext (image->image_buffer, image->transform_buffer,
+				      image->height * (image->pitch >> 2));
+      else if (pn_cpu_get_caps () & PN_CPU_CAP_MMX)
+	pn_image_bufcopy_5050_mmx (image->image_buffer, image->transform_buffer,
+				   image->height * (image->pitch >> 2));
+      else
+#endif /* PN_USE_MMX */
+	pn_image_bufcopy_5050 (image->image_buffer, image->transform_buffer,
+			       image->height * (image->pitch >> 2));
+      break;
+    }
+}
+
+/**
+ * pn_image_render_image
+ * @image: a #PnImage
+ * @src: the source image
+ * @blend_mode: the blend mode to use
+ *
+ * Renders the image buffer of @src onto the image buffer of an image.
+ */
+void
+pn_image_render_image (PnImage *image, PnImage *src, PnBlendMode blend_mode)
+{
+  g_return_if_fail (image != NULL);
+  g_return_if_fail (PN_IS_IMAGE (image));
+  g_return_if_fail (src != NULL);
+  g_return_if_fail (PN_IS_IMAGE (src));
+  g_return_if_fail (blend_mode < PN_BLEND_MODE_LAST);
+  g_return_if_fail (image->width == src->width);
+  g_return_if_fail (image->height == src->height);
+
+  switch (blend_mode)
+    {
+    case PN_BLEND_MODE_LAST:
+    case PN_BLEND_MODE_IGNORE:
+      return;
+
+    case PN_BLEND_MODE_REPLACE:
+      memcpy (image->image_buffer, src->image_buffer, image->height * (image->pitch >> 2) * sizeof (PnColor));
+      break;
+
+    case PN_BLEND_MODE_5050:
+#ifdef PN_USE_MMX
+      if (pn_cpu_get_caps () & PN_CPU_CAP_MMXEXT)
+	pn_image_bufcopy_5050_mmxext (image->image_buffer, src->image_buffer,
+				      image->height * (image->pitch >> 2));
+      else if (pn_cpu_get_caps () & PN_CPU_CAP_MMX)
+	pn_image_bufcopy_5050_mmx (image->image_buffer, src->image_buffer, image->height * (image->pitch >> 2));
+      else
+#endif /* PN_USE_MMX */
+	pn_image_bufcopy_5050 (image->image_buffer, src->image_buffer, image->height * (image->pitch >> 2));
+    }
+}