text: /* FreeRDP: A Remote Desktop Protocol Client
   * Copy operations.
   * vi:ts=4 sw=4:
   *
   * (c) Copyright 2012 Hewlett-Packard Development Company, L.P.
   * Licensed under the Apache License, Version 2.0 (the "License"); you may
   * not use this file except in compliance with the License. You may obtain
   * a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
   * or implied. See the License for the specific language governing
   * permissions and limitations under the License.
   */
  
  #ifdef HAVE_CONFIG_H
  #include "config.h"
  #endif
  
  #include <string.h>
  #include <freerdp/types.h>
  #include <freerdp/primitives.h>
  #ifdef WITH_IPP
  # include <ipps.h>
  # include <ippi.h>
  #endif /* WITH_IPP */
  #include "prim_internal.h"
  
  static primitives_t* generic = NULL;
  
  /* ------------------------------------------------------------------------- */
  /*static inline BOOL memory_regions_overlap_1d(*/
  static BOOL memory_regions_overlap_1d(
      const BYTE* p1,
      const BYTE* p2,
      size_t bytes)
  {
  	const ULONG_PTR p1m = (const ULONG_PTR) p1;
  	const ULONG_PTR p2m = (const ULONG_PTR) p2;
  
  	if (p1m <= p2m)
  	{
  		if (p1m + bytes > p2m) return TRUE;
  	}
  	else
  	{
  		if (p2m + bytes > p1m) return TRUE;
  	}
  
  	/* else */
  	return FALSE;
  }
  
  /* ------------------------------------------------------------------------- */
  /*static inline BOOL memory_regions_overlap_2d( */
  static BOOL memory_regions_overlap_2d(
      const BYTE* p1,  int p1Step,  int p1Size,
      const BYTE* p2,  int p2Step,  int p2Size,
      int width,  int height)
  {
  	ULONG_PTR p1m = (ULONG_PTR) p1;
  	ULONG_PTR p2m = (ULONG_PTR) p2;
  
  	if (p1m <= p2m)
  	{
  		ULONG_PTR p1mEnd = p1m + (height - 1) * p1Step + width * p1Size;
  
  		if (p1mEnd > p2m) return TRUE;
  	}
  	else
  	{
  		ULONG_PTR p2mEnd = p2m + (height - 1) * p2Step + width * p2Size;
  
  		if (p2mEnd > p1m) return TRUE;
  	}
  
  	/* else */
  	return FALSE;
  }
  
  /* ------------------------------------------------------------------------- */
  static pstatus_t general_copy_8u(
      const BYTE* pSrc,
      BYTE* pDst,
      INT32 len)
  {
  	if (memory_regions_overlap_1d(pSrc, pDst, (size_t) len))
  	{
  		memmove((void*) pDst, (const void*) pSrc, (size_t) len);
  	}
  	else
  	{
  		memcpy((void*) pDst, (const void*) pSrc, (size_t) len);
  	}
  
  	return PRIMITIVES_SUCCESS;
  }
  
  /* ------------------------------------------------------------------------- */
  /* Copy a block of pixels from one buffer to another.
   * The addresses are assumed to have been already offset to the upper-left
   * corners of the source and destination region of interest.
   */
  static pstatus_t general_copy_8u_AC4r(
      const BYTE* pSrc,  INT32 srcStep,
      BYTE* pDst,  INT32 dstStep,
      INT32 width,  INT32 height)
  {
  	const BYTE* src = (const BYTE*) pSrc;
  	BYTE* dst = (BYTE*) pDst;
  	int rowbytes = width * sizeof(UINT32);
  
  	if ((width == 0) || (height == 0)) return PRIMITIVES_SUCCESS;
  
  	if (memory_regions_overlap_2d(pSrc, srcStep, sizeof(UINT32),
  	                              pDst, dstStep, sizeof(UINT32), width, height))
  	{
  		do
  		{
  			generic->copy(src, dst, rowbytes);
  			src += srcStep;
  			dst += dstStep;
  		}
  		while (--height);
  	}
  	else
  	{
  		/* TODO: do it in one operation when the rowdata is adjacent. */
  		do
  		{
  			/* If we find a replacement for memcpy that is consistently
  			 * faster, this could be replaced with that.
  			 */
  			memcpy(dst, src, rowbytes);
  			src += srcStep;
  			dst += dstStep;
  		}
  		while (--height);
  	}
  
  	return PRIMITIVES_SUCCESS;
  }
  
  #ifdef WITH_IPP
  /* ------------------------------------------------------------------------- */
  /* This is just ippiCopy_8u_AC4R without the IppiSize structure parameter.   */
  static pstatus_t ippiCopy_8u_AC4r(
      const BYTE* pSrc,  INT32 srcStep,
      BYTE* pDst,  INT32 dstStep,
      INT32 width,  INT32 height)
  {
  	IppiSize roi;
  	roi.width  = width;
  	roi.height = height;
  	return (pstatus_t) ippiCopy_8u_AC4R(pSrc, srcStep, pDst, dstStep, roi);
  }
  #endif /* WITH_IPP */
  
  /* ------------------------------------------------------------------------- */
  void primitives_init_copy(
      primitives_t* prims)
  {
  	/* Start with the default. */
  	prims->copy_8u = general_copy_8u;
  	prims->copy_8u_AC4r = general_copy_8u_AC4r;
  	/* This is just an alias with void* parameters */
  	prims->copy    = (__copy_t)(prims->copy_8u);
  }
  
  void primitives_init_copy_opt(
      primitives_t* prims)
  {
  	generic = primitives_get_generic();
  	primitives_init_copy(prims);
  	/* Pick tuned versions if possible. */
  #ifdef WITH_IPP
  	prims->copy_8u = (__copy_8u_t) ippsCopy_8u;
  	prims->copy_8u_AC4r = (__copy_8u_AC4r_t) ippiCopy_8u_AC4r;
  #endif
  	/* Performance with an SSE2 version with no prefetch seemed to be
  	 * all over the map vs. memcpy.
  	 * Sometimes it was significantly faster, sometimes dreadfully slower,
  	 * and it seemed to vary a lot depending on block size and processor.
  	 * Hence, no SSE version is used here unless once can be written that
  	 * is consistently faster than memcpy.
  	 */
  	/* This is just an alias with void* parameters */
  	prims->copy    = (__copy_t)(prims->copy_8u);
  }
  