updae source to 2.0.9 source

Edward Rudd

2019-04-09 9cd2e9ec8fc0127393dfce9c0359d500c8c238be

 source/src/video/SDL_blit_A.c

@@ -45,28 +45,28 @@
    const unsigned A = info->a;

    while (height--) {
       /* *INDENT-OFF* */
       DUFFS_LOOP4(
       {
      DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel, sR, sG, sB);
      dR = dstfmt->palette->colors[*dst].r;
      dG = dstfmt->palette->colors[*dst].g;
      dB = dstfmt->palette->colors[*dst].b;
      ALPHA_BLEND_RGB(sR, sG, sB, A, dR, dG, dB);
      dR &= 0xff;
      dG &= 0xff;
      dB &= 0xff;
      /* Pack RGB into 8bit pixel */
      if ( palmap == NULL ) {
          *dst =((dR>>5)<<(3+2))|((dG>>5)<<(2))|((dB>>6)<<(0));
      } else {
          *dst = palmap[((dR>>5)<<(3+2))|((dG>>5)<<(2))|((dB>>6)<<(0))];
      }
      dst++;
      src += srcbpp;
       },
       width);
       /* *INDENT-ON* */
        /* *INDENT-OFF* */
        DUFFS_LOOP4(
        {
        DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel, sR, sG, sB);
        dR = dstfmt->palette->colors[*dst].r;
        dG = dstfmt->palette->colors[*dst].g;
        dB = dstfmt->palette->colors[*dst].b;
        ALPHA_BLEND_RGB(sR, sG, sB, A, dR, dG, dB);
        dR &= 0xff;
        dG &= 0xff;
        dB &= 0xff;
        /* Pack RGB into 8bit pixel */
        if ( palmap == NULL ) {
            *dst =((dR>>5)<<(3+2))|((dG>>5)<<(2))|((dB>>6)<<(0));
        } else {
            *dst = palmap[((dR>>5)<<(3+2))|((dG>>5)<<(2))|((dB>>6)<<(0))];
        }
        dst++;
        src += srcbpp;
        },
        width);
        /* *INDENT-ON* */
        src += srcskip;
        dst += dstskip;
    }
@@ -91,28 +91,28 @@
    unsigned dR, dG, dB;

    while (height--) {
       /* *INDENT-OFF* */
       DUFFS_LOOP4(
       {
      DISEMBLE_RGBA(src,srcbpp,srcfmt,Pixel,sR,sG,sB,sA);
      dR = dstfmt->palette->colors[*dst].r;
      dG = dstfmt->palette->colors[*dst].g;
      dB = dstfmt->palette->colors[*dst].b;
      ALPHA_BLEND_RGB(sR, sG, sB, sA, dR, dG, dB);
      dR &= 0xff;
      dG &= 0xff;
      dB &= 0xff;
      /* Pack RGB into 8bit pixel */
      if ( palmap == NULL ) {
          *dst =((dR>>5)<<(3+2))|((dG>>5)<<(2))|((dB>>6)<<(0));
      } else {
          *dst = palmap[((dR>>5)<<(3+2))|((dG>>5)<<(2))|((dB>>6)<<(0))];
      }
      dst++;
      src += srcbpp;
       },
       width);
       /* *INDENT-ON* */
        /* *INDENT-OFF* */
        DUFFS_LOOP4(
        {
        DISEMBLE_RGBA(src,srcbpp,srcfmt,Pixel,sR,sG,sB,sA);
        dR = dstfmt->palette->colors[*dst].r;
        dG = dstfmt->palette->colors[*dst].g;
        dB = dstfmt->palette->colors[*dst].b;
        ALPHA_BLEND_RGB(sR, sG, sB, sA, dR, dG, dB);
        dR &= 0xff;
        dG &= 0xff;
        dB &= 0xff;
        /* Pack RGB into 8bit pixel */
        if ( palmap == NULL ) {
            *dst =((dR>>5)<<(3+2))|((dG>>5)<<(2))|((dB>>6)<<(0));
        } else {
            *dst = palmap[((dR>>5)<<(3+2))|((dG>>5)<<(2))|((dB>>6)<<(0))];
        }
        dst++;
        src += srcbpp;
        },
        width);
        /* *INDENT-ON* */
        src += srcskip;
        dst += dstskip;
    }
@@ -139,30 +139,30 @@
    const unsigned A = info->a;

    while (height--) {
       /* *INDENT-OFF* */
       DUFFS_LOOP(
       {
      DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel, sR, sG, sB);
      if ( Pixel != ckey ) {
          dR = dstfmt->palette->colors[*dst].r;
          dG = dstfmt->palette->colors[*dst].g;
          dB = dstfmt->palette->colors[*dst].b;
          ALPHA_BLEND_RGB(sR, sG, sB, A, dR, dG, dB);
          dR &= 0xff;
          dG &= 0xff;
          dB &= 0xff;
          /* Pack RGB into 8bit pixel */
          if ( palmap == NULL ) {
        /* *INDENT-OFF* */
        DUFFS_LOOP(
        {
        DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel, sR, sG, sB);
        if ( Pixel != ckey ) {
            dR = dstfmt->palette->colors[*dst].r;
            dG = dstfmt->palette->colors[*dst].g;
            dB = dstfmt->palette->colors[*dst].b;
            ALPHA_BLEND_RGB(sR, sG, sB, A, dR, dG, dB);
            dR &= 0xff;
            dG &= 0xff;
            dB &= 0xff;
            /* Pack RGB into 8bit pixel */
            if ( palmap == NULL ) {
                *dst =((dR>>5)<<(3+2))|((dG>>5)<<(2))|((dB>>6)<<(0));
          } else {
            } else {
                *dst = palmap[((dR>>5)<<(3+2))|((dG>>5)<<(2))|((dB>>6)<<(0))];
          }
      }
      dst++;
      src += srcbpp;
       },
       width);
       /* *INDENT-ON* */
            }
        }
        dst++;
        src += srcbpp;
        },
        width);
        /* *INDENT-ON* */
        src += srcskip;
        dst += dstskip;
    }
