Optimize CMYK->RGBA (BGRA) transform for jpeg decodes

src/opts/SkSwizzler_opts.h

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkSwizzler_opts_DEFINED
 #define SkSwizzler_opts_DEFINED
 
@@ skipping 107 matching lines @@
                 a = src[1];
         src += 2;
         g = (g*a+127)/255;
         dst[i] = (uint32_t)a << 24
                | (uint32_t)g << 16
                | (uint32_t)g <<  8
                | (uint32_t)g <<  0;
     }
 }
 
+static void inverted_CMYK_to_RGB1_portable(uint32_t* dst, const void* vsrc, int count) {
+    const uint32_t* src = (const uint32_t*)vsrc;
+    for (int i = 0; i < count; i++) {
+        uint8_t k = src[i] >> 24,
+                y = src[i] >> 16,
+                m = src[i] >>  8,
+                c = src[i] >>  0;
+        // See comments in SkSwizzler.cpp for details on the conversion formula.
+        uint8_t b = (y*k+127)/255,
+                g = (m*k+127)/255,
+                r = (c*k+127)/255;
+        dst[i] = (uint32_t)0xFF << 24
+               | (uint32_t)   b << 16
+               | (uint32_t)   g <<  8
+               | (uint32_t)   r <<  0;
+    }
+}
+
+static void inverted_CMYK_to_BGR1_portable(uint32_t* dst, const void* vsrc, int count) {
+    const uint32_t* src = (const uint32_t*)vsrc;
+    for (int i = 0; i < count; i++) {
+        uint8_t k = src[i] >> 24,
+                y = src[i] >> 16,
+                m = src[i] >>  8,
+                c = src[i] >>  0;
+        uint8_t b = (y*k+127)/255,
+                g = (m*k+127)/255,
+                r = (c*k+127)/255;
+        dst[i] = (uint32_t)0xFF << 24
+               | (uint32_t)   r << 16
+               | (uint32_t)   g <<  8
+               | (uint32_t)   b <<  0;
+    }
+}
+
 #if defined(SK_ARM_HAS_NEON)
 
 // Rounded divide by 255, (x + 127) / 255
 static uint8x8_t div255_round(uint16x8_t x) {
     // result = (x + 127) / 255
     // result = (x + 127) / 256 + error1
     //
     // error1 = (x + 127) / (255 * 256)
     // error1 = (x + 127) / (256 * 256) + error2
     //
@@ skipping 256 matching lines @@
 }
 
 static void grayA_to_RGBA(uint32_t dst[], const void* src, int count) {
     expand_grayA<false>(dst, src, count);
 }
 
 static void grayA_to_rgbA(uint32_t dst[], const void* src, int count) {
     expand_grayA<true>(dst, src, count);
 }
 
+template <bool kSwapRB>

[mtklein, 2016/02/08 17:31:26]

Let's do some renaming to get "swap" out of these names?  It's sort of weird to
say swap when there's no starting red and blue values.  E.g.

enum Format { kRGB1, kBGR1 };

template <Format format>
static void inverted_cmyk_to(...) {


}
(Called as inverted_cmyk_to_<kRGB1>, inverted_cmyk_to<kBGR1>)

[msarett, 2016/02/08 18:09:47]

Done.

+static void cmyk_should_swapRB(uint32_t* dst, const void* vsrc, int count) {
+    auto src = (const uint32_t*)vsrc;
+    while (count >= 8) {
+        // Load 8 cmyk pixels.
+        uint8x8x4_t pixels = vld4_u8((const uint8_t*) src);
+
+        uint8x8_t k = pixels.val[3],
+                  y = pixels.val[2],
+                  m = pixels.val[1],
+                  c = pixels.val[0];
+
+        // Scale to r, g, b.
+        uint8x8_t b = scale(y, k);
+        uint8x8_t g = scale(m, k);
+        uint8x8_t r = scale(c, k);
+
+        // Store 8 rgba pixels.
+        if (kSwapRB) {
+            pixels.val[3] = vdup_n_u8(0xFF);
+            pixels.val[2] = r;
+            pixels.val[1] = g;
+            pixels.val[0] = b;
+        } else {
+            pixels.val[3] = vdup_n_u8(0xFF);
+            pixels.val[2] = b;
+            pixels.val[1] = g;
+            pixels.val[0] = r;
+        }
+        vst4_u8((uint8_t*) dst, pixels);
+        src += 8;
+        dst += 8;
+        count -= 8;
+    }
+
+    auto proc = kSwapRB ? inverted_CMYK_to_BGR1_portable : inverted_CMYK_to_RGB1_portable;
+    proc(dst, src, count);
+}
+
+static void inverted_CMYK_to_RGB1(uint32_t dst[], const void* src, int count) {
+    cmyk_should_swapRB<false>(dst, src, count);
+}
+
+static void inverted_CMYK_to_BGR1(uint32_t dst[], const void* src, int count) {
+    cmyk_should_swapRB<true>(dst, src, count);
+}
+
 #elif SK_CPU_SSE_LEVEL >= SK_CPU_SSE_LEVEL_SSSE3
 
 // Scale a byte by another.
 // Inputs are stored in 16-bit lanes, but are not larger than 8-bits.
 static __m128i scale(__m128i x, __m128i y) {
     const __m128i _128 = _mm_set1_epi16(128);
     const __m128i _257 = _mm_set1_epi16(257);
 
     // (x+127)/255 == ((x+128)*257)>>16 for 0 <= x <= 255*255.
     return _mm_mulhi_epu16(_mm_add_epi16(_mm_mullo_epi16(x, y), _128), _257);
@@ skipping 210 matching lines @@
         _mm_storeu_si128((__m128i*) (dst +  4), ggga_hi);
 
         src += 8*2;
         dst += 8;
         count -= 8;
     }
 
     grayA_to_rgbA_portable(dst, src, count);
 }
 
