add SkPixmap and external locking to bitmaps

include/core/SkImageInfo.h

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkImageInfo_DEFINED
 #define SkImageInfo_DEFINED
 
@@ skipping 93 matching lines @@
 }
 
 static inline size_t SkColorTypeMinRowBytes(SkColorType ct, int width) {
     return width * SkColorTypeBytesPerPixel(ct);
 }
 
 static inline bool SkColorTypeIsValid(unsigned value) {
     return value <= kLastEnum_SkColorType;
 }
 
+static inline size_t SkColorTypeComputeOffset(SkColorType ct, int x, int y, size_t rowBytes) {
+    int shift = 0;
+    switch (SkColorTypeBytesPerPixel(ct)) {
+        case 4: shift = 2; break;
+        case 2: shift = 1; break;
+        case 1: shift = 0; break;
+        default: return 0;

[scroggo, 2015/05/19 20:11:42]

Should this SkASSERT(false)?

[reed1, 2015/05/21 20:02:00]

kUnknown_SkColorType correctly should return 0

[scroggo, 2015/05/21 20:20:55]

Right, but it seems like that is correct but not interesting. If someone called
this with kUnknown_SkColorType, aren't they going to run into trouble later, if
they were going to do anything with the information? 

[reed1, 2015/05/21 21:19:02]

This is calling SkColorTypeBytesPerPixels, which already behaves this same-way :
it returns a 0 for these configs. If we want to make this sort of logical
change, I'd like to make it across the board (in this and the other method) to
keep them mutually consistent. If we choose to do that, I'd prefer to do it in a
separate CL.

+    }
+    return y * rowBytes + (x << shift);
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 
 /**
  *  Return true if alphaType is supported by colorType. If there is a canonical
  *  alphaType for this colorType, return it in canonical.
  */
 bool SkColorTypeValidateAlphaType(SkColorType colorType, SkAlphaType alphaType,
                                   SkAlphaType* canonical = NULL);
 
 ///////////////////////////////////////////////////////////////////////////////
@@ skipping 116 matching lines @@
     }
 
     uint64_t minRowBytes64() const {
         return sk_64_mul(fWidth, this->bytesPerPixel());
     }
 
     size_t minRowBytes() const {
         return (size_t)this->minRowBytes64();
     }
 
+    size_t computeOffset(int x, int y, size_t rowBytes) const {
+        SkASSERT((unsigned)x < (unsigned)fWidth);
+        SkASSERT((unsigned)y < (unsigned)fHeight);
+        return SkColorTypeComputeOffset(fColorType, x, y, rowBytes);
+    }
+
     bool operator==(const SkImageInfo& other) const {
         return 0 == memcmp(this, &other, sizeof(other));
     }
     bool operator!=(const SkImageInfo& other) const {
         return 0 != memcmp(this, &other, sizeof(other));
     }
 
     void unflatten(SkReadBuffer&);
     void flatten(SkWriteBuffer&) const;
 
@@ skipping 31 matching lines @@
         , fHeight(height)
         , fColorType(ct)
         , fAlphaType(at)
         , fProfileType(pt)
     {}
 
     SkColorProfileType  fProfileType;
 };
 
 #endif