/*

* Copyright (c) 2010 Ixonos Plc.

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - Initial contribution

*

* Contributors:

* Ixonos Plc

*

* Description: 

* Block copying functions.

*

*/

#include "h263dconfig.h"

/*

 *

 * blcMemSetIncBuf

 *

 * Parameters:

 *    void HUGE *buf    destination buffer

 *    int ch            input value

 *    size_t count      the number of values to put into the buffer

 *

 * Function:

 *    This macro sets count bytes of buf into the low-order byte of ch

 *    and increases buf by count.

 *

 * Changes:

 *    buf

 *

 * Returns:

 *    Nothing.

 *

 * Error codes:

 *    None.

 *

 */

#define blcMemSetIncBuf(buf, ch, count) \

   MEMSET(buf, ch, count); \

   buf += count

/*

 *

 * blcCopyRowNBC           copy a row without border checking

 *

 * Parameters:

 *    u_char HUGE *srcMem  source row

 *    u_char HUGE *dstMem  destination row

 *

 *    int xlt0             ignored

 *    int xNormal          See blcCopyBlockBC.

 *    int xgtmax           ignored

 *

 * Function:

 *    This macro copies a row of pixels and assumes that

 *       - all pixels are within the image area

 *       - the pixels are in integer positions

 *

 *    dstMem is increased by xNormal

 *    srcMem is increased by xNormal - 1

 *

 * Changes:

 *    srcMem

 *    dstMem

 *

 * Returns:

 *    Nothing.

 *

 * Error codes:

 *    None.

 *

 */

#define blcCopyRowNBC(srcMem, dstMem, xlt0, xNormal, xgtmax, roundIncNotUsed) \

{ \

   MEMCPY(dstMem, srcMem, xNormal); \

   dstMem += xNormal; \

   srcMem += xNormal - 1; \

}

/*

 *

 * blcCopyRowBC            copy a row with border checking

 *

 * Parameters:

 *    u_char HUGE *srcMem  source row

 *    u_char HUGE *dstMem  destination row

 *

 *    int xlt0             See blcCopyBlockBC.

 *    int xNormal          See blcCopyBlockBC.

 *    int xgtmax           See blcCopyBlockBC.

 *

 * Function:

 *    This macro copies a row of pixels and assumes that

 *       - xlt0 pixels are in the left side of the image area and

 *       - xgtmax pixels are in the right side of the image area and

 *       - the pixels are in integer positions

 *

 *    dstMem is increased by xlt0 + xNormal + xgtmax

 *    srcMem is increased by xNormal - 1 if xNormal > 0

 *

 * Changes:

 *    srcMem

 *    dstMem

 *

 * Returns:

 *    Nothing.

 *

 * Error codes:

 *    None.

 *

 */

#define blcCopyRowBC(srcMem, dstMem, xlt0, xNormal, xgtmax, roundIncNotUsed) \

{ \

   if (xlt0) MEMSET(dstMem, *srcMem, xlt0); \

   dstMem += xlt0; \

   if (xNormal) blcCopyRowNBC(srcMem, dstMem, xlt0, xNormal, xgtmax, roundIncNotUsed); \

   if (xgtmax) MEMSET(dstMem, *srcMem, xgtmax); \

   dstMem += xgtmax; \

}

/*

 *

 * blcCopyRowSubXNBC

 *

 * Parameters:

 *    u_char HUGE *srcMem  source row

 *    u_char HUGE *dstMem  destination row

 *

 *    int xlt0             ignored

 *    int xNormal          See blcCopyBlockBC.

 *    int xgtmax           ignored

 *

 *    roundInc             See blcCopyBlockSub*.

 *

 * Function:

 *    This macro copies a row of pixels and assumes that

 *       - all pixels are within the image area

 *       - the pixels are in integer pixel position in vertical direction

 *       - the pixels are in half pixel position in horizontal direction

 *

 *    dstMem is increased by xNormal

 *    srcMem is increased by xNormal

 *

 * Changes:

 *    srcMem

 *    dstMem

 *    loopVar

 *

 * Returns:

 *    Nothing.

 *

 * Error codes:

 *    None.

 *

 */

#define blcCopyRowSubXNBC(srcMem, dstMem, xlt0, xNormal, xgtmax, loopVar, roundInc) \