@@ -342,45 +342,45 @@

    mm_zero = _mm_setzero_si64();       /* 0 -> mm_zero */
    multmask = 0x00FF;
   multmask <<= (ashift * 2);
   multmask2 = 0x00FF00FF00FF00FFULL;
    multmask <<= (ashift * 2);
    multmask2 = 0x00FF00FF00FF00FFULL;

    while (height--) {
      /* *INDENT-OFF* */
      DUFFS_LOOP4({
      Uint32 alpha = *srcp & amask;
      if (alpha == 0) {
         /* do nothing */
      } else if (alpha == amask) {
         *dstp = *srcp;
      } else {
         src1 = _mm_cvtsi32_si64(*srcp); /* src(ARGB) -> src1 (0000ARGB) */
         src1 = _mm_unpacklo_pi8(src1, mm_zero); /* 0A0R0G0B -> src1 */
        /* *INDENT-OFF* */
        DUFFS_LOOP4({
        Uint32 alpha = *srcp & amask;
        if (alpha == 0) {
            /* do nothing */
        } else if (alpha == amask) {
            *dstp = *srcp;
        } else {
            src1 = _mm_cvtsi32_si64(*srcp); /* src(ARGB) -> src1 (0000ARGB) */
            src1 = _mm_unpacklo_pi8(src1, mm_zero); /* 0A0R0G0B -> src1 */

         dst1 = _mm_cvtsi32_si64(*dstp); /* dst(ARGB) -> dst1 (0000ARGB) */
         dst1 = _mm_unpacklo_pi8(dst1, mm_zero); /* 0A0R0G0B -> dst1 */
            dst1 = _mm_cvtsi32_si64(*dstp); /* dst(ARGB) -> dst1 (0000ARGB) */
            dst1 = _mm_unpacklo_pi8(dst1, mm_zero); /* 0A0R0G0B -> dst1 */

         mm_alpha = _mm_cvtsi32_si64(alpha); /* alpha -> mm_alpha (0000000A) */
         mm_alpha = _mm_srli_si64(mm_alpha, ashift); /* mm_alpha >> ashift -> mm_alpha(0000000A) */
         mm_alpha = _mm_unpacklo_pi16(mm_alpha, mm_alpha); /* 00000A0A -> mm_alpha */
         mm_alpha2 = _mm_unpacklo_pi32(mm_alpha, mm_alpha); /* 0A0A0A0A -> mm_alpha2 */
         mm_alpha = _mm_or_si64(mm_alpha2, *(__m64 *) & multmask);   /* 0F0A0A0A -> mm_alpha */
         mm_alpha2 = _mm_xor_si64(mm_alpha2, *(__m64 *) & multmask2);   /* 255 - mm_alpha -> mm_alpha */
            mm_alpha = _mm_cvtsi32_si64(alpha); /* alpha -> mm_alpha (0000000A) */
            mm_alpha = _mm_srli_si64(mm_alpha, ashift); /* mm_alpha >> ashift -> mm_alpha(0000000A) */
            mm_alpha = _mm_unpacklo_pi16(mm_alpha, mm_alpha); /* 00000A0A -> mm_alpha */
            mm_alpha2 = _mm_unpacklo_pi32(mm_alpha, mm_alpha); /* 0A0A0A0A -> mm_alpha2 */
            mm_alpha = _mm_or_si64(mm_alpha2, *(__m64 *) & multmask);    /* 0F0A0A0A -> mm_alpha */
            mm_alpha2 = _mm_xor_si64(mm_alpha2, *(__m64 *) & multmask2);    /* 255 - mm_alpha -> mm_alpha */

         /* blend */		    
         src1 = _mm_mullo_pi16(src1, mm_alpha);
         src1 = _mm_srli_pi16(src1, 8);
         dst1 = _mm_mullo_pi16(dst1, mm_alpha2);
         dst1 = _mm_srli_pi16(dst1, 8);
         dst1 = _mm_add_pi16(src1, dst1);
         dst1 = _mm_packs_pu16(dst1, mm_zero);
			
         *dstp = _mm_cvtsi64_si32(dst1); /* dst1 -> pixel */
      }
      ++srcp;
      ++dstp;
       }, width);
      /* *INDENT-ON* */
            /* blend */            
            src1 = _mm_mullo_pi16(src1, mm_alpha);
            src1 = _mm_srli_pi16(src1, 8);
            dst1 = _mm_mullo_pi16(dst1, mm_alpha2);
            dst1 = _mm_srli_pi16(dst1, 8);
            dst1 = _mm_add_pi16(src1, dst1);
            dst1 = _mm_packs_pu16(dst1, mm_zero);
            
            *dstp = _mm_cvtsi64_si32(dst1); /* dst1 -> pixel */
        }
        ++srcp;
        ++dstp;
        }, width);
        /* *INDENT-ON* */
        srcp += srcskip;
        dstp += dstskip;
    }
@@ -401,14 +401,14 @@
    int dstskip = info->dst_skip >> 2;

    while (height--) {
       /* *INDENT-OFF* */
       DUFFS_LOOP4({
          Uint32 s = *srcp++;
          Uint32 d = *dstp;
          *dstp++ = ((((s & 0x00fefefe) + (d & 0x00fefefe)) >> 1)
                + (s & d & 0x00010101)) | 0xff000000;
       }, width);
       /* *INDENT-ON* */
        /* *INDENT-OFF* */
        DUFFS_LOOP4({
            Uint32 s = *srcp++;
            Uint32 d = *dstp;
            *dstp++ = ((((s & 0x00fefefe) + (d & 0x00fefefe)) >> 1)
                   + (s & d & 0x00010101)) | 0xff000000;
        }, width);
        /* *INDENT-ON* */
        srcp += srcskip;
        dstp += dstskip;
    }
@@ -434,22 +434,22 @@
        Uint32 d1;

        while (height--) {
         /* *INDENT-OFF* */
         DUFFS_LOOP4({
            s = *srcp;
            d = *dstp;
            s1 = s & 0xff00ff;
            d1 = d & 0xff00ff;
            d1 = (d1 + ((s1 - d1) * alpha >> 8))
                 & 0xff00ff;
            s &= 0xff00;
            d &= 0xff00;
            d = (d + ((s - d) * alpha >> 8)) & 0xff00;
            *dstp = d1 | d | 0xff000000;
            ++srcp;
            ++dstp;
         }, width);
         /* *INDENT-ON* */
            /* *INDENT-OFF* */
            DUFFS_LOOP4({
                s = *srcp;
                d = *dstp;
                s1 = s & 0xff00ff;
                d1 = d & 0xff00ff;
                d1 = (d1 + ((s1 - d1) * alpha >> 8))
                     & 0xff00ff;
                s &= 0xff00;
                d &= 0xff00;
                d = (d + ((s - d) * alpha >> 8)) & 0xff00;
                *dstp = d1 | d | 0xff000000;
                ++srcp;
                ++dstp;
            }, width);
            /* *INDENT-ON* */
            srcp += srcskip;
            dstp += dstskip;
        }
