respect srgb gamma when building mips

src/core/SkMipMap.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkMipMap.h"
 #include "SkBitmap.h"
 #include "SkColorPriv.h"
 #include "SkHalf.h"
 #include "SkMath.h"
 #include "SkNx.h"
+#include "SkPM4fPriv.h"
 #include "SkTypes.h"
 
 //
 // ColorTypeFilter is the "Type" we pass to some downsample template functions.
 // It controls how we expand a pixel into a large type, with space between each component,
 // so we can then perform our simple filter (either box or triangle) and store the intermediates
 // in the expanded type.
 //
 
 struct ColorTypeFilter_8888 {
@@ skipping 10 matching lines @@
 #else
     static uint64_t Expand(uint32_t x) {
         return (x & 0xFF00FF) | ((uint64_t)(x & 0xFF00FF00) << 24);
     }
     static uint32_t Compact(uint64_t x) {
         return (uint32_t)((x & 0xFF00FF) | ((x >> 24) & 0xFF00FF00));
     }
 #endif
 };
 
+struct ColorTypeFilter_S32 {
+    typedef uint32_t Type;
+    static Sk4f Expand(uint32_t x) {
+        // does not bother to normalize to 1.0, so result range is 0 ... 255*255
+        return srgb_to_linear(to_4f(x));
+    }
+    static uint32_t Compact(const Sk4f& x) {
+        return to_4b(linear_to_srgb(x));
+    }
+};
+
 struct ColorTypeFilter_565 {
     typedef uint16_t Type;
     static uint32_t Expand(uint16_t x) {
         return (x & ~SK_G16_MASK_IN_PLACE) | ((x & SK_G16_MASK_IN_PLACE) << 16);
     }
     static uint16_t Compact(uint32_t x) {
         return (x & ~SK_G16_MASK_IN_PLACE) | ((x >> 16) & SK_G16_MASK_IN_PLACE);
     }
 };
 
@@ skipping 232 matching lines @@
     if (levelCount < 0) {
         return 0;
     }
     int64_t size = sk_64_mul(levelCount + 1, sizeof(Level)) + pixelSize;
     if (!sk_64_isS32(size)) {
         return 0;
     }
     return sk_64_asS32(size);
 }
 
-SkMipMap* SkMipMap::Build(const SkPixmap& src, SkDiscardableFactoryProc fact) {
+static bool treat_like_srgb(const SkImageInfo& info) {
+    if (info.colorSpace()) {
+        return SkColorSpace::k2Dot2Curve_GammaNamed == info.colorSpace()->gammaNamed();
+    } else {
+        return kSRGB_SkColorProfileType == info.profileType();
+    }
+}
+
+SkMipMap* SkMipMap::Build(const SkPixmap& src, SrcGammaMode mode, SkDiscardableFactoryProc fact) {
     typedef void FilterProc(void*, const void* srcPtr, size_t srcRB, int count);
 
     FilterProc* proc_1_2 = nullptr;
     FilterProc* proc_1_3 = nullptr;
     FilterProc* proc_2_1 = nullptr;
     FilterProc* proc_2_2 = nullptr;
     FilterProc* proc_2_3 = nullptr;
     FilterProc* proc_3_1 = nullptr;
     FilterProc* proc_3_2 = nullptr;
     FilterProc* proc_3_3 = nullptr;
 
     const SkColorType ct = src.colorType();
     const SkAlphaType at = src.alphaType();
+    const bool srgbGamma = (kRespect_SrcGammaMode == mode) && treat_like_srgb(src.info());
+
     switch (ct) {
         case kRGBA_8888_SkColorType:
         case kBGRA_8888_SkColorType:
-            proc_1_2 = downsample_1_2<ColorTypeFilter_8888>;
-            proc_1_3 = downsample_1_3<ColorTypeFilter_8888>;
-            proc_2_1 = downsample_2_1<ColorTypeFilter_8888>;
-            proc_2_2 = downsample_2_2<ColorTypeFilter_8888>;
-            proc_2_3 = downsample_2_3<ColorTypeFilter_8888>;
-            proc_3_1 = downsample_3_1<ColorTypeFilter_8888>;
-            proc_3_2 = downsample_3_2<ColorTypeFilter_8888>;
-            proc_3_3 = downsample_3_3<ColorTypeFilter_8888>;
+            if (srgbGamma) {
+                proc_1_2 = downsample_1_2<ColorTypeFilter_S32>;
+                proc_1_3 = downsample_1_3<ColorTypeFilter_S32>;
+                proc_2_1 = downsample_2_1<ColorTypeFilter_S32>;
+                proc_2_2 = downsample_2_2<ColorTypeFilter_S32>;
+                proc_2_3 = downsample_2_3<ColorTypeFilter_S32>;
+                proc_3_1 = downsample_3_1<ColorTypeFilter_S32>;
+                proc_3_2 = downsample_3_2<ColorTypeFilter_S32>;
+                proc_3_3 = downsample_3_3<ColorTypeFilter_S32>;
+            } else {
+                proc_1_2 = downsample_1_2<ColorTypeFilter_8888>;
+                proc_1_3 = downsample_1_3<ColorTypeFilter_8888>;
+                proc_2_1 = downsample_2_1<ColorTypeFilter_8888>;
+                proc_2_2 = downsample_2_2<ColorTypeFilter_8888>;
+                proc_2_3 = downsample_2_3<ColorTypeFilter_8888>;
+                proc_3_1 = downsample_3_1<ColorTypeFilter_8888>;
+                proc_3_2 = downsample_3_2<ColorTypeFilter_8888>;
+                proc_3_3 = downsample_3_3<ColorTypeFilter_8888>;
+            }
             break;
         case kRGB_565_SkColorType:
             proc_1_2 = downsample_1_2<ColorTypeFilter_565>;
             proc_1_3 = downsample_1_3<ColorTypeFilter_565>;
             proc_2_1 = downsample_2_1<ColorTypeFilter_565>;
             proc_2_2 = downsample_2_2<ColorTypeFilter_565>;
             proc_2_3 = downsample_2_3<ColorTypeFilter_565>;
             proc_3_1 = downsample_3_1<ColorTypeFilter_565>;
             proc_3_2 = downsample_3_2<ColorTypeFilter_565>;
             proc_3_3 = downsample_3_3<ColorTypeFilter_565>;
@@ skipping 56 matching lines @@
         SkDiscardableMemory* dm = fact(storageSize);
         if (nullptr == dm) {
             return nullptr;
         }
         mipmap = new SkMipMap(storageSize, dm);
     } else {
         mipmap = new SkMipMap(sk_malloc_throw(storageSize), storageSize);
     }
 
     // init
+    mipmap->fCS = sk_ref_sp(src.info().colorSpace());
     mipmap->fCount = countLevels;
     mipmap->fLevels = (Level*)mipmap->writable_data();
+    SkASSERT(mipmap->fLevels);
 
     Level* levels = mipmap->fLevels;
     uint8_t*    baseAddr = (uint8_t*)&levels[countLevels];
     uint8_t*    addr = baseAddr;
     int         width = src.width();
     int         height = src.height();
     uint32_t    rowBytes;
     SkPixmap    srcPM(src);
 
     for (int i = 0; i < countLevels; ++i) {
@@ skipping 24 matching lines @@
                     proc = proc_3_2;
                 }
             } else {                  // src-width is 2
                 proc = proc_2_2;
             }
         }
         width = SkTMax(1, width >> 1);
         height = SkTMax(1, height >> 1);
         rowBytes = SkToU32(SkColorTypeMinRowBytes(ct, width));
 