for (loopVar = xNormal; loopVar; loopVar--, srcMem++) \

   *dstMem++ = (u_char) ((*srcMem + *(srcMem + 1) + roundInc) >> 1)

/*

 *

 * blcCopyRowSubXBC

 *

 * Parameters:

 *    u_char HUGE *srcMem  source row

 *    u_char HUGE *dstMem  destination row

 *

 *    int xlt0             See blcCopyBlockBC.

 *    int xNormal          See blcCopyBlockBC.

 *    int xgtmax           See blcCopyBlockBC.

 *

 *    roundInc             See blcCopyBlockSub*.

 *

 * Function:

 *    This macro copies a row of pixels and assumes that

 *       - xlt0 pixels are in the left side of the image area and

 *       - xgtmax pixels are in the right side of the image area and

 *       - the pixels are in integer pixel position in vertical direction

 *       - the pixels are in half pixel position in horizontal direction

 *

 *    dstMem is increased by xlt0 + xNormal + xgtmax

 *    srcMem is increased by xlt0 + xNormal + xgtmax

 *

 * Changes:

 *    srcMem

 *    dstMem

 *    loopVar

 *

 * Returns:

 *    Nothing.

 *

 * Error codes:

 *    None.

 *

 */

#define blcCopyRowSubXBC(srcMem, dstMem, xlt0, xNormal, xgtmax, loopVar, roundInc) \

{ \

   if (xlt0) \

      blcMemSetIncBuf(dstMem, *srcMem, xlt0); \

   blcCopyRowSubXNBC(srcMem, dstMem, xlt0, xNormal, xgtmax, loopVar, roundInc); \

   if (xgtmax) blcMemSetIncBuf(dstMem, *srcMem, xgtmax); \

}

/*

 *

 * blcCopyRowSubYNBC

 *

 * Parameters:

 *    u_char HUGE *srcMem  source row

 *    u_char HUGE *dstMem  destination row

 *

 *    int xlt0             ignored

 *    int xNormal          See blcCopyBlockBC.

 *    int xgtmax           ignored

 *

 *    roundInc             See blcCopyBlockSub*.

 *

 * Function:

 *    This macro copies a row of pixels and assumes that

 *       - all pixels are within the image area

 *       - the pixels are in half pixel position in vertical direction

 *       - the pixels are in integer pixel position in horizontal direction

 *

 *    dstMem is increased by xNormal

 *    srcMem is increased by xNormal - 1 if xNormal > 0

 *

 * Changes:

 *    srcMem

 *    dstMem

 *    loopVar

 *

 * Returns:

 *    Nothing.

 *

 * Error codes:

 *    None.

 *

 */

#define blcCopyRowSubYNBC(srcMem, dstMem, xlt0, xNormal, xgtmax, loopVar, \

   srcXSize, roundInc) \

{ \

   for (loopVar = xNormal; loopVar; loopVar--, srcMem++) \

      *dstMem++ = (u_char) ((*srcMem + *(srcMem + srcXSize) + roundInc) >> 1); \

   if (xNormal) srcMem--; \

}

/*

 *

 * blcCopyRowSubYBC

 *

 * Parameters:

 *    u_char HUGE *srcMem  source row

 *    u_char HUGE *dstMem  destination row

 *

 *    int xlt0             See blcCopyBlockBC.

 *    int xNormal          See blcCopyBlockBC.

 *    int xgtmax           See blcCopyBlockBC.

 *

 *    roundInc             See blcCopyBlockSub*.

 *

 * Function:

 *    This macro copies a row of pixels and assumes that

 *       - xlt0 pixels are in the left side of the image area and

 *       - xgtmax pixels are in the right side of the image area and

 *       - the pixels are in half pixel position in vertical direction

 *       - the pixels are in integer pixel position in horizontal direction

 *

 *    dstMem is increased by xlt0 + xNormal + xgtmax

 *    srcMem is increased by xNormal - 1 if xNormal > 0

 *

 * Changes:

 *    srcMem

 *    dstMem

 *    loopVar

 *

 * Returns:

 *    Nothing.

 *

 * Error codes:

 *    None.

 *

 */

#define blcCopyRowSubYBC(srcMem, dstMem, xlt0, xNormal, xgtmax, loopVar, \

   srcXSize, roundInc) \