@@ -468,42 +468,42 @@
    int dstskip = info->dst_skip >> 2;

    while (height--) {
       /* *INDENT-OFF* */
       DUFFS_LOOP4({
      Uint32 dalpha;
      Uint32 d;
      Uint32 s1;
      Uint32 d1;
      Uint32 s = *srcp;
      Uint32 alpha = s >> 24;
      /* FIXME: Here we special-case opaque alpha since the
         compositioning used (>>8 instead of /255) doesn't handle
         it correctly. Also special-case alpha=0 for speed?
         Benchmark this! */
      if (alpha) {
        if (alpha == SDL_ALPHA_OPAQUE) {
           *dstp = *srcp;
        } else {
          /*
           * take out the middle component (green), and process
           * the other two in parallel. One multiply less.
           */
          d = *dstp;
         dalpha = d >> 24;
          s1 = s & 0xff00ff;
          d1 = d & 0xff00ff;
          d1 = (d1 + ((s1 - d1) * alpha >> 8)) & 0xff00ff;
          s &= 0xff00;
          d &= 0xff00;
          d = (d + ((s - d) * alpha >> 8)) & 0xff00;
         dalpha = alpha + (dalpha * (alpha ^ 0xFF) >> 8);
          *dstp = d1 | d | (dalpha << 24);
        }
      }
      ++srcp;
      ++dstp;
       }, width);
       /* *INDENT-ON* */
        /* *INDENT-OFF* */
        DUFFS_LOOP4({
        Uint32 dalpha;
        Uint32 d;
        Uint32 s1;
        Uint32 d1;
        Uint32 s = *srcp;
        Uint32 alpha = s >> 24;
        /* FIXME: Here we special-case opaque alpha since the
           compositioning used (>>8 instead of /255) doesn't handle
           it correctly. Also special-case alpha=0 for speed?
           Benchmark this! */
        if (alpha) {
          if (alpha == SDL_ALPHA_OPAQUE) {
              *dstp = *srcp;
          } else {
            /*
             * take out the middle component (green), and process
             * the other two in parallel. One multiply less.
             */
            d = *dstp;
            dalpha = d >> 24;
            s1 = s & 0xff00ff;
            d1 = d & 0xff00ff;
            d1 = (d1 + ((s1 - d1) * alpha >> 8)) & 0xff00ff;
            s &= 0xff00;
            d &= 0xff00;
            d = (d + ((s - d) * alpha >> 8)) & 0xff00;
            dalpha = alpha + (dalpha * (alpha ^ 0xFF) >> 8);
            *dstp = d1 | d | (dalpha << 24);
          }
        }
        ++srcp;
        ++dstp;
        }, width);
        /* *INDENT-ON* */
        srcp += srcskip;
        dstp += dstskip;
    }
@@ -533,47 +533,47 @@
    multmask2 = 0x00FF00FF00FF00FFULL;

    while (height--) {
       /* *INDENT-OFF* */
       DUFFS_LOOP4({
      Uint32 alpha;
        /* *INDENT-OFF* */
        DUFFS_LOOP4({
        Uint32 alpha;

      _m_prefetch(srcp + 16);
      _m_prefetch(dstp + 16);
        _m_prefetch(srcp + 16);
        _m_prefetch(dstp + 16);

      alpha = *srcp & amask;
      if (alpha == 0) {
         /* do nothing */
      } else if (alpha == amask) {
         *dstp = *srcp;
      } else {
         src1 = _mm_cvtsi32_si64(*srcp); /* src(ARGB) -> src1 (0000ARGB) */
         src1 = _mm_unpacklo_pi8(src1, mm_zero); /* 0A0R0G0B -> src1 */
        alpha = *srcp & amask;
        if (alpha == 0) {
            /* do nothing */
        } else if (alpha == amask) {
            *dstp = *srcp;
        } else {
            src1 = _mm_cvtsi32_si64(*srcp); /* src(ARGB) -> src1 (0000ARGB) */
            src1 = _mm_unpacklo_pi8(src1, mm_zero); /* 0A0R0G0B -> src1 */

         dst1 = _mm_cvtsi32_si64(*dstp); /* dst(ARGB) -> dst1 (0000ARGB) */
         dst1 = _mm_unpacklo_pi8(dst1, mm_zero); /* 0A0R0G0B -> dst1 */
            dst1 = _mm_cvtsi32_si64(*dstp); /* dst(ARGB) -> dst1 (0000ARGB) */
            dst1 = _mm_unpacklo_pi8(dst1, mm_zero); /* 0A0R0G0B -> dst1 */

         mm_alpha = _mm_cvtsi32_si64(alpha); /* alpha -> mm_alpha (0000000A) */
         mm_alpha = _mm_srli_si64(mm_alpha, ashift); /* mm_alpha >> ashift -> mm_alpha(0000000A) */
         mm_alpha = _mm_unpacklo_pi16(mm_alpha, mm_alpha); /* 00000A0A -> mm_alpha */
         mm_alpha2 = _mm_unpacklo_pi32(mm_alpha, mm_alpha); /* 0A0A0A0A -> mm_alpha2 */
         mm_alpha = _mm_or_si64(mm_alpha2, *(__m64 *) & multmask);   /* 0F0A0A0A -> mm_alpha */
         mm_alpha2 = _mm_xor_si64(mm_alpha2, *(__m64 *) & multmask2);   /* 255 - mm_alpha -> mm_alpha */
            mm_alpha = _mm_cvtsi32_si64(alpha); /* alpha -> mm_alpha (0000000A) */
            mm_alpha = _mm_srli_si64(mm_alpha, ashift); /* mm_alpha >> ashift -> mm_alpha(0000000A) */
            mm_alpha = _mm_unpacklo_pi16(mm_alpha, mm_alpha); /* 00000A0A -> mm_alpha */
            mm_alpha2 = _mm_unpacklo_pi32(mm_alpha, mm_alpha); /* 0A0A0A0A -> mm_alpha2 */
            mm_alpha = _mm_or_si64(mm_alpha2, *(__m64 *) & multmask);    /* 0F0A0A0A -> mm_alpha */
            mm_alpha2 = _mm_xor_si64(mm_alpha2, *(__m64 *) & multmask2);    /* 255 - mm_alpha -> mm_alpha */


         /* blend */		    
         src1 = _mm_mullo_pi16(src1, mm_alpha);
         src1 = _mm_srli_pi16(src1, 8);
         dst1 = _mm_mullo_pi16(dst1, mm_alpha2);
         dst1 = _mm_srli_pi16(dst1, 8);
         dst1 = _mm_add_pi16(src1, dst1);
         dst1 = _mm_packs_pu16(dst1, mm_zero);
			
         *dstp = _mm_cvtsi64_si32(dst1); /* dst1 -> pixel */
      }
      ++srcp;
      ++dstp;
       }, width);
       /* *INDENT-ON* */
            /* blend */            
            src1 = _mm_mullo_pi16(src1, mm_alpha);
            src1 = _mm_srli_pi16(src1, 8);
            dst1 = _mm_mullo_pi16(dst1, mm_alpha2);
            dst1 = _mm_srli_pi16(dst1, 8);
            dst1 = _mm_add_pi16(src1, dst1);
            dst1 = _mm_packs_pu16(dst1, mm_zero);
            
            *dstp = _mm_cvtsi64_si32(dst1); /* dst1 -> pixel */
        }
        ++srcp;
        ++dstp;
        }, width);
        /* *INDENT-ON* */
        srcp += srcskip;
        dstp += dstskip;
    }
