Enable basic drawing with SkRecord-based pictures.

src/core/SkPicture.cpp

 
 /*
  * Copyright 2007 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.
  */
 
 
 #include "SkPictureFlat.h"
@@ skipping 14 matching lines @@
 
 #include "SkReader32.h"
 #include "SkWriter32.h"
 #include "SkRTree.h"
 #include "SkBBoxHierarchyRecord.h"
 
 #if SK_SUPPORT_GPU
 #include "GrContext.h"
 #endif
 
+#include "SkRecord.h"
+#include "SkRecordDraw.h"
+
 template <typename T> int SafeCount(const T* obj) {
     return obj ? obj->count() : 0;
 }
 
 #define DUMP_BUFFER_SIZE 65536
 
 //#define ENABLE_TIME_DRAW    // dumps milliseconds for each draw
 
 
 #ifdef SK_DEBUG
@@ skipping 71 matching lines @@
     SkASSERT(scaleX == 0 || skewX == 0);
     SkASSERT(scaleY == 0 || skewY == 0);
     SkASSERT(perspX == 0);
     SkASSERT(perspY == 0);
 }
 #endif
 
 
 ///////////////////////////////////////////////////////////////////////////////
 
+// fRecord OK
 SkPicture::SkPicture()
-    : fAccelData(NULL) {
+    : fWidth(0)
+    , fHeight(0) {
     this->needsNewGenID();
-    fPlayback = NULL;
-    fWidth = fHeight = 0;
 }
 
+// fRecord OK
 SkPicture::SkPicture(int width, int height,
                      const SkPictureRecord& record,
                      bool deepCopyOps)
     : fWidth(width)
-    , fHeight(height)
-    , fAccelData(NULL) {
+    , fHeight(height) {
     this->needsNewGenID();
 
     SkPictInfo info;
     this->createHeader(&info);
-    fPlayback = SkNEW_ARGS(SkPicturePlayback, (record, info, deepCopyOps));
+    fPlayback.reset(SkNEW_ARGS(SkPicturePlayback, (record, info, deepCopyOps)));
 }
 
-SkPicture::SkPicture(const SkPicture& src)
-    : INHERITED()
-    , fAccelData(NULL) {
+// fRecord TODO
+SkPicture::SkPicture(const SkPicture& src) : INHERITED() {
     this->needsNewGenID();
     fWidth = src.fWidth;
     fHeight = src.fHeight;
 
-    if (src.fPlayback) {
-        fPlayback = SkNEW_ARGS(SkPicturePlayback, (*src.fPlayback));
+    if (src.fPlayback.get()) {
+        fPlayback.reset(SkNEW_ARGS(SkPicturePlayback, (*src.fPlayback)));
         fUniqueID = src.uniqueID();     // need to call method to ensure != 0
-    } else {
-        fPlayback = NULL;
     }
 }
 
-SkPicture::~SkPicture() {
-    SkDELETE(fPlayback);
-    SkSafeUnref(fAccelData);
+// fRecord OK
+SkPicture::~SkPicture() {}
+
+// fRecord OK
+void SkPicture::swap(SkPicture& other) {
+    SkTSwap(fUniqueID, other.fUniqueID);
+    SkTSwap(fWidth, other.fWidth);
+    SkTSwap(fHeight, other.fHeight);
+
+    fAccelData.swap(&other.fAccelData);
+    fPlayback.swap(&other.fPlayback);
+    fRecord.swap(&other.fRecord);
 }
 
-void SkPicture::swap(SkPicture& other) {
-    SkTSwap(fUniqueID, other.fUniqueID);
-    SkTSwap(fPlayback, other.fPlayback);
-    SkTSwap(fAccelData, other.fAccelData);
-    SkTSwap(fWidth, other.fWidth);
-    SkTSwap(fHeight, other.fHeight);
-}
-
+// fRecord TODO
 SkPicture* SkPicture::clone() const {
     SkPicture* clonedPicture = SkNEW(SkPicture);
     this->clone(clonedPicture, 1);
     return clonedPicture;
 }
 
+// fRecord TODO
 void SkPicture::clone(SkPicture* pictures, int count) const {
     SkPictCopyInfo copyInfo;
 
     for (int i = 0; i < count; i++) {
         SkPicture* clone = &pictures[i];
 
         clone->needsNewGenID();
         clone->fWidth = fWidth;
         clone->fHeight = fHeight;
-        SkDELETE(clone->fPlayback);
+        clone->fPlayback.reset(NULL);
 
         /*  We want to copy the src's playback. However, if that hasn't been built
             yet, we need to fake a call to endRecording() without actually calling
             it (since it is destructive, and we don't want to change src).
          */
-        if (fPlayback) {
+        if (fPlayback.get()) {
             if (!copyInfo.initialized) {
                 int paintCount = SafeCount(fPlayback->fPaints);
 
                 /* The alternative to doing this is to have a clone method on the paint and have it
                  * make the deep copy of its internal structures as needed. The holdup to doing
                  * that is at this point we would need to pass the SkBitmapHeap so that we don't
                  * unnecessarily flatten the pixels in a bitmap shader.
                  */
                 copyInfo.paintData.setCount(paintCount);
 
@@ skipping 22 matching lines @@
                         copyInfo.paintData[i] = NULL;
                     }
                 }
                 SkASSERT(SafeCount(fPlayback->fBitmapHeap.get()) == heapSize);
 
                 // needed to create typeface playback
                 copyInfo.controller.setupPlaybacks();
                 copyInfo.initialized = true;
             }
 
-            clone->fPlayback = SkNEW_ARGS(SkPicturePlayback, (*fPlayback, &copyInfo));
+            clone->fPlayback.reset(SkNEW_ARGS(SkPicturePlayback, (*fPlayback, &copyInfo)));
             clone->fUniqueID = this->uniqueID(); // need to call method to ensure != 0
-        } else {
-            clone->fPlayback = NULL;
         }
     }
 }
 
+// fRecord OK
+void SkPicture::EXPERIMENTAL_addAccelData(const SkPicture::AccelData* data) const {
+    fAccelData.reset(SkRef(data));
+}
+
+// fRecord OK
+const SkPicture::AccelData* SkPicture::EXPERIMENTAL_getAccelData(
+        SkPicture::AccelData::Key key) const {
+    if (NULL != fAccelData.get() && fAccelData->getKey() == key) {
+        return fAccelData.get();
+    }
+    return NULL;
+}
+
+// fRecord OK
 SkPicture::AccelData::Domain SkPicture::AccelData::GenerateDomain() {
     static int32_t gNextID = 0;
 
     int32_t id = sk_atomic_inc(&gNextID);
     if (id >= 1 << (8 * sizeof(Domain))) {
         SK_CRASH();
     }
 
     return static_cast<Domain>(id);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
+// fRecord OK
 const SkPicture::OperationList& SkPicture::OperationList::InvalidList() {
     static OperationList gInvalid;
     return gInvalid;
 }
 
+// fRecord TODO
 const SkPicture::OperationList& SkPicture::EXPERIMENTAL_getActiveOps(const SkIRect& queryRect) const {
-    SkASSERT(NULL != fPlayback);
-    if (NULL != fPlayback) {
+    SkASSERT(NULL != fPlayback.get());
+    if (NULL != fPlayback.get()) {
         return fPlayback->getActiveOps(queryRect);
     }
     return OperationList::InvalidList();
 }
 
+// fRecord TODO
 size_t SkPicture::EXPERIMENTAL_curOpID() const {
-    if (NULL != fPlayback) {
+    if (NULL != fPlayback.get()) {
         return fPlayback->curOpID();
     }
     return 0;
 }
 
-void SkPicture::draw(SkCanvas* surface, SkDrawPictureCallback* callback) const {
-    SkASSERT(NULL != fPlayback);
-    if (NULL != fPlayback) {
-        fPlayback->draw(*surface, callback);
+// fRecord OK
+void SkPicture::draw(SkCanvas* canvas, SkDrawPictureCallback* callback) const {
+    SkASSERT(NULL != canvas);
+    SkASSERT(NULL != fPlayback.get() || NULL != fRecord.get());
+
+    if (NULL != fPlayback.get()) {
+        fPlayback->draw(*canvas, callback);
+    }
+    if (NULL != fRecord.get()) {
+        // TODO: support SkDrawPictureCallback
+        SkRecordDraw(*fRecord, canvas);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "SkStream.h"
 
 static const char kMagic[] = { 's', 'k', 'i', 'a', 'p', 'i', 'c', 't' };
 
+// fRecord OK
 bool SkPicture::IsValidPictInfo(const SkPictInfo& info) {
     if (0 != memcmp(info.fMagic, kMagic, sizeof(kMagic))) {
         return false;
     }
 
     if (info.fVersion < MIN_PICTURE_VERSION ||
         info.fVersion > CURRENT_PICTURE_VERSION) {
         return false;
     }
 
     return true;
 }
 
+// fRecord OK
 bool SkPicture::InternalOnly_StreamIsSKP(SkStream* stream, SkPictInfo* pInfo) {
     if (NULL == stream) {
         return false;
     }
 
     // Check magic bytes.
     SkPictInfo info;
     SkASSERT(sizeof(kMagic) == sizeof(info.fMagic));
     if (!stream->read(&info, sizeof(info)) || !IsValidPictInfo(info)) {
         return false;
     }
 
     if (pInfo != NULL) {
         *pInfo = info;
     }
     return true;
 }
 
+// fRecord OK
 bool SkPicture::InternalOnly_BufferIsSKP(SkReadBuffer& buffer, SkPictInfo* pInfo) {
     // Check magic bytes.
     SkPictInfo info;
     SkASSERT(sizeof(kMagic) == sizeof(info.fMagic));
     if (!buffer.readByteArray(&info, sizeof(info)) || !IsValidPictInfo(info)) {
         return false;
     }
 
     if (pInfo != NULL) {
         *pInfo = info;
     }
     return true;
 }
 
+// fRecord OK
 SkPicture::SkPicture(SkPicturePlayback* playback, int width, int height)
     : fPlayback(playback)
     , fWidth(width)
-    , fHeight(height)
-    , fAccelData(NULL) {
+    , fHeight(height) {
     this->needsNewGenID();
 }
 
+// fRecord OK
 SkPicture* SkPicture::CreateFromStream(SkStream* stream, InstallPixelRefProc proc) {
     SkPictInfo info;
 
     if (!InternalOnly_StreamIsSKP(stream, &info)) {
         return NULL;
     }
 
     // Check to see if there is a playback to recreate.
     if (stream->readBool()) {
         SkPicturePlayback* playback = SkPicturePlayback::CreateFromStream(stream, info, proc);
         if (NULL == playback) {
             return NULL;
         }
 
         return SkNEW_ARGS(SkPicture, (playback, info.fWidth, info.fHeight));
     }
 
     return NULL;
 }
 
+// fRecord OK
 SkPicture* SkPicture::CreateFromBuffer(SkReadBuffer& buffer) {
     SkPictInfo info;
 
     if (!InternalOnly_BufferIsSKP(buffer, &info)) {
         return NULL;
     }
 
     // Check to see if there is a playback to recreate.
     if (buffer.readBool()) {
         SkPicturePlayback* playback = SkPicturePlayback::CreateFromBuffer(buffer, info);
         if (NULL == playback) {
             return NULL;
         }
 
         return SkNEW_ARGS(SkPicture, (playback, info.fWidth, info.fHeight));
     }
 
     return NULL;
 }
 
+// fRecord OK
 void SkPicture::createHeader(SkPictInfo* info) const {
     // Copy magic bytes at the beginning of the header
     SkASSERT(sizeof(kMagic) == 8);
     SkASSERT(sizeof(kMagic) == sizeof(info->fMagic));
     memcpy(info->fMagic, kMagic, sizeof(kMagic));
 
     // Set picture info after magic bytes in the header
     info->fVersion = CURRENT_PICTURE_VERSION;
     info->fWidth = fWidth;
     info->fHeight = fHeight;
     info->fFlags = SkPictInfo::kCrossProcess_Flag;
     // TODO: remove this flag, since we're always float (now)
     info->fFlags |= SkPictInfo::kScalarIsFloat_Flag;
 
     if (8 == sizeof(void*)) {
         info->fFlags |= SkPictInfo::kPtrIs64Bit_Flag;
     }
 }
 
+// fRecord TODO
 void SkPicture::serialize(SkWStream* stream, EncodeBitmap encoder) const {
-    SkPicturePlayback* playback = fPlayback;
+    SkPicturePlayback* playback = fPlayback.get();
 
     SkPictInfo info;
     this->createHeader(&info);
     stream->write(&info, sizeof(info));
     if (playback) {
         stream->writeBool(true);
         playback->serialize(stream, encoder);
         // delete playback if it is a local version (i.e. cons'd up just now)
-        if (playback != fPlayback) {
+        if (playback != fPlayback.get()) {
             SkDELETE(playback);
         }
     } else {
         stream->writeBool(false);
     }
 }
 
+// fRecord OK
 void SkPicture::WriteTagSize(SkWriteBuffer& buffer, uint32_t tag, size_t size) {
     buffer.writeUInt(tag);
     buffer.writeUInt(SkToU32(size));
 }
 
+// fRecord OK
 void SkPicture::WriteTagSize(SkWStream* stream, uint32_t tag,  size_t size) {
     stream->write32(tag);
     stream->write32(SkToU32(size));
 }
 
+// fRecord TODO
 void SkPicture::flatten(SkWriteBuffer& buffer) const {
-    SkPicturePlayback* playback = fPlayback;
+    SkPicturePlayback* playback = fPlayback.get();
 
     SkPictInfo info;
     this->createHeader(&info);
     buffer.writeByteArray(&info, sizeof(info));
     if (playback) {
         buffer.writeBool(true);
         playback->flatten(buffer);
         // delete playback if it is a local version (i.e. cons'd up just now)
-        if (playback != fPlayback) {
+        if (playback != fPlayback.get()) {
             SkDELETE(playback);
         }
     } else {
         buffer.writeBool(false);
     }
 }
 
 #if SK_SUPPORT_GPU
+// fRecord TODO
 bool SkPicture::suitableForGpuRasterization(GrContext* context, const char **reason) const {
-    if (NULL == fPlayback) {
+    if (NULL == fPlayback.get()) {
         if (NULL != reason) {
             *reason = "Missing playback object.";
         }
         return false;
     }
 
     return fPlayback->suitableForGpuRasterization(context, reason);
 }
 #endif
 
+// fRecord TODO
 bool SkPicture::willPlayBackBitmaps() const {
-    if (!fPlayback) {
+    if (!fPlayback.get()) {
         return false;
     }
     return fPlayback->containsBitmaps();
 }
 
 #ifdef SK_BUILD_FOR_ANDROID
+// fRecord TODO
 void SkPicture::abortPlayback() {
-    if (NULL == fPlayback) {
+    if (NULL == fPlayback.get()) {
         return;
     }
     fPlayback->abort();
 }
 #endif
 
+// fRecord OK
 static int32_t next_picture_generation_id() {
     static int32_t  gPictureGenerationID = 0;
     // do a loop in case our global wraps around, as we never want to
     // return a 0
     int32_t genID;
     do {
         genID = sk_atomic_inc(&gPictureGenerationID) + 1;
     } while (SK_InvalidGenID == genID);
     return genID;
 }
 
+// fRecord OK
 uint32_t SkPicture::uniqueID() const {
     if (SK_InvalidGenID == fUniqueID) {
         fUniqueID = next_picture_generation_id();
     }
     return fUniqueID;
 }
+
+// fRecord OK
+SkPicture::SkPicture(int width, int height, SkRecord* record)
+    : fWidth(width)
+    , fHeight(height)
+    , fRecord(record) {
+    this->needsNewGenID();
+}