/*

 * Copyright 1997-2003 Sun Microsystems, Inc.  All Rights Reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Sun designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Sun in the LICENSE file that accompanied this code.

 *

 * This code 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 General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

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

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 */

/*

 * FUNCTION

 *      mlib_ImageCreateStruct   - create image data structure

 *      mlib_ImageCreate         - create image data structure and allocate

 *                                 memory for image data

 *      mlib_ImageDelete         - delete image

 *      mlib_ImageCreateSubimage - create sub-image

 *

 *      mlib_ImageCreateRowTable - create row starts pointer table

 *      mlib_ImageDeleteRowTable - delete row starts pointer table

 *

 *      mlib_ImageSetPaddings    - set paddings for clipping box borders

 *

 *      mlib_ImageSetFormat      - set image format

 *

 * SYNOPSIS

 *        mlib_image *mlib_ImageCreateStruct(mlib_type  type,

 *                                           mlib_s32   channels,

 *                                           mlib_s32   width,

 *                                           mlib_s32   height,

 *                                           mlib_s32   stride,

 *                                           const void *data)

 *

 *        mlib_image *mlib_ImageCreate(mlib_type type,

 *                                     mlib_s32  channels,

 *                                     mlib_s32  width,

 *                                     mlib_s32  height)

 *

 *        void mlib_ImageDelete(mlib_image *img)

 *

 *        mlib_image *mlib_ImageCreateSubimage(mlib_image *img,

 *                                             mlib_s32   x,

 *                                             mlib_s32   y,

 *                                             mlib_s32   w,

 *                                             mlib_s32   h)

 *

 *        void *mlib_ImageCreateRowTable(mlib_image *img)

 *

 *        void mlib_ImageDeleteRowTable(mlib_image *img)

 *

 *        mlib_status mlib_ImageSetPaddings(mlib_image *img,

 *                                          mlib_u8    left,

 *                                          mlib_u8    top,

 *                                          mlib_u8    right,

 *                                          mlib_u8    bottom)

 *

 *        mlib_status mlib_ImageSetFormat(mlib_image  *img,

 *                                        mlib_format format)

 * ARGUMENTS

 *      img       pointer to image data structure

 *      type      image data type, one of MLIB_BIT, MLIB_BYTE, MLIB_SHORT,

 *                MLIB_USHORT, MLIB_INT, MLIB_FLOAT or MLIB_DOUBLE

 *      channels  number of image channels

 *      width     image width in pixels

 *      height    image height in pixels

 *      stride    linebytes( bytes to next row) of the image

 *      data      pointer to image data allocated by user

 *      x         x coordinate of the left border in the source image

 *      y         y coordinate of the top border in the source image

 *      w         width of the sub-image

 *      h         height of the sub-image

 *      left      clipping box left padding

 *      top       clipping box top padding

 *      right     clipping box right padding

 *      bottom    clipping box bottom padding

 *      format    image format

 *

 * DESCRIPTION

 *      mlib_ImageCreateStruct() creates a mediaLib image data structure

 *      using parameter supplied by user.

 *

 *      mlib_ImageCreate() creates a mediaLib image data structure and

 *      allocates memory space for image data.

 *

 *      mlib_ImageDelete() deletes the mediaLib image data structure

 *      and frees the memory space of the image data if it is allocated

 *      through mlib_ImageCreate().

 *

 *      mlib_ImageCreateSubimage() creates a mediaLib image structure

 *      for a sub-image based on a source image.

 *

 *      mlib_ImageCreateRowTable() creates row starts pointer table and

 *      puts it into mlib_image->state field.

 *

 *      mlib_ImageDeleteRowTable() deletes row starts pointer table from

 *      image and puts NULL into mlib_image->state field.

 *

 *      mlib_ImageSetPaddings() sets new values for the clipping box paddings

 *

 *      mlib_ImageSetFormat() sets new value for the image format

 */

#include <stdlib.h>

#include "mlib_image.h"

#include "mlib_ImageRowTable.h"

#include "mlib_ImageCreate.h"

/***************************************************************/

mlib_image* mlib_ImageSet(mlib_image *image,

                          mlib_type  type,

                          mlib_s32   channels,

                          mlib_s32   width,

                          mlib_s32   height,

                          mlib_s32   stride,

                          const void *data)