@@ -585,13 +585,13 @@
/* 16bpp special case for per-surface alpha=50%: blend 2 pixels in parallel */

/* blend a single 16 bit pixel at 50% */
#define BLEND16_50(d, s, mask)                  \
   ((((s & mask) + (d & mask)) >> 1) + (s & d & (~mask & 0xffff)))
#define BLEND16_50(d, s, mask)                        \
    ((((s & mask) + (d & mask)) >> 1) + (s & d & (~mask & 0xffff)))

/* blend two 16 bit pixels at 50% */
#define BLEND2x16_50(d, s, mask)                    \
   (((s & (mask | mask << 16)) >> 1) + ((d & (mask | mask << 16)) >> 1) \
    + (s & d & (~(mask | mask << 16))))
#define BLEND2x16_50(d, s, mask)                         \
    (((s & (mask | mask << 16)) >> 1) + ((d & (mask | mask << 16)) >> 1) \
     + (s & d & (~(mask | mask << 16))))

static void
Blit16to16SurfaceAlpha128(SDL_BlitInfo * info, Uint16 mask)
@@ -727,103 +727,103 @@
        bmask = _mm_set_pi32(0x001F001F, 0x001F001F);   /* MASKBLUE -> bmask */

        while (height--) {
         /* *INDENT-OFF* */
         DUFFS_LOOP_124(
         {
            s = *srcp++;
            d = *dstp;
            /*
             * shift out the middle component (green) to
             * the high 16 bits, and process all three RGB
             * components at the same time.
             */
            s = (s | s << 16) & 0x07e0f81f;
            d = (d | d << 16) & 0x07e0f81f;
            d += (s - d) * alpha >> 5;
            d &= 0x07e0f81f;
            *dstp++ = (Uint16)(d | d >> 16);
         },{
            s = *srcp++;
            d = *dstp;
            /*
             * shift out the middle component (green) to
             * the high 16 bits, and process all three RGB
             * components at the same time.
             */
            s = (s | s << 16) & 0x07e0f81f;
            d = (d | d << 16) & 0x07e0f81f;
            d += (s - d) * alpha >> 5;
            d &= 0x07e0f81f;
            *dstp++ = (Uint16)(d | d >> 16);
            s = *srcp++;
            d = *dstp;
            /*
             * shift out the middle component (green) to
             * the high 16 bits, and process all three RGB
             * components at the same time.
             */
            s = (s | s << 16) & 0x07e0f81f;
            d = (d | d << 16) & 0x07e0f81f;
            d += (s - d) * alpha >> 5;
            d &= 0x07e0f81f;
            *dstp++ = (Uint16)(d | d >> 16);
         },{
            src1 = *(__m64*)srcp; /* 4 src pixels -> src1 */
            dst1 = *(__m64*)dstp; /* 4 dst pixels -> dst1 */
            /* *INDENT-OFF* */
            DUFFS_LOOP_124(
            {
                s = *srcp++;
                d = *dstp;
                /*
                 * shift out the middle component (green) to
                 * the high 16 bits, and process all three RGB
                 * components at the same time.
                 */
                s = (s | s << 16) & 0x07e0f81f;
                d = (d | d << 16) & 0x07e0f81f;
                d += (s - d) * alpha >> 5;
                d &= 0x07e0f81f;
                *dstp++ = (Uint16)(d | d >> 16);
            },{
                s = *srcp++;
                d = *dstp;
                /*
                 * shift out the middle component (green) to
                 * the high 16 bits, and process all three RGB
                 * components at the same time.
                 */
                s = (s | s << 16) & 0x07e0f81f;
                d = (d | d << 16) & 0x07e0f81f;
                d += (s - d) * alpha >> 5;
                d &= 0x07e0f81f;
                *dstp++ = (Uint16)(d | d >> 16);
                s = *srcp++;
                d = *dstp;
                /*
                 * shift out the middle component (green) to
                 * the high 16 bits, and process all three RGB
                 * components at the same time.
                 */
                s = (s | s << 16) & 0x07e0f81f;
                d = (d | d << 16) & 0x07e0f81f;
                d += (s - d) * alpha >> 5;
                d &= 0x07e0f81f;
                *dstp++ = (Uint16)(d | d >> 16);
            },{
                src1 = *(__m64*)srcp; /* 4 src pixels -> src1 */
                dst1 = *(__m64*)dstp; /* 4 dst pixels -> dst1 */

            /* red */
            src2 = src1;
            src2 = _mm_srli_pi16(src2, 11); /* src2 >> 11 -> src2 [000r 000r 000r 000r] */
                /* red */
                src2 = src1;
                src2 = _mm_srli_pi16(src2, 11); /* src2 >> 11 -> src2 [000r 000r 000r 000r] */

            dst2 = dst1;
            dst2 = _mm_srli_pi16(dst2, 11); /* dst2 >> 11 -> dst2 [000r 000r 000r 000r] */
                dst2 = dst1;
                dst2 = _mm_srli_pi16(dst2, 11); /* dst2 >> 11 -> dst2 [000r 000r 000r 000r] */

            /* blend */
            src2 = _mm_sub_pi16(src2, dst2);/* src - dst -> src2 */
            src2 = _mm_mullo_pi16(src2, mm_alpha); /* src2 * alpha -> src2 */
            src2 = _mm_srli_pi16(src2, 11); /* src2 >> 11 -> src2 */
            dst2 = _mm_add_pi16(src2, dst2); /* src2 + dst2 -> dst2 */
            dst2 = _mm_slli_pi16(dst2, 11); /* dst2 << 11 -> dst2 */
                /* blend */
                src2 = _mm_sub_pi16(src2, dst2);/* src - dst -> src2 */
                src2 = _mm_mullo_pi16(src2, mm_alpha); /* src2 * alpha -> src2 */
                src2 = _mm_srli_pi16(src2, 11); /* src2 >> 11 -> src2 */
                dst2 = _mm_add_pi16(src2, dst2); /* src2 + dst2 -> dst2 */
                dst2 = _mm_slli_pi16(dst2, 11); /* dst2 << 11 -> dst2 */

            mm_res = dst2; /* RED -> mm_res */
                mm_res = dst2; /* RED -> mm_res */

            /* green -- process the bits in place */
            src2 = src1;
            src2 = _mm_and_si64(src2, gmask); /* src & MASKGREEN -> src2 */
                /* green -- process the bits in place */
                src2 = src1;
                src2 = _mm_and_si64(src2, gmask); /* src & MASKGREEN -> src2 */

            dst2 = dst1;
            dst2 = _mm_and_si64(dst2, gmask); /* dst & MASKGREEN -> dst2 */
                dst2 = dst1;
                dst2 = _mm_and_si64(dst2, gmask); /* dst & MASKGREEN -> dst2 */

            /* blend */
            src2 = _mm_sub_pi16(src2, dst2);/* src - dst -> src2 */
            src2 = _mm_mulhi_pi16(src2, mm_alpha); /* src2 * alpha -> src2 */
            src2 = _mm_slli_pi16(src2, 5); /* src2 << 5 -> src2 */
            dst2 = _mm_add_pi16(src2, dst2); /* src2 + dst2 -> dst2 */
                /* blend */
                src2 = _mm_sub_pi16(src2, dst2);/* src - dst -> src2 */
                src2 = _mm_mulhi_pi16(src2, mm_alpha); /* src2 * alpha -> src2 */
                src2 = _mm_slli_pi16(src2, 5); /* src2 << 5 -> src2 */
                dst2 = _mm_add_pi16(src2, dst2); /* src2 + dst2 -> dst2 */

            mm_res = _mm_or_si64(mm_res, dst2); /* RED | GREEN -> mm_res */
                mm_res = _mm_or_si64(mm_res, dst2); /* RED | GREEN -> mm_res */

            /* blue */
            src2 = src1;
            src2 = _mm_and_si64(src2, bmask); /* src & MASKBLUE -> src2[000b 000b 000b 000b] */
                /* blue */
                src2 = src1;
                src2 = _mm_and_si64(src2, bmask); /* src & MASKBLUE -> src2[000b 000b 000b 000b] */

            dst2 = dst1;
            dst2 = _mm_and_si64(dst2, bmask); /* dst & MASKBLUE -> dst2[000b 000b 000b 000b] */
                dst2 = dst1;
                dst2 = _mm_and_si64(dst2, bmask); /* dst & MASKBLUE -> dst2[000b 000b 000b 000b] */

            /* blend */
            src2 = _mm_sub_pi16(src2, dst2);/* src - dst -> src2 */
            src2 = _mm_mullo_pi16(src2, mm_alpha); /* src2 * alpha -> src2 */
            src2 = _mm_srli_pi16(src2, 11); /* src2 >> 11 -> src2 */
            dst2 = _mm_add_pi16(src2, dst2); /* src2 + dst2 -> dst2 */
            dst2 = _mm_and_si64(dst2, bmask); /* dst2 & MASKBLUE -> dst2 */
                /* blend */
                src2 = _mm_sub_pi16(src2, dst2);/* src - dst -> src2 */
                src2 = _mm_mullo_pi16(src2, mm_alpha); /* src2 * alpha -> src2 */
                src2 = _mm_srli_pi16(src2, 11); /* src2 >> 11 -> src2 */
                dst2 = _mm_add_pi16(src2, dst2); /* src2 + dst2 -> dst2 */
                dst2 = _mm_and_si64(dst2, bmask); /* dst2 & MASKBLUE -> dst2 */

            mm_res = _mm_or_si64(mm_res, dst2); /* RED | GREEN | BLUE -> mm_res */
                mm_res = _mm_or_si64(mm_res, dst2); /* RED | GREEN | BLUE -> mm_res */

            *(__m64*)dstp = mm_res; /* mm_res -> 4 dst pixels */
                *(__m64*)dstp = mm_res; /* mm_res -> 4 dst pixels */

            srcp += 4;
            dstp += 4;
         }, width);
         /* *INDENT-ON* */
                srcp += 4;
                dstp += 4;
            }, width);
            /* *INDENT-ON* */
            srcp += srcskip;
            dstp += dstskip;
        }
