src/third_party/skia/src/core/SkPictureFlat.cpp

   1
   2 /*
   3  * Copyright 2011 Google Inc.
   4  *
   5  * Use of this source code is governed by a BSD-style license that can be
   6  * found in the LICENSE file.
   7  */
   8 #include "SkPictureFlat.h"
   9
  10 #include "SkChecksum.h"
  11 #include "SkColorFilter.h"
  12 #include "SkDrawLooper.h"
  13 #include "SkMaskFilter.h"
  14 #include "SkRasterizer.h"
  15 #include "SkShader.h"
  16 #include "SkTypeface.h"
  17 #include "SkXfermode.h"
  18
  19 SK_DEFINE_INST_COUNT(SkFlatController)
  20
  21 ///////////////////////////////////////////////////////////////////////////////
  22
  23 SkTypefacePlayback::SkTypefacePlayback() : fCount(0), fArray(NULL) {}
  24
  25 SkTypefacePlayback::~SkTypefacePlayback() {
  26     this->reset(NULL);
  27 }
  28
  29 void SkTypefacePlayback::reset(const SkRefCntSet* rec) {
  30     for (int i = 0; i < fCount; i++) {
  31         SkASSERT(fArray[i]);
  32         fArray[i]->unref();
  33     }
  34     SkDELETE_ARRAY(fArray);
  35
  36     if (rec!= NULL && rec->count() > 0) {
  37         fCount = rec->count();
  38         fArray = SkNEW_ARRAY(SkRefCnt*, fCount);
  39         rec->copyToArray(fArray);
  40         for (int i = 0; i < fCount; i++) {
  41             fArray[i]->ref();
  42         }
  43     } else {
  44         fCount = 0;
  45         fArray = NULL;
  46     }
  47 }
  48
  49 void SkTypefacePlayback::setCount(int count) {
  50     this->reset(NULL);
  51
  52     fCount = count;
  53     fArray = SkNEW_ARRAY(SkRefCnt*, count);
  54     sk_bzero(fArray, count * sizeof(SkRefCnt*));
  55 }
  56
  57 SkRefCnt* SkTypefacePlayback::set(int index, SkRefCnt* obj) {
  58     SkASSERT((unsigned)index < (unsigned)fCount);
  59     SkRefCnt_SafeAssign(fArray[index], obj);
  60     return obj;
  61 }
  62
  63 ///////////////////////////////////////////////////////////////////////////////
  64
  65 SkFlatController::SkFlatController()
  66 : fBitmapHeap(NULL)
  67 , fTypefaceSet(NULL)
  68 , fTypefacePlayback(NULL)
  69 , fFactorySet(NULL)
  70 , fWriteBufferFlags(0) {}
  71
  72 SkFlatController::~SkFlatController() {
  73     SkSafeUnref(fBitmapHeap);
  74     SkSafeUnref(fTypefaceSet);
  75     SkSafeUnref(fFactorySet);
  76 }
  77
  78 void SkFlatController::setBitmapHeap(SkBitmapHeap* heap) {
  79     SkRefCnt_SafeAssign(fBitmapHeap, heap);
  80 }
  81
  82 void SkFlatController::setTypefaceSet(SkRefCntSet *set) {
  83     SkRefCnt_SafeAssign(fTypefaceSet, set);
  84 }
  85
  86 void SkFlatController::setTypefacePlayback(SkTypefacePlayback* playback) {
  87     fTypefacePlayback = playback;
  88 }
  89
  90 SkNamedFactorySet* SkFlatController::setNamedFactorySet(SkNamedFactorySet* set) {
  91     SkRefCnt_SafeAssign(fFactorySet, set);
  92     return set;
  93 }
  94
  95 ///////////////////////////////////////////////////////////////////////////////
  96
  97 SkFlatData* SkFlatData::Create(SkFlatController* controller,
  98                                const void* obj,
  99                                int index,
 100                                void (*flattenProc)(SkOrderedWriteBuffer&, const void*)) {
 101     // a buffer of 256 bytes should be sufficient for most paints, regions,
 102     // and matrices.
 103     intptr_t storage[256];
 104     SkOrderedWriteBuffer buffer(256, storage, sizeof(storage));
 105
 106     buffer.setBitmapHeap(controller->getBitmapHeap());
 107     buffer.setTypefaceRecorder(controller->getTypefaceSet());
 108     buffer.setNamedFactoryRecorder(controller->getNamedFactorySet());
 109     buffer.setFlags(controller->getWriteBufferFlags());
 110
 111     flattenProc(buffer, obj);
 112     uint32_t size = buffer.size();
 113     SkASSERT(SkIsAlign4(size));
 114
 115     // Allocate enough memory to hold SkFlatData struct and the flat data itself.
 116     size_t allocSize = sizeof(SkFlatData) + size;
 117     SkFlatData* result = (SkFlatData*) controller->allocThrow(allocSize);
 118
 119     // Put the serialized contents into the data section of the new allocation.
 120     buffer.writeToMemory(result->data());
 121     // Stamp the index, size and checksum in the header.
 122     result->stampHeader(index, size);
 123     return result;
 124 }
 125
 126 void SkFlatData::unflatten(void* result,
 127         void (*unflattenProc)(SkOrderedReadBuffer&, void*),
 128         SkBitmapHeap* bitmapHeap,
 129         SkTypefacePlayback* facePlayback) const {
 130
 131     SkOrderedReadBuffer buffer(this->data(), fFlatSize);
 132
 133     if (bitmapHeap) {
 134         buffer.setBitmapStorage(bitmapHeap);
 135     }
 136     if (facePlayback) {
 137         facePlayback->setupBuffer(buffer);
 138     }
 139
 140     unflattenProc(buffer, result);
 141     SkASSERT(fFlatSize == (int32_t)buffer.offset());
 142 }