{

  mlib_s32        wb;                /* width in bytes */

  mlib_s32        mask;              /* mask for check of stride */

  if (image == NULL) return NULL;

/* for some ugly functions calling with incorrect parameters */

  image -> type     = type;

  image -> channels = channels;

  image -> width    = width;

  image -> height   = height;

  image -> stride   = stride;

  image -> data     = (void *)data;

  image -> state    = NULL;

  image -> format   = MLIB_FORMAT_UNKNOWN;

  image -> paddings[0] = 0;

  image -> paddings[1] = 0;

  image -> paddings[2] = 0;

  image -> paddings[3] = 0;

  image -> bitoffset = 0;

  if (width <= 0 || height <= 0 || channels < 1 || channels > 4) {

    return NULL;

  }

/* Check if stride == width

   * If it is then image can be treated as a 1-D vector

 */

  switch (type) {

    case MLIB_DOUBLE:

      wb = width * channels * 8;

      mask = 7;

      break;

    case MLIB_FLOAT:

    case MLIB_INT:

      wb = width * channels * 4;

      mask = 3;

      break;

    case MLIB_USHORT:

    case MLIB_SHORT:

      wb = width * channels * 2;

      mask = 1;

      break;

    case MLIB_BYTE:

      wb = width * channels;

      mask = 0;

      break;

    case MLIB_BIT:

      wb = (width * channels + 7) / 8;

      mask = 0;

      break;

    default:

      return NULL;

  }

  if (stride & mask) {

    return NULL;

  }

  image -> flags    = ((width & 0xf) << 8);          /* set width field */

  image -> flags   |= ((stride & 0xf) << 16);        /* set stride field */

  image -> flags   |= ((height & 0xf) << 12);        /* set height field */

  image -> flags   |= (mlib_addr)data & 0xff;

  image -> flags   |= MLIB_IMAGE_USERALLOCATED;      /* user allocated data */

  if ((stride != wb) ||

      ((type == MLIB_BIT) && (stride * 8 != width * channels))) {

    image -> flags |= MLIB_IMAGE_ONEDVECTOR;

  }

  image -> flags &= MLIB_IMAGE_ATTRIBUTESET;

  return image;

}

/***************************************************************/

mlib_image *mlib_ImageCreateStruct(mlib_type  type,

                                   mlib_s32   channels,

                                   mlib_s32   width,

                                   mlib_s32   height,

                                   mlib_s32   stride,

                                   const void *data)

{

  mlib_image *image;

  if (stride <= 0) {

    return NULL;

  }

  image = (mlib_image *)mlib_malloc(sizeof(mlib_image));

  if (image == NULL) {

    return NULL;

  }

  if (mlib_ImageSet(image, type, channels, width, height, stride, data) == NULL) {

    mlib_free(image);

    image = NULL;

  }

  return image;

}

/***************************************************************/

mlib_image *mlib_ImageCreate(mlib_type type,

                             mlib_s32  channels,

                             mlib_s32  width,

                             mlib_s32  height)

{

  mlib_image *image;

  mlib_s32        wb;                /* width in bytes */

  void       *data;

/* sanity check */

  if (width <= 0 || height <= 0 || channels < 1 || channels > 4) {

    return NULL;

  };

  switch (type) {

    case MLIB_DOUBLE:

      wb = width * channels * 8;

      break;

    case MLIB_FLOAT:

    case MLIB_INT:

      wb = width * channels * 4;

      break;

    case MLIB_USHORT:

    case MLIB_SHORT:

      wb = width * channels * 2;

      break;

    case MLIB_BYTE:

      wb = width * channels;

      break;

    case MLIB_BIT:

      wb = (width * channels + 7) / 8;

      break;

    default:

      return NULL;

  }

  data = mlib_malloc(wb * height);

  if (data == NULL) {

    return NULL;

  }

  image = (mlib_image *)mlib_malloc(sizeof(mlib_image));

  if (image == NULL) {

    mlib_free(data);

    return NULL;

  };

  image -> type     = type;

  image -> channels = channels;

  image -> width    = width;

  image -> height   = height;

  image -> stride   = wb;

  image -> data     = data;

  image -> flags    = ((width & 0xf) << 8);        /* set width field */

  image -> flags   |= ((height & 0xf) << 12);      /* set height field */

  image -> flags   |= ((wb & 0xf) << 16);          /* set stride field */

  image -> flags   |= (mlib_addr)data & 0xff;

  image -> format   = MLIB_FORMAT_UNKNOWN;

  image -> paddings[0] = 0;

  image -> paddings[1] = 0;

  image -> paddings[2] = 0;

  image -> paddings[3] = 0;

  image -> bitoffset = 0;

  if ((type == MLIB_BIT) && (wb * 8 != width * channels)) {

    image -> flags |= MLIB_IMAGE_ONEDVECTOR;       /* not 1-d vector */

  }

  image -> flags &= MLIB_IMAGE_ATTRIBUTESET;

  image -> state  = NULL;

  return image;

}

/***************************************************************/

void mlib_ImageDelete(mlib_image *img)

{

  if (img == NULL) return;

  if ((img -> flags & MLIB_IMAGE_USERALLOCATED) == 0) {

    mlib_free(img -> data);

  }

  mlib_ImageDeleteRowTable(img);

  mlib_free(img);

}

/***************************************************************/

mlib_image *mlib_ImageCreateSubimage(mlib_image *img,

                                     mlib_s32   x,

                                     mlib_s32   y,

                                     mlib_s32   w,

                                     mlib_s32   h)