{ \

   if (xlt0) { \

      *dstMem++ = (u_char) ((*srcMem + *(srcMem + srcXSize) + roundInc) >> 1); \

      if (xlt0 > 1) blcMemSetIncBuf(dstMem, *(dstMem - 1), xlt0 - 1); \

   } \

   blcCopyRowSubYNBC(srcMem, dstMem, xlt0, xNormal, xgtmax, loopVar, \

      srcXSize, roundInc); \

   if (xgtmax) { \

      if (xNormal) { \

         blcMemSetIncBuf(dstMem, *(dstMem - 1), xgtmax); \

      } \

      else { \

         *dstMem++ = (u_char) ((*srcMem + *(srcMem + srcXSize) + roundInc) >> 1); \

         if (xgtmax > 1) blcMemSetIncBuf(dstMem, *(dstMem - 1), xgtmax - 1); \

      } \

   } \

}

/*

 *

 * blcCopyRowSubXYNBC

 *

 * Parameters:

 *    u_char HUGE *srcMem  source row

 *    u_char HUGE *dstMem  destination row

 *

 *    int xlt0             ignored

 *    int xNormal          See blcCopyBlockBC.

 *    int xgtmax           ignored

 *

 *    roundInc             See blcCopyBlockSub*.

 *

 * Function:

 *    This macro copies a row of pixels and assumes that

 *       - all pixels are within the image area

 *       - the pixels are in half pixel position in vertical direction

 *       - the pixels are in half pixel position in horizontal direction

 *

 *    dstMem is increased by xNormal

 *    srcMem is increased by xNormal

 *

 * Changes:

 *    srcMem

 *    dstMem

 *    loopVar

 *

 * Returns:

 *    Nothing.

 *

 * Error codes:

 *    None.

 *

 */

#define blcCopyRowSubXYNBC(srcMem, dstMem, xlt0, xNormal, xgtmax, loopVar, \

   srcXSize, roundInc) \

for (loopVar = xNormal; loopVar; loopVar--, srcMem++) \

   *dstMem++ = (u_char) ((*srcMem + *(srcMem + 1) + *(srcMem + srcXSize) + \

      *(srcMem + srcXSize + 1) + roundInc) >> 2)

/*

 *

 * blcCopyOutPicXPixelSubXYRoundInc1

 * blcCopyOutPicXPixelSubXYRoundInc2

 *

 * Parameters:

 *    u_char HUGE *srcMem  source row

 *    u_char HUGE *dstMem  destination row

 *    srcXSize             number of pixels (bytes) in source row

 *

 * Function:

 *    These macros copy one pixel which lies horizontally outside the picture

 *    area assuming that

 *       - the pixels are in half pixel position in vertical direction

 *       - the pixels are in half pixel position in horizontal direction

 *

 *    If roundInc is 2, the macro takes advantage of the fact that

 *       (A + B + C + D + roundInc) / 4 = (A + A + C + C + 2) / 4 = 

 *       (A + C + 1) / 2

 *    when using the notation of section 6.1.2 of the H.263 recommendation.

 *

 *    dstMem is increased by 1

 *

 * Changes:

 *    dstMem

 *

 * Returns:

 *    Nothing.

 *

 * Error codes:

 *    None.

 *

 */

#define blcCopyOutPicXPixelSubXYRoundInc2(srcMem, dstMem, srcXSize) \

   *dstMem++ = (u_char) ((*srcMem + *(srcMem + srcXSize) + 1) >> 1)

#define blcCopyOutPicXPixelSubXYRoundInc1(srcMem, dstMem, srcXSize) \

   *dstMem++ = (u_char) ((((*srcMem) << 1) + ((*(srcMem + srcXSize)) << 1) + 1) >> 2)

/*

 *

 * blcCopyRowSubXYBC

 *

 * Parameters:

 *    u_char HUGE *srcMem  source row

 *    u_char HUGE *dstMem  destination row

 *

 *    int xlt0             ignored

 *    int xNormal          See blcCopyBlockBC.

 *    int xgtmax           ignored

 *

 *    roundInc             See blcCopyBlockSub*.

 *

 * Function:

 *    This macro copies a row of pixels and assumes that

 *       - xlt0 pixels are in the left side of the image area and

 *       - xgtmax pixels are in the right side of the image area and

 *       - the pixels are in half pixel position in vertical direction

 *       - the pixels are in half pixel position in horizontal direction

 *

 *    dstMem is increased by xNormal

 *    srcMem is increased by xNormal

 *

 * Changes:

 *    srcMem

 *    dstMem

 *    loopVar

 *

 * Returns:

 *    Nothing.

 *

 * Error codes:

 *    None.

 *

 */

