/* This file is part of GEGL.

 *

 * This library 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.

 *

 * 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

 * Lesser General Public License for more details.

 *

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

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

 *

 * Copyright 2006,2007 Øyvind Kolås <pippin@gimp.org>

 */

#include "config.h"

#include <glib.h>

#include <glib-object.h>

#include <string.h>

#include "gegl-types.h"

#include "gegl-matrix.h"

#include "gegl-buffer-types.h"

#include "gegl-buffer-private.h"

#include "gegl-tile-handler.h"

#include "gegl-tile-handler-zoom.h"

#include "gegl-tile-handler-cache.h"

G_DEFINE_TYPE (GeglTileHandlerZoom, gegl_tile_handler_zoom, GEGL_TYPE_TILE_HANDLER)

#include <babl/babl.h>

#include "gegl-tile-backend.h"

#include "gegl-tile-storage.h"

void gegl_tile_handler_cache_insert (GeglTileHandlerCache *cache,

                                     GeglTile             *tile,

                                     gint                  x,

                                     gint                  y,

                                     gint                  z);

static inline void set_blank (GeglTile   *dst_tile,

                              gint        width,

                              gint        height,

                              const Babl *format,

                              gint        i,

                              gint        j)

{

  guchar *dst_data  = gegl_tile_get_data (dst_tile);

  gint    bpp       = babl_format_get_bytes_per_pixel (format);

  gint    rowstride = width * bpp;

  gint    scanline;

  gint    bytes = width * bpp / 2;

  guchar *dst   = dst_data + j * height / 2 * rowstride + i * rowstride / 2;

  for (scanline = 0; scanline < height / 2; scanline++)

    {

      memset (dst, 0x0, bytes);

      dst += rowstride;

    }

}

/* fixme: make the api of this, as well as blank be the

 * same as the downscale functions */

static inline void set_half_nearest (GeglTile   *dst_tile,

                                     GeglTile   *src_tile,

                                     gint        width,

                                     gint        height,

                                     const Babl *format,

                                     gint        i,

                                     gint        j)

{

  guchar *dst_data = gegl_tile_get_data (dst_tile);

  guchar *src_data = gegl_tile_get_data (src_tile);

  gint    bpp      = babl_format_get_bytes_per_pixel (format);

  gint    x, y;

  for (y = 0; y < height / 2; y++)

    {

      guchar *dst = dst_data +

                    (

        (

          (y + j * (height / 2)) * width

        ) + i * (width / 2)

                    ) * bpp;

      guchar *src = src_data + (y * 2 * width) * bpp;

      for (x = 0; x < width / 2; x++)

        {

          memcpy (dst, src, bpp);

          dst += bpp;

          src += bpp * 2;

        }

    }

}

static inline void

downscale_float (gint    components,

                 gint    width,

                 gint    height,

                 gint    rowstride,

                 guchar *src_data,

                 guchar *dst_data)

{

  gint y;

  if (!src_data || !dst_data)

    return;

  for (y = 0; y < height / 2; y++)

    {

      gint    x;

      gfloat *dst = (gfloat *) (dst_data + y * rowstride);

      gfloat *src = (gfloat *) (src_data + y * 2 * rowstride);

      for (x = 0; x < width / 2; x++)

        {

          int i;

          for (i = 0; i < components; i++)

            dst[i] = (src[i] +

                      src[i + components] +

                      src[i + (width * components)] +

                      src[i + (width + 1) * components]) /

                     4.0;

          dst += components;

          src += components * 2;

        }

    }

}

static inline void

downscale_u8 (gint    components,

              gint    width,

              gint    height,

              gint    rowstride,

              guchar *src_data,

              guchar *dst_data)

{

  gint y;

  if (!src_data || !dst_data)

    return;

  for (y = 0; y < height / 2; y++)

    {

      gint    x;

      guchar *dst = dst_data + y * rowstride;

      guchar *src = src_data + y * 2 * rowstride;

      for (x = 0; x < width / 2; x++)

        {

          int i;

          for (i = 0; i < components; i++)

            dst[i] = (src[i] +

                      src[i + components] +

                      src[i + rowstride] +

                      src[i + rowstride + components]) /

                     4;

          dst += components;

          src += components * 2;

        }

    }

}

static inline void set_half (GeglTile   * dst_tile,

                             GeglTile   * src_tile,

                             gint         width,

                             gint         height,

                             const Babl * format,

                             gint i,

                             gint j)

