add SkPixmap and external locking to bitmaps

include/core/SkPixelRef.h

 /*
  * Copyright 2008 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkPixelRef_DEFINED
 #define SkPixelRef_DEFINED
 
 #include "SkAtomics.h"
 #include "SkBitmap.h"
+#include "SkFilterQuality.h"
 #include "SkImageInfo.h"
 #include "SkMutex.h"
+#include "SkPixmap.h"
 #include "SkRefCnt.h"
 #include "SkSize.h"
 #include "SkString.h"
 #include "SkTDArray.h"
 
-//#define xed
-
 #ifdef SK_DEBUG
     /**
      *  Defining SK_IGNORE_PIXELREF_SETPRELOCKED will force all pixelref
      *  subclasses to correctly handle lock/unlock pixels. For performance
      *  reasons, simple malloc-based subclasses call setPreLocked() to skip
      *  the overhead of implementing these calls.
      *
      *  This build-flag disables that optimization, to add in debugging our
      *  call-sites, to ensure that they correctly balance their calls of
      *  lock and unlock.
@@ skipping 154 matching lines @@
      *  return a ref to its data. If the pixelRef
      *  is uncompressed or otherwise does not have this form, return NULL.
      *
      *  If non-null is returned, the caller is responsible for calling unref()
      *  on the data when it is finished.
      */
     SkData* refEncodedData() {
         return this->onRefEncodedData();
     }
 
+    struct LockRequest {
+        SkISize         fSize;
+        SkFilterQuality fQuality;
+    };
+
+    struct LockResult {
+        void        (*fUnlockProc)(void* ctx);
+        void*       fUnlockContext;
+
+        SkColorTable* fCTable;  // should be NULL unless colortype is kIndex8
+        const void* fPixels;
+        size_t      fRowBytes;
+        SkISize     fSize;
+
+        void unlock() {
+            if (fUnlockProc) {
+                fUnlockProc(fUnlockContext);
+                fUnlockProc = NULL; // can't unlock twice!
+            }
+        }
+    };
+
+    bool requestLock(const LockRequest&, LockResult*);
+
     /** Are we really wrapping a texture instead of a bitmap?
      */
     virtual GrTexture* getTexture() { return NULL; }
 
     /**
      *  If any planes or rowBytes is NULL, this should output the sizes and return true
      *  if it can efficiently return YUV planar data. If it cannot, it should return false.
      *
      *  If all planes and rowBytes are not NULL, then it should copy the associated Y,U,V data
      *  into those planes of memory supplied by the caller. It should validate that the sizes
@@ skipping 86 matching lines @@
     /**
      *  Returns the size (in bytes) of the internally allocated memory.
      *  This should be implemented in all serializable SkPixelRef derived classes.
      *  SkBitmap::fPixelRefOffset + SkBitmap::getSafeSize() should never overflow this value,
      *  otherwise the rendering code may attempt to read memory out of bounds.
      *
      *  @return default impl returns 0.
      */
     virtual size_t getAllocatedSizeInBytes() const;
 
+    virtual bool onRequestLock(const LockRequest&, LockResult*);
+
     /** Return the mutex associated with this pixelref. This value is assigned
         in the constructor, and cannot change during the lifetime of the object.
     */
     SkBaseMutex* mutex() const { return fMutex; }
 
     // only call from constructor. Flags this to always be locked, removing
     // the need to grab the mutex and call onLockPixels/onUnlockPixels.
     // Performance tweak to avoid those calls (esp. in multi-thread use case).
     void setPreLocked(void*, size_t rowBytes, SkColorTable*);
 
@@ skipping 44 matching lines @@
     /**
      *  Allocate a new pixelref matching the specified ImageInfo, allocating
      *  the memory for the pixels. If the ImageInfo requires a ColorTable,
      *  the pixelref will ref() the colortable.
      *  On failure return NULL.
      */
     virtual SkPixelRef* create(const SkImageInfo&, size_t rowBytes, SkColorTable*) = 0;
 };
 
 #endif