@@ -865,103 +865,103 @@
        bmask = _mm_set_pi32(0x001F001F, 0x001F001F);   /* MASKBLUE -> bmask */

        while (height--) {
         /* *INDENT-OFF* */
         DUFFS_LOOP_124(
         {
            s = *srcp++;
            d = *dstp;
            /*
             * shift out the middle component (green) to
             * the high 16 bits, and process all three RGB
             * components at the same time.
             */
            s = (s | s << 16) & 0x03e07c1f;
            d = (d | d << 16) & 0x03e07c1f;
            d += (s - d) * alpha >> 5;
            d &= 0x03e07c1f;
            *dstp++ = (Uint16)(d | d >> 16);
         },{
            s = *srcp++;
            d = *dstp;
            /*
             * shift out the middle component (green) to
             * the high 16 bits, and process all three RGB
             * components at the same time.
             */
            s = (s | s << 16) & 0x03e07c1f;
            d = (d | d << 16) & 0x03e07c1f;
            d += (s - d) * alpha >> 5;
            d &= 0x03e07c1f;
            *dstp++ = (Uint16)(d | d >> 16);
                 s = *srcp++;
            d = *dstp;
            /*
             * shift out the middle component (green) to
             * the high 16 bits, and process all three RGB
             * components at the same time.
             */
            s = (s | s << 16) & 0x03e07c1f;
            d = (d | d << 16) & 0x03e07c1f;
            d += (s - d) * alpha >> 5;
            d &= 0x03e07c1f;
            *dstp++ = (Uint16)(d | d >> 16);
         },{
            src1 = *(__m64*)srcp; /* 4 src pixels -> src1 */
            dst1 = *(__m64*)dstp; /* 4 dst pixels -> dst1 */
            /* *INDENT-OFF* */
            DUFFS_LOOP_124(
            {
                s = *srcp++;
                d = *dstp;
                /*
                 * shift out the middle component (green) to
                 * the high 16 bits, and process all three RGB
                 * components at the same time.
                 */
                s = (s | s << 16) & 0x03e07c1f;
                d = (d | d << 16) & 0x03e07c1f;
                d += (s - d) * alpha >> 5;
                d &= 0x03e07c1f;
                *dstp++ = (Uint16)(d | d >> 16);
            },{
                s = *srcp++;
                d = *dstp;
                /*
                 * shift out the middle component (green) to
                 * the high 16 bits, and process all three RGB
                 * components at the same time.
                 */
                s = (s | s << 16) & 0x03e07c1f;
                d = (d | d << 16) & 0x03e07c1f;
                d += (s - d) * alpha >> 5;
                d &= 0x03e07c1f;
                *dstp++ = (Uint16)(d | d >> 16);
                    s = *srcp++;
                d = *dstp;
                /*
                 * shift out the middle component (green) to
                 * the high 16 bits, and process all three RGB
                 * components at the same time.
                 */
                s = (s | s << 16) & 0x03e07c1f;
                d = (d | d << 16) & 0x03e07c1f;
                d += (s - d) * alpha >> 5;
                d &= 0x03e07c1f;
                *dstp++ = (Uint16)(d | d >> 16);
            },{
                src1 = *(__m64*)srcp; /* 4 src pixels -> src1 */
                dst1 = *(__m64*)dstp; /* 4 dst pixels -> dst1 */

            /* red -- process the bits in place */
            src2 = src1;
            src2 = _mm_and_si64(src2, rmask); /* src & MASKRED -> src2 */
                /* red -- process the bits in place */
                src2 = src1;
                src2 = _mm_and_si64(src2, rmask); /* src & MASKRED -> src2 */

            dst2 = dst1;
            dst2 = _mm_and_si64(dst2, rmask); /* dst & MASKRED -> dst2 */
                dst2 = dst1;
                dst2 = _mm_and_si64(dst2, rmask); /* dst & MASKRED -> dst2 */

            /* blend */
            src2 = _mm_sub_pi16(src2, dst2);/* src - dst -> src2 */
            src2 = _mm_mulhi_pi16(src2, mm_alpha); /* src2 * alpha -> src2 */
            src2 = _mm_slli_pi16(src2, 5); /* src2 << 5 -> src2 */
            dst2 = _mm_add_pi16(src2, dst2); /* src2 + dst2 -> dst2 */
            dst2 = _mm_and_si64(dst2, rmask); /* dst2 & MASKRED -> dst2 */
                /* blend */
                src2 = _mm_sub_pi16(src2, dst2);/* src - dst -> src2 */
                src2 = _mm_mulhi_pi16(src2, mm_alpha); /* src2 * alpha -> src2 */
                src2 = _mm_slli_pi16(src2, 5); /* src2 << 5 -> src2 */
                dst2 = _mm_add_pi16(src2, dst2); /* src2 + dst2 -> dst2 */
                dst2 = _mm_and_si64(dst2, rmask); /* dst2 & MASKRED -> dst2 */

            mm_res = dst2; /* RED -> mm_res */
				
            /* green -- process the bits in place */
            src2 = src1;
            src2 = _mm_and_si64(src2, gmask); /* src & MASKGREEN -> src2 */
                mm_res = dst2; /* RED -> mm_res */
                
                /* green -- process the bits in place */
                src2 = src1;
                src2 = _mm_and_si64(src2, gmask); /* src & MASKGREEN -> src2 */

            dst2 = dst1;
            dst2 = _mm_and_si64(dst2, gmask); /* dst & MASKGREEN -> dst2 */
                dst2 = dst1;
                dst2 = _mm_and_si64(dst2, gmask); /* dst & MASKGREEN -> dst2 */

            /* blend */
            src2 = _mm_sub_pi16(src2, dst2);/* src - dst -> src2 */
            src2 = _mm_mulhi_pi16(src2, mm_alpha); /* src2 * alpha -> src2 */
            src2 = _mm_slli_pi16(src2, 5); /* src2 << 5 -> src2 */
            dst2 = _mm_add_pi16(src2, dst2); /* src2 + dst2 -> dst2 */
                /* blend */
                src2 = _mm_sub_pi16(src2, dst2);/* src - dst -> src2 */
                src2 = _mm_mulhi_pi16(src2, mm_alpha); /* src2 * alpha -> src2 */
                src2 = _mm_slli_pi16(src2, 5); /* src2 << 5 -> src2 */
                dst2 = _mm_add_pi16(src2, dst2); /* src2 + dst2 -> dst2 */

            mm_res = _mm_or_si64(mm_res, dst2); /* RED | GREEN -> mm_res */
                mm_res = _mm_or_si64(mm_res, dst2); /* RED | GREEN -> mm_res */

            /* blue */
            src2 = src1; /* src -> src2 */
            src2 = _mm_and_si64(src2, bmask); /* src & MASKBLUE -> src2[000b 000b 000b 000b] */
                /* blue */
                src2 = src1; /* src -> src2 */
                src2 = _mm_and_si64(src2, bmask); /* src & MASKBLUE -> src2[000b 000b 000b 000b] */

            dst2 = dst1; /* dst -> dst2 */
            dst2 = _mm_and_si64(dst2, bmask); /* dst & MASKBLUE -> dst2[000b 000b 000b 000b] */
                dst2 = dst1; /* dst -> dst2 */
                dst2 = _mm_and_si64(dst2, bmask); /* dst & MASKBLUE -> dst2[000b 000b 000b 000b] */

            /* blend */
            src2 = _mm_sub_pi16(src2, dst2);/* src - dst -> src2 */
            src2 = _mm_mullo_pi16(src2, mm_alpha); /* src2 * alpha -> src2 */
            src2 = _mm_srli_pi16(src2, 11); /* src2 >> 11 -> src2 */
            dst2 = _mm_add_pi16(src2, dst2); /* src2 + dst2 -> dst2 */
            dst2 = _mm_and_si64(dst2, bmask); /* dst2 & MASKBLUE -> dst2 */
                /* blend */
                src2 = _mm_sub_pi16(src2, dst2);/* src - dst -> src2 */
                src2 = _mm_mullo_pi16(src2, mm_alpha); /* src2 * alpha -> src2 */
                src2 = _mm_srli_pi16(src2, 11); /* src2 >> 11 -> src2 */
                dst2 = _mm_add_pi16(src2, dst2); /* src2 + dst2 -> dst2 */
                dst2 = _mm_and_si64(dst2, bmask); /* dst2 & MASKBLUE -> dst2 */

            mm_res = _mm_or_si64(mm_res, dst2); /* RED | GREEN | BLUE -> mm_res */
                mm_res = _mm_or_si64(mm_res, dst2); /* RED | GREEN | BLUE -> mm_res */

            *(__m64*)dstp = mm_res; /* mm_res -> 4 dst pixels */
                *(__m64*)dstp = mm_res; /* mm_res -> 4 dst pixels */

            srcp += 4;
            dstp += 4;
         }, width);
         /* *INDENT-ON* */
                srcp += 4;
                dstp += 4;
            }, width);
            /* *INDENT-ON* */
            srcp += srcskip;
            dstp += dstskip;
        }
