/*
 * Copyright (c) 2000, 2003, Oracle and/or its affiliates. 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.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */


/*
 * FUNCTION
 *      mlib_ImageCopy   - Direct copy from one image to another.
 *
 * SYNOPSIS
 *      mlib_status mlib_ImageCopy(mlib_image *dst,
 *                                 mlib_image *src);
 *
 * ARGUMENT
 *      dst     pointer to output or destination image
 *      src     pointer to input or source image
 *
 * RESTRICTION
 *      src and dst must have the same size, type and number of channels.
 *      They can have 1, 2, 3 or 4 channels of MLIB_BIT, MLIB_BYTE,
 *      MLIB_SHORT, MLIB_INT, MLIB_FLOAT or MLIB_DOUBLE data type.
 *
 * DESCRIPTION
 *      Direct copy from one image to another.
 */

#include <stdlib.h>
#include "mlib_image.h"
#include "mlib_ImageCheck.h"

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

extern void mlib_v_ImageCopy_blk(mlib_u8 *sa, mlib_u8 *da, mlib_s32 size);
extern void mlib_v_ImageCopy_a1(mlib_d64 *sp, mlib_d64 *dp, mlib_s32 size);
extern void mlib_ImageCopy_na(mlib_u8 *sa, mlib_u8 *da, mlib_s32 size);
extern void mlib_ImageCopy_bit_al(mlib_u8 *sa, mlib_u8 *da,
                                  mlib_s32 size, mlib_s32 offset);
extern void mlib_ImageCopy_bit_na(mlib_u8 *sa, mlib_u8 *da, mlib_s32 size,
                                  mlib_s32 s_offset, mlib_s32 d_offset);

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

#ifdef MLIB_TEST

mlib_status mlib_v_ImageCopy(mlib_image *dst, mlib_image *src)

#else

mlib_status mlib_ImageCopy(mlib_image *dst, const mlib_image *src)

#endif
{
  mlib_u8  *sa;         /* start point in source */
  mlib_u8  *da;         /* start points in destination */
  mlib_s32 width;       /* width in bytes of src and dst */
  mlib_s32 height;      /* height in lines of src and dst */
  mlib_s32 s_offset;    /* bit offset of src */
  mlib_s32 d_offset;    /* bit offset of dst */
  mlib_s32 stride;      /* stride in bytes in src*/
  mlib_s32 dstride;     /* stride in bytes in dst */
  mlib_s32 j;           /* indices for x, y */
  mlib_s32 size;

  MLIB_IMAGE_CHECK(src);
  MLIB_IMAGE_CHECK(dst);
  MLIB_IMAGE_TYPE_EQUAL(src, dst);
  MLIB_IMAGE_CHAN_EQUAL(src, dst);
  MLIB_IMAGE_SIZE_EQUAL(src, dst);

  width  = mlib_ImageGetWidth(dst) * mlib_ImageGetChannels(dst);
  height = mlib_ImageGetHeight(dst);
  sa = (mlib_u8 *)mlib_ImageGetData(src);
  da = (mlib_u8 *)mlib_ImageGetData(dst);

  switch (mlib_ImageGetType(dst)) {
    case MLIB_BIT:

      if (!mlib_ImageIsNotOneDvector(src) &&
          !mlib_ImageIsNotOneDvector(dst)) {
          size = height * (width  >> 3);
          if ((size & 0x3f) == 0 &&
              !mlib_ImageIsNotAligned64(src) &&
              !mlib_ImageIsNotAligned64(dst)) {

              mlib_v_ImageCopy_blk(sa, da, size);
              return MLIB_SUCCESS;
          }
          if (((size & 7) == 0) && !mlib_ImageIsNotAligned8(src) &&
              !mlib_ImageIsNotAligned8(dst)) {

              size >>= 3;                                /* in octlet */
              mlib_v_ImageCopy_a1((mlib_d64 *)sa, (mlib_d64 *)da, size);
          }
          else {

            mlib_ImageCopy_na(sa, da, size);
          }
        }
      else {
        stride = mlib_ImageGetStride(src);                /* in byte */
        dstride = mlib_ImageGetStride(dst);               /* in byte */
        s_offset = mlib_ImageGetBitOffset(src);           /* in bits */
        d_offset = mlib_ImageGetBitOffset(dst);           /* in bits */

        if (s_offset == d_offset) {
          for (j = 0; j < height; j++) {
            mlib_ImageCopy_bit_al(sa, da, width, s_offset);
            sa += stride;
            da += dstride;
          }
        } else {
          for (j = 0; j < height; j++) {
            mlib_ImageCopy_bit_na(sa, da, width, s_offset, d_offset);
            sa += stride;
            da += dstride;
          }
        }
      }
      return MLIB_SUCCESS;
    case MLIB_BYTE:
      break;
    case MLIB_SHORT:
      width *= 2;
      break;
    case MLIB_INT:
    case MLIB_FLOAT:
      width *= 4;
      break;
    case MLIB_DOUBLE:
      width *= 8;
      break;
    default:
      return MLIB_FAILURE;
  }

  if (!mlib_ImageIsNotOneDvector(src) &&
      !mlib_ImageIsNotOneDvector(dst)) {
      size = height * width;
      if ((size & 0x3f) == 0 &&
          !mlib_ImageIsNotAligned64(src) &&
          !mlib_ImageIsNotAligned64(dst)) {

          mlib_v_ImageCopy_blk(sa, da, size);
          return MLIB_SUCCESS;
      }
      if (((size & 7) == 0) && !mlib_ImageIsNotAligned8(src) &&
          !mlib_ImageIsNotAligned8(dst)) {

          size >>= 3;                                /* in octlet */
          mlib_v_ImageCopy_a1((mlib_d64 *)sa, (mlib_d64 *)da, size);
      }
      else {

        mlib_ImageCopy_na(sa, da, size);
      }
    }
  else {
    stride = mlib_ImageGetStride(src);                /* in byte */
    dstride = mlib_ImageGetStride(dst);                /* in byte */

    /* row loop */
    for (j = 0; j < height; j++) {
      mlib_ImageCopy_na(sa, da, width);
      sa += stride;
      da += dstride;
    }
  }
  return MLIB_SUCCESS;
}

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