Adding direct access to SkMipMap levels.

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 "SkMath.h"
 #include "SkNx.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 {
     typedef uint32_t Type;
@@ skipping 343 matching lines @@
         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);
 }
 
+int SkMipMap::ComputeLevelCount(int baseWidth, int baseHeight) {

[reed1, 2016/01/28 02:06:03]

Its a little odd that the Build code doesn't call or share code with
ComputeLevelCount. Perhaps they could somehow share code to help ensure they
don't get out-of-sync. Or at least, we could assert that the count computed in
Build is the same as calling this new method..  perhaps after line 249?

[cblume, 2016/02/01 09:31:07]

I agree.
But when I was writing this I realized they have different goals.
One wants to find the dimensions of a given level, generating levels as it goes.
The other wants to know how many levels it would generate in total.
So it sort of makes sense that they wouldn't share much code.

I added a few tests to make sure their results are the same. You can see it at
https://codereview.chromium.org/1639693002/diff/60001/tests/MipMapTest.cpp#ne...
on line 205.

I also added (in the next patch set) an assert inside Build, since it maintains
countLevels as it generates them. Once the count is complete I assert that they
match.

+    // OpenGL's spec requires that each mipmap level have height/width equal to
+    // max(1, floor(original_height / 2^i)
+    // (or original_width) where i is the mipmap level.
+    // Continue scaling down until both axes are size 1.
+    //
+    // This means when it maintains isotropic space (both axes scaling down
+    // at the same rate) until one axis hits size 1.
+    // At that point, OpenGL continues to scale down into anisotropic space
+    // (where the scales are not the same between axes).
+    //
+    // Skia currently does not go into anisotropic space.
+    // Once an axis hits size 1 we stop.
+    // All this means is rather than use the largest axis we will use the
+    // smallest axis.
+
+    const int smallestAxis = SkTMin(baseWidth, baseHeight);
+    if (smallestAxis < 2) {
+       // SkMipMap::Build requires a minimum size of 2.
+        return 0;
+    }
+    const int leadingZeros = SkCLZ(static_cast<uint32_t>(smallestAxis));
+    // If the value 00011010 has 3 leading 0s then it has 5 significant bits
+    // (the bits which are not leading zeros)
+    const int significantBits = (sizeof(uint32_t) * 8) - leadingZeros;
+    // This is making the assumption that the size of a byte is 8 bits
+    // and that sizeof(uint32_t)'s implementation-defined behavior is 4.
+    const int mipLevelCount = significantBits;
+
+    return mipLevelCount;
+}
+
+int SkMipMap::countLevels() const {
+    return fCount;
+}
+
+void SkMipMap::getLevel(int index, Level* levelPtr) const {
+    if (NULL == fLevels) {
+        return;
+    }
+    if (index < 0) {
+        return;
+    }
+    if (index > fCount - 1) {
+        return;
+    }
+    if (levelPtr) {
+        *levelPtr = fLevels[index];
+    }
+}