@@ -988,22 +988,22 @@
        alpha >>= 3;            /* downscale alpha to 5 bits */

        while (height--) {
         /* *INDENT-OFF* */
         DUFFS_LOOP4({
            Uint32 s = *srcp++;
            Uint32 d = *dstp;
            /*
             * shift out the middle component (green) to
             * the high 16 bits, and process all three RGB
             * components at the same time.
             */
            s = (s | s << 16) & 0x07e0f81f;
            d = (d | d << 16) & 0x07e0f81f;
            d += (s - d) * alpha >> 5;
            d &= 0x07e0f81f;
            *dstp++ = (Uint16)(d | d >> 16);
         }, width);
         /* *INDENT-ON* */
            /* *INDENT-OFF* */
            DUFFS_LOOP4({
                Uint32 s = *srcp++;
                Uint32 d = *dstp;
                /*
                 * shift out the middle component (green) to
                 * the high 16 bits, and process all three RGB
                 * components at the same time.
                 */
                s = (s | s << 16) & 0x07e0f81f;
                d = (d | d << 16) & 0x07e0f81f;
                d += (s - d) * alpha >> 5;
                d &= 0x07e0f81f;
                *dstp++ = (Uint16)(d | d >> 16);
            }, width);
            /* *INDENT-ON* */
            srcp += srcskip;
            dstp += dstskip;
        }