{

  guchar *dst_data   = gegl_tile_get_data (dst_tile);

  guchar *src_data   = gegl_tile_get_data (src_tile);

  gint    components = babl_format_get_n_components (format);

  gint    bpp        = babl_format_get_bytes_per_pixel (format);

  if (i) dst_data += bpp * width / 2;

  if (j) dst_data += bpp * width * height / 2;

  if (babl_format_get_type (format, 0) == babl_type ("float"))

    {

      downscale_float (components, width, height, width * bpp, src_data, dst_data);

    }

  else if (babl_format_get_type (format, 0) == babl_type ("u8"))

    {

      downscale_u8 (components, width, height, width * bpp, src_data, dst_data);

    }

  else

    {

      set_half_nearest (dst_tile, src_tile, width, height, format, i, j);

    }

}

static GeglTile *

get_tile (GeglTileSource *gegl_tile_source,

          gint            x,

          gint            y,

          gint            z)

{

  GeglTileSource      *source = ((GeglTileHandler*)(gegl_tile_source))->source;

  GeglTileHandlerZoom *zoom   = (GeglTileHandlerZoom*)(gegl_tile_source);

  GeglTile            *tile   = NULL;

  const Babl          *format = gegl_tile_backend_get_format (zoom->backend);

  gint                 tile_width;

  gint                 tile_height;

  gint                 tile_size;

  if (source)

    {

      tile = gegl_tile_source_get_tile (source, x, y, z);

    }

  if (tile)

    return tile;

  if (z == 0)/* at base level with no tile found->send null, and shared empty

               tile will be used instead */

    {

      return NULL;

    }

  if (z>zoom->tile_storage->seen_zoom)

    zoom->tile_storage->seen_zoom = z;

  g_assert (zoom->backend);

  g_object_get (zoom->backend, "tile-width", &tile_width,

                "tile-height", &tile_height,

                "tile-size", &tile_size,

                NULL);

  {

    gint      i, j;

    GeglTile *source_tile[2][2] = { { NULL, NULL }, { NULL, NULL } };

    for (i = 0; i < 2; i++)

      for (j = 0; j < 2; j++)

        {

          /* we get the tile from ourselves, to make successive rescales work

           * correctly */

            source_tile[i][j] = gegl_tile_source_get_tile (gegl_tile_source,

                                                          x * 2 + i, y * 2 + j, z - 1);

        }

    if (source_tile[0][0] == NULL &&

        source_tile[0][1] == NULL &&

        source_tile[1][0] == NULL &&

        source_tile[1][1] == NULL)

      {

        return NULL;   /* no data from level below, return NULL and let GeglTileHandlerEmpty

                          fill in the shared empty tile */

      }

    g_assert (tile == NULL);

    if (tile == NULL)

      {

        tile = gegl_tile_new (tile_size);

        tile->x = x;

        tile->y = y;

        tile->z = z;

        tile->tile_storage = zoom->tile_storage;

        if (zoom->cache)

          gegl_tile_handler_cache_insert (zoom->cache, tile, x, y, z);

      }

    gegl_tile_lock (tile);

    for (i = 0; i < 2; i++)

      for (j = 0; j < 2; j++)

        {

          if (source_tile[i][j])

            {

              set_half (tile, source_tile[i][j], tile_width, tile_height, format, i, j);

              gegl_tile_unref (source_tile[i][j]);

            }

          else

            {

              set_blank (tile, tile_width, tile_height, format, i, j);

            }

        }

    gegl_tile_unlock (tile);

  }

  return tile;

}

static gpointer

gegl_tile_handler_zoom_command (GeglTileSource  *tile_store,

                                GeglTileCommand  command,

                                gint             x,

                                gint             y,

                                gint             z,

                                gpointer         data)

{

  GeglTileHandler *handler  = (void*)tile_store;

  if (command == GEGL_TILE_GET)

    return get_tile (tile_store, x, y, z);

  else

    return gegl_tile_handler_source_command (handler, command, x, y, z, data);

}

static void

gegl_tile_handler_zoom_class_init (GeglTileHandlerZoomClass *klass)

{

}

static void

gegl_tile_handler_zoom_init (GeglTileHandlerZoom *self)

{

  ((GeglTileSource*)self)->command = gegl_tile_handler_zoom_command;

  self->backend = NULL;

  self->tile_storage = NULL;

}

GeglTileHandler *

gegl_tile_handler_zoom_new (GeglTileBackend      *backend,

                            GeglTileStorage      *tile_storage,

                            GeglTileHandlerCache *cache)

{

  GeglTileHandlerZoom *ret = g_object_new (GEGL_TYPE_TILE_HANDLER_ZOOM, NULL);

  ((GeglTileSource*)ret)->command = gegl_tile_handler_zoom_command;

  ret->backend = backend;

  ret->tile_storage = tile_storage;

  ret->cache = cache;

  return (void*)ret;

}