+template <bool kSwapRB>
+static void cmyk_should_swapRB(uint32_t* dst, const void* vsrc, int count) {
+    auto src = (const uint32_t*)vsrc;
+
+    auto convert8 = [](__m128i* lo, __m128i* hi) {
+        const __m128i zeros = _mm_setzero_si128();
+        __m128i planar;
+        if (kSwapRB) {
+            planar = _mm_setr_epi8(2,6,10,14, 1,5,9,13, 0,4,8,12, 3,7,11,15);
+        } else {
+            planar = _mm_setr_epi8(0,4,8,12, 1,5,9,13, 2,6,10,14, 3,7,11,15);
+        }
+
+        // Swizzle the pixels to 8-bit planar.
+        *lo = _mm_shuffle_epi8(*lo, planar);                      // ccccmmmm yyyykkkk
+        *hi = _mm_shuffle_epi8(*hi, planar);                      // CCCCMMMM YYYYKKKK
+        __m128i cm = _mm_unpacklo_epi32(*lo, *hi),                // ccccCCCC mmmmMMMM
+                yk = _mm_unpackhi_epi32(*lo, *hi);                // yyyyYYYY kkkkKKKK
+
+        // Unpack to 16-bit planar.
+        __m128i c = _mm_unpacklo_epi8(cm, zeros),                 // c_c_c_c_ C_C_C_C_
+                m = _mm_unpackhi_epi8(cm, zeros),                 // m_m_m_m_ M_M_M_M_
+                y = _mm_unpacklo_epi8(yk, zeros),                 // y_y_y_y_ Y_Y_Y_Y_
+                k = _mm_unpackhi_epi8(yk, zeros);                 // k_k_k_k_ K_K_K_K_
+
+        // Scale to r, g, b.
+        __m128i r = scale(c, k),
+                g = scale(m, k),
+                b = scale(y, k);
+
+        // Repack into interlaced pixels.
+        __m128i rg = _mm_or_si128(r, _mm_slli_epi16(g, 8)),       // rgrgrgrg RGRGRGRG
+                ba = _mm_or_si128(b, _mm_set1_epi16(0xFF00));     // b1b1b1b1 B1B1B1B1
+        *lo = _mm_unpacklo_epi16(rg, ba);                         // rgbargba rgbargba
+        *hi = _mm_unpackhi_epi16(rg, ba);                         // RGB1RGB1 RGB1RGB1
+    };
+
+    while (count >= 8) {
+        __m128i lo = _mm_loadu_si128((const __m128i*) (src + 0)),
+                hi = _mm_loadu_si128((const __m128i*) (src + 4));
+
+        convert8(&lo, &hi);
+
+        _mm_storeu_si128((__m128i*) (dst + 0), lo);
+        _mm_storeu_si128((__m128i*) (dst + 4), hi);
+
+        src += 8;
+        dst += 8;
+        count -= 8;
+    }
+
+    if (count >= 4) {
+        __m128i lo = _mm_loadu_si128((const __m128i*) src),
+                hi = _mm_setzero_si128();
+
+        convert8(&lo, &hi);
+
+        _mm_storeu_si128((__m128i*) dst, lo);
+
+        src += 4;
+        dst += 4;
+        count -= 4;
+    }
+
+    auto proc = kSwapRB ? inverted_CMYK_to_BGR1_portable : inverted_CMYK_to_RGB1_portable;
+    proc(dst, src, count);
+}
+
+static void inverted_CMYK_to_RGB1(uint32_t dst[], const void* src, int count) {
+    cmyk_should_swapRB<false>(dst, src, count);
+}
+
+static void inverted_CMYK_to_BGR1(uint32_t dst[], const void* src, int count) {
+    cmyk_should_swapRB<true>(dst, src, count);
+}
+
 #else
 
 static void RGBA_to_rgbA(uint32_t* dst, const void* src, int count) {
     RGBA_to_rgbA_portable(dst, src, count);
 }
 
 static void RGBA_to_bgrA(uint32_t* dst, const void* src, int count) {
     RGBA_to_bgrA_portable(dst, src, count);
 }
 
@@ skipping 14 matching lines @@
 }
 
 static void grayA_to_RGBA(uint32_t dst[], const void* src, int count) {
     grayA_to_RGBA_portable(dst, src, count);
 }
 
 static void grayA_to_rgbA(uint32_t dst[], const void* src, int count) {
     grayA_to_rgbA_portable(dst, src, count);
 }
 
+static void inverted_CMYK_to_RGB1(uint32_t dst[], const void* src, int count) {
+    inverted_CMYK_to_RGB1_portable(dst, src, count);
+}
+
+static void inverted_CMYK_to_BGR1(uint32_t dst[], const void* src, int count) {
+    inverted_CMYK_to_BGR1_portable(dst, src, count);
+}
+
 #endif
 
 }
 
 #endif // SkSwizzler_opts_DEFINED