/* This file is part of GEGL

 *

 * GEGL is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 3 of the License, or (at your option) any later version.

 *

 * GEGL 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

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with GEGL; if not, see <http://www.gnu.org/licenses/>.

 *

 * Copyright 2003-2007 Calvin Williamson, Øyvind Kolås.

 */

#include "config.h"

#include <glib-object.h>

#include "gegl.h"

#include "gegl-types-internal.h"

#include "gegl-utils.h"

#include "gegl-types-internal.h"

  inline gint

  _gegl_float_epsilon_zero (float value)

  {

    return value > -GEGL_FLOAT_EPSILON && value < GEGL_FLOAT_EPSILON;

  }

  gint

  _gegl_float_epsilon_equal (float v1, float v2)

  {

    register float diff = v1 - v2;

    return diff > -GEGL_FLOAT_EPSILON && diff < GEGL_FLOAT_EPSILON;

  }

  void

  gegl_rectangle_set (GeglRectangle *r,

                      gint           x,

                      gint           y,

                      guint          w,

                      guint          h)

  {

    r->x      = x;

    r->y      = y;

    r->width  = w;

    r->height = h;

  }

  void

  gegl_rectangle_bounding_box (GeglRectangle       *dest,

                               const GeglRectangle *src1,

                               const GeglRectangle *src2)

  {

    gboolean s1_has_area = src1->width && src1->height;

    gboolean s2_has_area = src2->width && src2->height;

    if (!s1_has_area && !s2_has_area)

      gegl_rectangle_set (dest, 0, 0, 0, 0);

    else if (!s1_has_area)

      gegl_rectangle_copy (dest, src2);

    else if (!s2_has_area)

      gegl_rectangle_copy (dest, src1);

    else

      {

        gint x1 = MIN (src1->x, src2->x);

        gint x2 = MAX (src1->x + src1->width, src2->x + src2->width);

        gint y1 = MIN (src1->y, src2->y);

        gint y2 = MAX (src1->y + src1->height, src2->y + src2->height);

        dest->x      = x1;

        dest->y      = y1;

        dest->width  = x2 - x1;

        dest->height = y2 - y1;

      }

  }

  gboolean

  gegl_rectangle_intersect (GeglRectangle       *dest,

                            const GeglRectangle *src1,

                            const GeglRectangle *src2)

  {

    gint x1, x2, y1, y2;

    x1 = MAX (src1->x, src2->x);

    x2 = MIN (src1->x + src1->width, src2->x + src2->width);

    if (x2 <= x1)

      {

        if (dest)

          gegl_rectangle_set (dest, 0, 0, 0, 0);

        return FALSE;

      }

    y1 = MAX (src1->y, src2->y);

    y2 = MIN (src1->y + src1->height, src2->y + src2->height);

    if (y2 <= y1)

      {

        if (dest)

          gegl_rectangle_set (dest, 0, 0, 0, 0);

        return FALSE;

      }

    if (dest)

      gegl_rectangle_set (dest, x1, y1, x2 - x1, y2 - y1);

    return TRUE;

  }

  void

  gegl_rectangle_copy (GeglRectangle       *to,

                       const GeglRectangle *from)

  {

    to->x      = from->x;

    to->y      = from->y;

    to->width  = from->width;

    to->height = from->height;

  }

  gboolean

  gegl_rectangle_contains (const GeglRectangle *r,

                           const GeglRectangle *s)

  {

    g_return_val_if_fail (r && s, FALSE);

    if (s->x >= r->x &&

        s->y >= r->y &&

        (s->x + s->width) <= (r->x + r->width) &&

        (s->y + s->height) <= (r->y + r->height))

      return TRUE;

    else

      return FALSE;

  }

  gboolean

  gegl_rectangle_equal (const GeglRectangle *r,

                        const GeglRectangle *s)

  {

    g_return_val_if_fail (r && s, FALSE);

    if (r->x == s->x &&

        r->y == s->y &&

        r->width == s->width &&

        r->height == s->height)

      return TRUE;

    else

      return FALSE;

  }

  gboolean

  gegl_rectangle_equal_coords (const GeglRectangle *r,

                               gint                 x,

                               gint                 y,

                               gint                 w,

                               gint                 h)

  {

    g_return_val_if_fail (r, FALSE);

    if (r->x == x &&

        r->y == y &&

        r->width == w &&

        r->height == h)

      return TRUE;

    else

      return FALSE;

  }

  gboolean

  gegl_rectangle_is_empty (const GeglRectangle *r)

  {

    g_return_val_if_fail (r != NULL, FALSE);

    return r->width == 0 && r->height == 0;

  }

  static GeglRectangle *

  gegl_rectangle_dup (const GeglRectangle *rectangle)

  {

    GeglRectangle *result = g_new (GeglRectangle, 1);

    *result = *rectangle;

    return result;

  }

  GeglRectangle

  gegl_rectangle_infinite_plane (void)

  {

    GeglRectangle infinite_plane_rect = {G_MININT / 2, G_MININT / 2, G_MAXINT, G_MAXINT};

    return infinite_plane_rect;

  }

  gboolean

  gegl_rectangle_is_infinite_plane (const GeglRectangle *rectangle)

  {

    return (rectangle->x      == G_MININT / 2 &&

            rectangle->y      == G_MININT / 2 &&

            rectangle->width  == G_MAXINT     &&

            rectangle->height == G_MAXINT);

  }

  void

  gegl_rectangle_dump (const GeglRectangle *rectangle)

  {

    g_print ("%d, %d, %d×%d\n",

             rectangle->x,

             rectangle->y,

             rectangle->width,

             rectangle->height);

  }

  GType

  gegl_rectangle_get_type (void)

  {

    static GType our_type = 0;

    if (our_type == 0)

      our_type = g_boxed_type_register_static (g_intern_static_string ("GeglRectangle"),

                                               (GBoxedCopyFunc) gegl_rectangle_dup,

                                               (GBoxedFreeFunc) g_free);

    return our_type;

  }

#define GEGL_ALIGN 16

  gpointer

  gegl_malloc (gsize size);

  /* utility call that makes sure allocations are 16 byte aligned.

   * making RGBA float buffers have aligned access for pixels.

   */

  gpointer gegl_malloc (gsize size)

  {

    gchar *mem;

    gchar *ret;

    gint   offset;

    mem    = g_malloc (size + GEGL_ALIGN + sizeof(gpointer));

    offset = GEGL_ALIGN - (GPOINTER_TO_UINT(mem) + sizeof(gpointer)) % GEGL_ALIGN;

    ret    = (gpointer)(mem + sizeof(gpointer) + offset);

    /* store the real malloc one pointer in front of this malloc */

    *(gpointer*)(ret-sizeof(gpointer))=mem;

    return (gpointer) ret;

  }

  void

  gegl_free (gpointer buf);

  void

  gegl_free (gpointer buf)

  {

    g_assert (buf);

    g_free (*((gpointer*)buf -1));

  }