#define blcCopyRowSubXYBC(srcMem, dstMem, xlt0, xNormal, xgtmax, loopVar, \

   srcXSize, roundInc) \

{ \

   if (xlt0) { \

      blcCopyOutPicXPixelSubXYRoundInc ## roundInc(srcMem, dstMem, srcXSize); \

      if (xlt0 > 1) blcMemSetIncBuf(dstMem, *(dstMem - 1), xlt0 - 1); \

   } \

   blcCopyRowSubXYNBC(srcMem, dstMem, xlt0, xNormal, xgtmax, loopVar, \

      srcXSize, roundInc); \

   if (xgtmax) { \

      blcCopyOutPicXPixelSubXYRoundInc ## roundInc(srcMem, dstMem, srcXSize); \

      if (xgtmax > 1) blcMemSetIncBuf(dstMem, *(dstMem - 1), xgtmax - 1); \

   } \

}

/*

 *

 * blcCopyOutPicRowSubXYRoundInc1

 * blcCopyOutPicRowSubXYRoundInc2

 *

 * Parameters:

 *    u_char HUGE *srcMem  source row

 *    u_char HUGE *dstMem  destination row

 *    srcXSize             number of pixels (bytes) in source row

 *

 * Function:

 *    These macros copy one row which lies vertically outside the picture

 *    area assuming that

 *       - the pixels are in half pixel position in vertical direction

 *       - the pixels are in half pixel position in horizontal direction

 *

 *    If roundInc is 2, the macro takes advantage of the fact that

 *       (A + B + C + D + roundInc) / 4 = (A + A + B + B + 2) / 4 = 

 *       (A + B + 1) / 2

 *    when using the notation of section 6.1.2 of the H.263 recommendation.

 *

 * Changes:

 *    srcMem

 *    dstMem

 *    loopVar

 *

 * Returns:

 *    Nothing.

 *

 * Error codes:

 *    None.

 *

 */

#define blcCopyOutPicRowSubXYRoundInc2(borderCheck, srcMem, dstMem, \

   xlt0, xNormal, xgtmax, loopVar, srcXSize) \

   blcCopyRowSubX ## borderCheck(srcMem, dstMem, xlt0, xNormal, xgtmax, loopVar, 1)

#define blcCopyOutPicRowSubXYRoundInc1NBC(srcMem, dstMem, xlt0, xNormal, xgtmax, loopVar, srcXSize) \

   for (loopVar = xNormal; loopVar; loopVar--, srcMem++) \

      *dstMem++ = (u_char) ((((*srcMem) << 1) + ((*(srcMem + 1)) << 1) + 1) >> 2)

#define blcCopyOutPicRowSubXYRoundInc1BC(srcMem, dstMem, xlt0, xNormal, xgtmax, loopVar, srcXSize) \

{ \

   if (xlt0) {\

      blcMemSetIncBuf(dstMem, *(srcMem), xlt0); \

   } \

   blcCopyOutPicRowSubXYRoundInc1NBC(srcMem, dstMem, xlt0, xNormal, xgtmax, loopVar, srcXSize); \

   if (xgtmax) { \

      blcMemSetIncBuf(dstMem, *(srcMem), xgtmax); \

   } \

}

#define blcCopyOutPicRowSubXYRoundInc1(borderCheck, srcMem, dstMem, \

   xlt0, xNormal, xgtmax, loopVar, srcXSize) \

   blcCopyOutPicRowSubXYRoundInc1 ## borderCheck(srcMem, dstMem, \

      xlt0, xNormal, xgtmax, loopVar, srcXSize)

/*

 *

 * Integer pixel position (x and y picture boundary checks respectively):

 *    blcCopyBlockNoSubNBCBC

 *    blcCopyBlockNoSubBCNBC

 *    blcCopyBlockNoSubNBCNBC