Revert of remove colorfilter native-565 support. complicating w/ no real value.

src/effects/SkColorMatrixFilter.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkColorMatrixFilter.h"
 #include "SkColorMatrix.h"
 #include "SkColorPriv.h"
@@ skipping 119 matching lines @@
                   unsigned r, unsigned g, unsigned b, unsigned a,
                   int32_t* SK_RESTRICT result) {
     const int32_t* SK_RESTRICT array = state.fArray;
 
     result[0] = r + (array[SkColorMatrix::kR_Trans] >> 16);
     result[1] = g + (array[SkColorMatrix::kG_Trans] >> 16);
     result[2] = b + (array[SkColorMatrix::kB_Trans] >> 16);
     result[3] = a;
 }
 
+#define kNO_ALPHA_FLAGS (SkColorFilter::kAlphaUnchanged_Flag |  \
+                         SkColorFilter::kHasFilter16_Flag)
+
 // src is [20] but some compilers won't accept __restrict__ on anything
 // but an raw pointer or reference
 void SkColorMatrixFilter::initState(const SkScalar* SK_RESTRICT src) {
     transpose_to_pmorder(fTranspose, src);
 
     int32_t* array = fState.fArray;
     SkFixed max = 0;
     for (int i = 0; i < 20; i++) {
         SkFixed value = SkScalarToFixed(src[i]);
         array[i] = value;
@@ skipping 21 matching lines @@
     // check if we have to munge Alpha
     int32_t changesAlpha = (array[15] | array[16] | array[17] |
                             (array[18] - one) | array[19]);
     int32_t usesAlpha = (array[3] | array[8] | array[13]);
     bool shiftIs16 = (16 == fState.fShift);
 
     if (changesAlpha | usesAlpha) {
         fProc = shiftIs16 ? General16 : General;
         fFlags = changesAlpha ? 0 : SkColorFilter::kAlphaUnchanged_Flag;
     } else {
-        fFlags = SkColorFilter::kAlphaUnchanged_Flag;
+        fFlags = kNO_ALPHA_FLAGS;
 
         int32_t needsScale = (array[SkColorMatrix::kR_Scale] - one) |
                              (array[SkColorMatrix::kG_Scale] - one) |
                              (array[SkColorMatrix::kB_Scale] - one);
 
         int32_t needs3x3 =  array[1] | array[2] |     // red off-axis
                             array[5] | array[7] |     // green off-axis
                             array[10] | array[11];    // blue off-axis
 
         if (needs3x3) {
@@ skipping 161 matching lines @@
             r = pin(result[0], SK_R32_MASK);
             g = pin(result[1], SK_G32_MASK);
             b = pin(result[2], SK_B32_MASK);
             a = pin(result[3], SK_A32_MASK);
             // re-prepremultiply if needed
             dst[i] = SkPremultiplyARGBInline(a, r, g, b);
         }
     }
 }
 
+void SkColorMatrixFilter::filterSpan16(const uint16_t src[], int count,
+                                       uint16_t dst[]) const {
+    SkASSERT(fFlags & SkColorFilter::kHasFilter16_Flag);
+
+    Proc   proc = fProc;
+    const State& state = fState;
+    int32_t result[4];
+
+    if (NULL == proc) {
+        if (src != dst) {
+            memcpy(dst, src, count * sizeof(uint16_t));
+        }
+        return;
+    }
+
+    for (int i = 0; i < count; i++) {
+        uint16_t c = src[i];
+
+        // expand to 8bit components (since our matrix translate is 8bit biased
+        unsigned r = SkPacked16ToR32(c);
+        unsigned g = SkPacked16ToG32(c);
+        unsigned b = SkPacked16ToB32(c);
+
+        proc(state, r, g, b, 0, result);
+
+        r = pin(result[0], SK_R32_MASK);
+        g = pin(result[1], SK_G32_MASK);
+        b = pin(result[2], SK_B32_MASK);
+
+        // now packed it back down to 16bits (hmmm, could dither...)
+        dst[i] = SkPack888ToRGB16(r, g, b);
+    }
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 
 void SkColorMatrixFilter::flatten(SkWriteBuffer& buffer) const {
     SkASSERT(sizeof(fMatrix.fMat)/sizeof(SkScalar) == 20);
     buffer.writeScalarArray(fMatrix.fMat, 20);
 }
 
 SkFlattenable* SkColorMatrixFilter::CreateProc(SkReadBuffer& buffer) {
     SkColorMatrix matrix;
     if (buffer.readScalarArray(matrix.fMat, 20)) {
@@ skipping 202 matching lines @@
     str->append("matrix: (");
     for (int i = 0; i < 20; ++i) {
         str->appendScalar(fMatrix.fMat[i]);
         if (i < 19) {
             str->append(", ");
         }
     }
     str->append(")");
 }
 #endif