@@ -1027,22 +1027,22 @@
        alpha >>= 3;            /* downscale alpha to 5 bits */

        while (height--) {
         /* *INDENT-OFF* */
         DUFFS_LOOP4({
            Uint32 s = *srcp++;
            Uint32 d = *dstp;
            /*
             * shift out the middle component (green) to
             * the high 16 bits, and process all three RGB
             * components at the same time.
             */
            s = (s | s << 16) & 0x03e07c1f;
            d = (d | d << 16) & 0x03e07c1f;
            d += (s - d) * alpha >> 5;
            d &= 0x03e07c1f;
            *dstp++ = (Uint16)(d | d >> 16);
         }, width);
         /* *INDENT-ON* */
            /* *INDENT-OFF* */
            DUFFS_LOOP4({
                Uint32 s = *srcp++;
                Uint32 d = *dstp;
                /*
                 * shift out the middle component (green) to
                 * the high 16 bits, and process all three RGB
                 * components at the same time.
                 */
                s = (s | s << 16) & 0x03e07c1f;
                d = (d | d << 16) & 0x03e07c1f;
                d += (s - d) * alpha >> 5;
                d &= 0x03e07c1f;
                *dstp++ = (Uint16)(d | d >> 16);
            }, width);
            /* *INDENT-ON* */
            srcp += srcskip;
            dstp += dstskip;
        }
@@ -1061,35 +1061,35 @@
    int dstskip = info->dst_skip >> 1;

    while (height--) {
       /* *INDENT-OFF* */
       DUFFS_LOOP4({
      Uint32 s = *srcp;
      unsigned alpha = s >> 27; /* downscale alpha to 5 bits */
      /* FIXME: Here we special-case opaque alpha since the
         compositioning used (>>8 instead of /255) doesn't handle
         it correctly. Also special-case alpha=0 for speed?
         Benchmark this! */
      if(alpha) {   
        if(alpha == (SDL_ALPHA_OPAQUE >> 3)) {
          *dstp = (Uint16)((s >> 8 & 0xf800) + (s >> 5 & 0x7e0) + (s >> 3  & 0x1f));
        } else {
          Uint32 d = *dstp;
          /*
           * convert source and destination to G0RAB65565
           * and blend all components at the same time
           */
          s = ((s & 0xfc00) << 11) + (s >> 8 & 0xf800)
            + (s >> 3 & 0x1f);
          d = (d | d << 16) & 0x07e0f81f;
          d += (s - d) * alpha >> 5;
          d &= 0x07e0f81f;
          *dstp = (Uint16)(d | d >> 16);
        }
      }
      srcp++;
      dstp++;
       }, width);
       /* *INDENT-ON* */
        /* *INDENT-OFF* */
        DUFFS_LOOP4({
        Uint32 s = *srcp;
        unsigned alpha = s >> 27; /* downscale alpha to 5 bits */
        /* FIXME: Here we special-case opaque alpha since the
           compositioning used (>>8 instead of /255) doesn't handle
           it correctly. Also special-case alpha=0 for speed?
           Benchmark this! */
        if(alpha) {   
          if(alpha == (SDL_ALPHA_OPAQUE >> 3)) {
            *dstp = (Uint16)((s >> 8 & 0xf800) + (s >> 5 & 0x7e0) + (s >> 3  & 0x1f));
          } else {
            Uint32 d = *dstp;
            /*
             * convert source and destination to G0RAB65565
             * and blend all components at the same time
             */
            s = ((s & 0xfc00) << 11) + (s >> 8 & 0xf800)
              + (s >> 3 & 0x1f);
            d = (d | d << 16) & 0x07e0f81f;
            d += (s - d) * alpha >> 5;
            d &= 0x07e0f81f;
            *dstp = (Uint16)(d | d >> 16);
          }
        }
        srcp++;
        dstp++;
        }, width);
        /* *INDENT-ON* */
        srcp += srcskip;
        dstp += dstskip;
    }
