mg_dla_c4.c

Go to the documentation of this file.

/*******************************************************************************
 * Copyright © 2014 The DTVKit Open Software Foundation Ltd (www.dtvkit.org)
 * Copyright © 2008 Ocean Blue Software Ltd
 *
 * This file is part of a DTVKit Software Component
 * You are permitted to copy, modify or distribute this file subject to the terms
 * of the DTVKit 1.0 Licence which can be found in licence.txt or at www.dtvkit.org
 * 
 * THIS CODE AND INFORMATION ARE PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND,
 * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE.
 * 
 * If you or your organisation is not a member of DTVKit then you have access
 * to this source code outside of the terms of the licence agreement
 * and you are expected to delete this and any associated files immediately.
 * Further information on DTVKit, membership and terms can be found at www.dtvkit.org
 *******************************************************************************/
/*---includes for this file--------------------------------------------------*/
#include "techtype.h"

#if defined(OSD_31_BIT) || defined(OSD_32_BIT)

#define DLA_MEMSET32_THRESHOLD (4)
#define DLA_MEMSET32_THRESHOLD_NEXT (16)
#define DLA_MEMSET32_MASK (0x3)

#define DLA_MEMSET( dp, c, n ) DLA_MemSet32((dp), (c), (n))

#define DLA_struct     _DLA4_Surface
#define DLA_Surface     DLA4_Surface
#define DLA_FUNCTION(func) DLA_PC4_ ## func
#define DLAColor  OSDColor

static void DLA_MemSet32(void *buf, U32BIT b, U32BIT size);

#include "mg_dla.inl"

static void DLA_MemSet32(void *buf, U32BIT b, U32BIT size)
{
   U32BIT i;
   U32BIT max_power;
   U32BIT remainder;
   U32BIT power;
   U8BIT *p = buf;

#ifdef DLA_BIG_ENDIAN
   /* Big endian */
   U8BIT b0 = (U8BIT)(b >> 24);
   U8BIT b1 = (U8BIT)(b >> 16);
   U8BIT b2 = (U8BIT)(b >> 8);
   U8BIT b3 = (U8BIT)b;
#else
   /* Little endian */
   U8BIT b0 = (U8BIT)b;
   U8BIT b1 = (U8BIT)(b >> 8);
   U8BIT b2 = (U8BIT)(b >> 16);
   U8BIT b3 = (U8BIT)(b >> 24);
#endif

   if (size > DLA_MEMSET32_THRESHOLD)
   {
      /* First part is filled "manually" */
      for (i = 0; i < DLA_MEMSET32_THRESHOLD; ++i)
      {
         *p++ = b0;
         *p++ = b1;
         *p++ = b2;
         *p++ = b3;
      }

      power = DLA_MEMSET32_THRESHOLD_NEXT;
      max_power = size;
      max_power |= max_power >> 1;
      max_power |= max_power >> 2;
      max_power |= max_power >> 4;
      max_power |= max_power >> 8;
      max_power |= max_power >> 16;
      remainder = (size << 2) & (max_power << 1);
      ++max_power;
      max_power <<= 1;

      /* Second part is filled in powers of two, by copying larger and
       * larger blocks.
       */
      p = buf;
      while (power < max_power)
      {
         memcpy(p + power, p, power);
         power <<= 1;
      }

      /* Third part is the remainder. It's definitely smaller than what
       * we already have, so we can use what we have to fill the remainder.
       */
      if (remainder > 0)
      {
         memcpy(p + power, p, remainder);
      }
   }
   else
   {
      /* Too short to be clever - "manual" fill */
      for (i = 0; i < size; ++i)
      {
         *p++ = b0;
         *p++ = b1;
         *p++ = b2;
         *p++ = b3;
      }
   }
}

#endif /* OSD_32_BIT */