/*

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

}

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