@@ -1107,36 +1107,36 @@
    int dstskip = info->dst_skip >> 1;

    while (height--) {
       /* *INDENT-OFF* */
       DUFFS_LOOP4({
      unsigned alpha;
      Uint32 s = *srcp;
      alpha = s >> 27; /* downscale alpha to 5 bits */
      /* FIXME: Here we special-case opaque alpha since the
         compositioning used (>>8 instead of /255) doesn't handle
         it correctly. Also special-case alpha=0 for speed?
         Benchmark this! */
      if(alpha) {   
        if(alpha == (SDL_ALPHA_OPAQUE >> 3)) {
          *dstp = (Uint16)((s >> 9 & 0x7c00) + (s >> 6 & 0x3e0) + (s >> 3  & 0x1f));
        } else {
          Uint32 d = *dstp;
          /*
           * convert source and destination to G0RAB65565
           * and blend all components at the same time
           */
          s = ((s & 0xf800) << 10) + (s >> 9 & 0x7c00)
            + (s >> 3 & 0x1f);
          d = (d | d << 16) & 0x03e07c1f;
          d += (s - d) * alpha >> 5;
          d &= 0x03e07c1f;
          *dstp = (Uint16)(d | d >> 16);
        }
      }
      srcp++;
      dstp++;
       }, width);
       /* *INDENT-ON* */
        /* *INDENT-OFF* */
        DUFFS_LOOP4({
        unsigned alpha;
        Uint32 s = *srcp;
        alpha = s >> 27; /* downscale alpha to 5 bits */
        /* FIXME: Here we special-case opaque alpha since the
           compositioning used (>>8 instead of /255) doesn't handle
           it correctly. Also special-case alpha=0 for speed?
           Benchmark this! */
        if(alpha) {   
          if(alpha == (SDL_ALPHA_OPAQUE >> 3)) {
            *dstp = (Uint16)((s >> 9 & 0x7c00) + (s >> 6 & 0x3e0) + (s >> 3  & 0x1f));
          } else {
            Uint32 d = *dstp;
            /*
             * convert source and destination to G0RAB65565
             * and blend all components at the same time
             */
            s = ((s & 0xf800) << 10) + (s >> 9 & 0x7c00)
              + (s >> 3 & 0x1f);
            d = (d | d << 16) & 0x03e07c1f;
            d += (s - d) * alpha >> 5;
            d &= 0x03e07c1f;
            *dstp = (Uint16)(d | d >> 16);
          }
        }
        srcp++;
        dstp++;
        }, width);
        /* *INDENT-ON* */
        srcp += srcskip;
        dstp += dstskip;
    }
@@ -1163,18 +1163,18 @@

    if (sA) {
        while (height--) {
       /* *INDENT-OFF* */
       DUFFS_LOOP4(
       {
      DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel, sR, sG, sB);
      DISEMBLE_RGBA(dst, dstbpp, dstfmt, Pixel, dR, dG, dB, dA);
      ALPHA_BLEND_RGBA(sR, sG, sB, sA, dR, dG, dB, dA);
      ASSEMBLE_RGBA(dst, dstbpp, dstfmt, dR, dG, dB, dA);
      src += srcbpp;
      dst += dstbpp;
       },
       width);
       /* *INDENT-ON* */
        /* *INDENT-OFF* */
        DUFFS_LOOP4(
        {
        DISEMBLE_RGB(src, srcbpp, srcfmt, Pixel, sR, sG, sB);
        DISEMBLE_RGBA(dst, dstbpp, dstfmt, Pixel, dR, dG, dB, dA);
        ALPHA_BLEND_RGBA(sR, sG, sB, sA, dR, dG, dB, dA);
        ASSEMBLE_RGBA(dst, dstbpp, dstfmt, dR, dG, dB, dA);
        src += srcbpp;
        dst += dstbpp;
        },
        width);
        /* *INDENT-ON* */
            src += srcskip;
            dst += dstskip;
        }
@@ -1202,21 +1202,21 @@
    const unsigned sA = info->a;

    while (height--) {
       /* *INDENT-OFF* */
       DUFFS_LOOP4(
       {
      RETRIEVE_RGB_PIXEL(src, srcbpp, Pixel);
      if(sA && Pixel != ckey) {
          RGB_FROM_PIXEL(Pixel, srcfmt, sR, sG, sB);
          DISEMBLE_RGBA(dst, dstbpp, dstfmt, Pixel, dR, dG, dB, dA);
          ALPHA_BLEND_RGBA(sR, sG, sB, sA, dR, dG, dB, dA);
          ASSEMBLE_RGBA(dst, dstbpp, dstfmt, dR, dG, dB, dA);
      }
      src += srcbpp;
      dst += dstbpp;
       },
       width);
       /* *INDENT-ON* */
        /* *INDENT-OFF* */
        DUFFS_LOOP4(
        {
        RETRIEVE_RGB_PIXEL(src, srcbpp, Pixel);
        if(sA && Pixel != ckey) {
            RGB_FROM_PIXEL(Pixel, srcfmt, sR, sG, sB);
            DISEMBLE_RGBA(dst, dstbpp, dstfmt, Pixel, dR, dG, dB, dA);
            ALPHA_BLEND_RGBA(sR, sG, sB, sA, dR, dG, dB, dA);
            ASSEMBLE_RGBA(dst, dstbpp, dstfmt, dR, dG, dB, dA);
        }
        src += srcbpp;
        dst += dstbpp;
        },
        width);
        /* *INDENT-ON* */
        src += srcskip;
        dst += dstskip;
    }
@@ -1245,20 +1245,20 @@
    dstbpp = dstfmt->BytesPerPixel;

    while (height--) {
       /* *INDENT-OFF* */
       DUFFS_LOOP4(
       {
      DISEMBLE_RGBA(src, srcbpp, srcfmt, Pixel, sR, sG, sB, sA);
      if(sA) {
          DISEMBLE_RGBA(dst, dstbpp, dstfmt, Pixel, dR, dG, dB, dA);
          ALPHA_BLEND_RGBA(sR, sG, sB, sA, dR, dG, dB, dA);
          ASSEMBLE_RGBA(dst, dstbpp, dstfmt, dR, dG, dB, dA);
      }
      src += srcbpp;
      dst += dstbpp;
       },
       width);
       /* *INDENT-ON* */
        /* *INDENT-OFF* */
        DUFFS_LOOP4(
        {
        DISEMBLE_RGBA(src, srcbpp, srcfmt, Pixel, sR, sG, sB, sA);
        if(sA) {
            DISEMBLE_RGBA(dst, dstbpp, dstfmt, Pixel, dR, dG, dB, dA);
            ALPHA_BLEND_RGBA(sR, sG, sB, sA, dR, dG, dB, dA);
            ASSEMBLE_RGBA(dst, dstbpp, dstfmt, dR, dG, dB, dA);
        }
        src += srcbpp;
        dst += dstbpp;
        },
        width);
        /* *INDENT-ON* */
        src += srcskip;
        dst += dstskip;
    }