{

  mlib_image     *subimage;

  mlib_type      type;

  mlib_s32       channels;

  mlib_s32       width;                 /* for parent image */

  mlib_s32       height;                /* for parent image */

  mlib_s32       stride;

  mlib_s32       bitoffset;

  void           *data;

/* sanity check */

  if (w <= 0 || h <= 0 || img == NULL) return NULL;

  type     = img -> type;

  channels = img -> channels;

  width    = img -> width;

  height   = img -> height;

  stride   = img -> stride;

/* clip the sub-image with respect to the parent image */

  if (((x + w) <= 0) || ((y + h) <= 0) ||

      (x >= width) || (y >= height)) {

    return NULL;

  }

  else {

    if (x < 0) {

      w += x;                                        /* x is negative */

      x = 0;

    }

    if (y < 0) {

      h += y;                                        /* y is negative */

      y = 0;

    }

    if ((x + w) > width) {

      w = width - x;

    }

    if ((y + h) > height) {

      h = height - y;

    }

  }

/* compute sub-image origin */

  data = (mlib_u8 *)(img -> data) + y * stride;

  switch (type) {

    case MLIB_DOUBLE:

      data = (mlib_u8 *)data + x * channels * 8;

      break;

    case MLIB_FLOAT:

    case MLIB_INT:

      data = (mlib_u8 *)data + x * channels * 4;

      break;

    case MLIB_USHORT:

    case MLIB_SHORT:

      data = (mlib_u8 *)data + x * channels * 2;

      break;

    case MLIB_BYTE:

      data = (mlib_u8 *)data + x * channels;

      break;

    case MLIB_BIT:

      bitoffset = img -> bitoffset;

      data = (mlib_u8 *)data + (x * channels + bitoffset) / 8;

      bitoffset = (x * channels + bitoffset) & 7;

      break;

    default:

      return NULL;

  }

  subimage = mlib_ImageCreateStruct(type,

                                    channels,

                                    w,

                                    h,

                                    stride,

                                    data);

  if (subimage != NULL && type == MLIB_BIT)

    subimage -> bitoffset = bitoffset;

  return subimage;

}

/***************************************************************/

mlib_image *mlib_ImageSetSubimage(mlib_image       *dst,

                                  const mlib_image *src,

                                  mlib_s32         x,

                                  mlib_s32         y,

                                  mlib_s32         w,

                                  mlib_s32         h)

{

  mlib_type  type     = src -> type;

  mlib_s32   channels = src -> channels;

  mlib_s32   stride   = src -> stride;

  mlib_u8    *data    = src -> data;

  mlib_s32   bitoffset;

  data += y * stride;

  switch (type) {

    case MLIB_DOUBLE:

      data += channels * x * 8;

      break;

    case MLIB_FLOAT:

    case MLIB_INT:

      data += channels * x * 4;

      break;

    case MLIB_USHORT:

    case MLIB_SHORT:

      data += channels * x * 2;

      break;

    case MLIB_BYTE:

      data += channels * x;

      break;

    case MLIB_BIT:

      bitoffset = src -> bitoffset + channels * x;

      data += (bitoffset >= 0) ? bitoffset/8 : (bitoffset - 7)/8; /* with rounding toward -Inf */

      bitoffset &= 7;

      break;

    default:

      return NULL;

  }

  if (h > 0) {

    dst = mlib_ImageSet(dst, type, channels, w, h, stride, data);

  } else {

    h = - h;

    dst = mlib_ImageSet(dst, type, channels, w, h, - stride, data + (h - 1)*stride);

  }

  if (dst != NULL && type == MLIB_BIT) {

    dst -> bitoffset = bitoffset;

  }

  return dst;

}

/***************************************************************/

void *mlib_ImageCreateRowTable(mlib_image *img)

{

  mlib_u8  **rtable, *tline;

  mlib_s32 i, im_height, im_stride;

  if (img == NULL) return NULL;

  if (img -> state)  return img -> state;

  im_height = mlib_ImageGetHeight(img);

  im_stride = mlib_ImageGetStride(img);

  tline     = mlib_ImageGetData(img);

  rtable    = mlib_malloc((3 + im_height)*sizeof(mlib_u8 *));

  if (rtable == NULL || tline == NULL) return NULL;

  rtable[0] = 0;

  rtable[1] = (mlib_u8*)((void **)rtable + 1);

  rtable[2 + im_height] = (mlib_u8*)((void **)rtable + 1);

  for (i = 0; i < im_height; i++) {

    rtable[i+2] = tline;

    tline    += im_stride;

  }

  img -> state = ((void **)rtable + 2);

  return img -> state;

}

/***************************************************************/

void mlib_ImageDeleteRowTable(mlib_image *img)

{

  void **state;

  if (img == NULL) return;

  state = img -> state;

  if (!state) return;

  mlib_free(state - 2);

  img -> state = 0;

}

/***************************************************************/

mlib_status mlib_ImageSetPaddings(mlib_image *img,

                                  mlib_u8    left,

                                  mlib_u8    top,

                                  mlib_u8    right,

                                  mlib_u8    bottom)

{

  if (img == NULL) return MLIB_FAILURE;

  if ((left + right) >= img -> width ||

      (top + bottom) >= img -> height) return MLIB_OUTOFRANGE;

  img -> paddings[0] = left;

  img -> paddings[1] = top;

  img -> paddings[2] = right;

  img -> paddings[3] = bottom;

  return MLIB_SUCCESS;

}