Expand pixelref to return SkImageInfo and rowbytes

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 "SkBitmap.h"
 #include "SkRefCnt.h"
 #include "SkString.h"
 #include "SkFlattenable.h"
+#include "SkImageInfo.h"
 #include "SkTDArray.h"
 
 #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
@@ skipping 18 matching lines @@
 
     This class can be shared/accessed between multiple threads.
 */
 class SK_API SkPixelRef : public SkFlattenable {
 public:
     SK_DECLARE_INST_COUNT(SkPixelRef)
 
     explicit SkPixelRef(SkBaseMutex* mutex = NULL);
     virtual ~SkPixelRef();
 
+    /**
+     *  Return the data's rowbytes. Will be 0 if the the lockCount is 0.
+     */
+    size_t rowBytes() const { return fRowBytes; }
+
     /** Return the pixel memory returned from lockPixels, or null if the
         lockCount is 0.
     */
     void* pixels() const { return fPixels; }
 
     /** Return the current colorTable (if any) if pixels are locked, or null.
     */
     SkColorTable* colorTable() const { return fColorTable; }
 
     /**
@@ skipping 159 matching lines @@
         virtual void onChange() = 0;
     };
 
     // Takes ownership of listener.
     void addGenIDChangeListener(GenIDChangeListener* listener);
 
 protected:
     /** Called when the lockCount goes from 0 to 1. The caller will have already
         acquire a mutex for thread safety, so this method need not do that.
     */
-    virtual void* onLockPixels(SkColorTable**) = 0;
+    virtual void* onLockPixels(SkImageInfo*, size_t* rowBytes, SkColorTable**) = 0;

[scroggo, 2013/11/19 18:17:09]

Comments explaining the parameters would be nice.

     /** Called when the lock count goes from 1 to 0. The caller will have
         already acquire a mutex for thread safety, so this method need not do
         that.
     */
     virtual void onUnlockPixels() = 0;
 
     /** Default impl returns true */
     virtual bool onLockPixelsAreWritable() const;
 
     // returns false;
@@ skipping 17 matching lines @@
     */
     SkBaseMutex* mutex() const { return fMutex; }
 
     // serialization
     SkPixelRef(SkFlattenableReadBuffer&, SkBaseMutex*);
     virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
 
     // 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* pixels, SkColorTable* ctable);
+    void setPreLocked(void* pixels, size_t rowBytes, SkColorTable* ctable);
 
 private:
     SkBaseMutex*    fMutex; // must remain in scope for the life of this object
     void*           fPixels;
     SkColorTable*   fColorTable;    // we do not track ownership, subclass does
+    size_t          fRowBytes;
     int             fLockCount;
 
     mutable uint32_t fGenerationID;
     mutable bool     fUniqueGenerationID;
 
     SkTDArray<GenIDChangeListener*> fGenIDChangeListeners;  // pointers are owned
 
     SkString    fURI;
 
     // can go from false to true, but never from true to false
     bool    fIsImmutable;
     // only ever set in constructor, const after that
     bool    fPreLocked;
 
     void needsNewGenID();
     void callGenIDChangeListeners();
 
     void setMutex(SkBaseMutex* mutex);
 
     // When copying a bitmap to another with the same shape and config, we can safely
     // clone the pixelref generation ID too, which makes them equivalent under caching.
     friend class SkBitmap;  // only for cloneGenID
     void cloneGenID(const SkPixelRef&);
 
     typedef SkFlattenable INHERITED;
 };
 
 #endif