+        // We make the Info w/o any colorspace, since that storage is not under our control, and
+        // will not be deleted in a controlled fashion. When the caller is given the pixmap for
+        // a given level, we augment this pixmap with fCS (which we do managed).

[msarett, 2016/06/03 16:54:17]

nit: *manage

[reed1, 2016/06/07 16:01:10]

Done.

         new (&levels[i].fPixmap) SkPixmap(SkImageInfo::Make(width, height, ct, at), addr, rowBytes);
         levels[i].fScale  = SkSize::Make(SkIntToScalar(width)  / src.width(),
                                          SkIntToScalar(height) / src.height());
 
         const SkPixmap& dstPM = levels[i].fPixmap;
         const void* srcBasePtr = srcPM.addr();
         void* dstBasePtr = dstPM.writable_addr();
 
         const size_t srcRB = srcPM.rowBytes();
         for (int y = 0; y < height; y++) {
             proc(dstBasePtr, srcBasePtr, srcRB, width);
             srcBasePtr = (char*)srcBasePtr + srcRB * 2; // jump two rows
             dstBasePtr = (char*)dstBasePtr + dstPM.rowBytes();
         }
         srcPM = dstPM;
         addr += height * rowBytes;
     }
     SkASSERT(addr == baseAddr + size);
 
+    SkASSERT(mipmap->fLevels);
     return mipmap;
 }
 
 int SkMipMap::ComputeLevelCount(int baseWidth, int baseHeight) {
     if (baseWidth < 1 || baseHeight < 1) {
         return 0;
     }
 
     // OpenGL's spec requires that each mipmap level have height/width equal to
     // max(1, floor(original_height / 2^i)
@@ skipping 68 matching lines @@
 
     if (scale >= SK_Scalar1 || scale <= 0 || !SkScalarIsFinite(scale)) {
         return false;
     }
 
     SkScalar L = -SkScalarLog2(scale);
     if (!SkScalarIsFinite(L)) {
         return false;
     }
     SkASSERT(L >= 0);
-//    int rndLevel = SkScalarRoundToInt(L);
     int level = SkScalarFloorToInt(L);
-//    SkDebugf("mipmap scale=%g L=%g level=%d rndLevel=%d\n", scale, L, level, rndLevel);
 
     SkASSERT(level >= 0);
     if (level <= 0) {
         return false;
     }
 
     if (level > fCount) {
         level = fCount;
     }
     if (levelPtr) {
         *levelPtr = fLevels[level - 1];
+        // need to augment with our colorspace
+        levelPtr->fPixmap.setColorSpace(fCS);
     }
     return true;
 }
 
 // Helper which extracts a pixmap from the src bitmap
 //
-SkMipMap* SkMipMap::Build(const SkBitmap& src, SkDiscardableFactoryProc fact) {
+SkMipMap* SkMipMap::Build(const SkBitmap& src, SrcGammaMode mode, SkDiscardableFactoryProc fact) {
     SkAutoPixmapUnlock srcUnlocker;
     if (!src.requestLock(&srcUnlocker)) {
         return nullptr;
     }
     const SkPixmap& srcPixmap = srcUnlocker.pixmap();
     // Try to catch where we might have returned nullptr for src crbug.com/492818
     if (nullptr == srcPixmap.addr()) {
         sk_throw();
     }
-    return Build(srcPixmap, fact);
+    return Build(srcPixmap, mode, fact);
 }
 
 int SkMipMap::countLevels() const {
     return fCount;
 }
 
 bool SkMipMap::getLevel(int index, Level* levelPtr) const {
     if (NULL == fLevels) {
         return false;
     }
     if (index < 0) {
         return false;
     }
     if (index > fCount - 1) {
         return false;
     }
     if (levelPtr) {
         *levelPtr = fLevels[index];
     }
     return true;
 }