add installPixels

include/core/SkBitmap.h

 /*
  * Copyright 2006 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 SkBitmap_DEFINED
 #define SkBitmap_DEFINED
 
 #include "SkColor.h"
 #include "SkColorTable.h"
 #include "SkImageInfo.h"
 #include "SkPoint.h"
 #include "SkRefCnt.h"
 
 struct SkIRect;
 struct SkRect;
 class SkPaint;
 class SkPixelRef;
+class SkPixelRefFactory;
 class SkRegion;
 class SkString;
 
 class GrTexture;
 
 /** \class SkBitmap
 
     The SkBitmap class specifies a raster bitmap. A bitmap has an integer width
     and height, and a format (config), and a pointer to the actual pixels.
     Bitmaps can be drawn into a SkCanvas, but they are also used to specify the
@@ skipping 212 matching lines @@
     bool setConfig(Config, int width, int height, size_t rowBytes, SkAlphaType);
 
     bool setConfig(Config config, int width, int height, size_t rowBytes = 0) {
         return this->setConfig(config, width, height, rowBytes,
                                kPremul_SkAlphaType);
     }
 
     bool setConfig(const SkImageInfo& info, size_t rowBytes = 0);
 
     /**
+     *  Allocate a pixelref to match the specified image info. If the Factory
+     *  is non-null, call it to allcoate the pixelref. If the ImageInfo requires
+     *  a colortable, then ColorTable must be non-null, and will be ref'd.
+     *  On failure, the bitmap will be set to empty and return false.
+     */
+    bool allocPixels(const SkImageInfo&, SkPixelRefFactory*, SkColorTable*);
+    
+    /**
+     *  Allocate a pixelref to match the specified image info, using the default
+     *  allocator.
+     *  On success, the bitmap's pixels will be "locked", and return true.
+     *  On failure, the bitmap will be set to empty and return false.
+     */
+    bool allocPixels(const SkImageInfo& info) {
+        return this->allocPixels(info, NULL, NULL);
+    }
+    
+    /**
+     *  Install a pixelref that wraps the specified pixels and rowBytes, and
+     *  optional ReleaseProc and context. When the pixels are no longer
+     *  referenced, if ReleaseProc is not null, it will be called with the
+     *  pixels and context as parameters.
+     *  On failure, the bitmap will be set to empty and return false.
+     */
+    bool installPixels(const SkImageInfo&, void* pixels, size_t rowBytes,
+                       void (*ReleaseProc)(void* addr, void* context),
+                       void* context);
+    
+    /**
      *  If the bitmap's config can be represented as SkImageInfo, return true,
      *  and if info is not-null, set it to the bitmap's info. If it cannot be
      *  represented as SkImageInfo, return false and ignore the info parameter.
      */
     bool asImageInfo(SkImageInfo* info) const;
 
     /** Use this to assign a new pixel address for an existing bitmap. This
         will automatically release any pixelref previously installed. Only call
         this if you are handling ownership/lifetime of the pixel memory.
 
@@ skipping 367 matching lines @@
     private:
         typedef SkRefCnt INHERITED;
     };
 
     /** Subclass of Allocator that returns a pixelref that allocates its pixel
         memory from the heap. This is the default Allocator invoked by
         allocPixels().
     */
     class HeapAllocator : public Allocator {
     public:
-        virtual bool allocPixelRef(SkBitmap*, SkColorTable*);
+        virtual bool allocPixelRef(SkBitmap*, SkColorTable*) SK_OVERRIDE;
     };
 
     class RLEPixels {
     public:
         RLEPixels(int width, int height);
         virtual ~RLEPixels();
 
         uint8_t* packedAtY(int y) const {
             SkASSERT((unsigned)y < (unsigned)fHeight);
             return fYPtrs[y];
@@ skipping 176 matching lines @@
 
 inline SkPMColor SkBitmap::getIndex8Color(int x, int y) const {
     SkASSERT(fPixels);
     SkASSERT(fConfig == kIndex8_Config);
     SkASSERT((unsigned)x < fWidth && (unsigned)y < fHeight);
     SkASSERT(fColorTable);
     return (*fColorTable)[*((const uint8_t*)fPixels + y * fRowBytes + x)];
 }
 
 #endif