diff options
Diffstat (limited to 'libsgl/picture/SkPictureFlat.cpp')
| -rw-r--r-- | libsgl/picture/SkPictureFlat.cpp | 266 |
1 files changed, 266 insertions, 0 deletions
diff --git a/libsgl/picture/SkPictureFlat.cpp b/libsgl/picture/SkPictureFlat.cpp new file mode 100644 index 0000000..ba7119e --- /dev/null +++ b/libsgl/picture/SkPictureFlat.cpp @@ -0,0 +1,266 @@ +#include "SkPictureFlat.h" + +#include "SkColorFilter.h" +#include "SkDrawLooper.h" +#include "SkMaskFilter.h" +#include "SkRasterizer.h" +#include "SkShader.h" +#include "SkTypeface.h" +#include "SkXfermode.h" + +SkFlatData* SkFlatData::Alloc(SkChunkAlloc* heap, int32_t size, int index) { + SkFlatData* result = (SkFlatData*) heap->allocThrow(size + sizeof(SkFlatData)); + result->fIndex = index; + result->fAllocSize = size + sizeof(result->fAllocSize); + return result; +} + +SkFlatBitmap* SkFlatBitmap::Flatten(SkChunkAlloc* heap, const SkBitmap& bitmap, + int index, SkRefCntRecorder* rec) { + SkFlattenableWriteBuffer buffer(1024); + buffer.setRefCntRecorder(rec); + + bitmap.flatten(buffer); + size_t size = buffer.size(); + SkFlatBitmap* result = (SkFlatBitmap*) INHERITED::Alloc(heap, size, index); + buffer.flatten(result->fBitmapData); + return result; +} + +SkFlatMatrix* SkFlatMatrix::Flatten(SkChunkAlloc* heap, const SkMatrix& matrix, int index) { + int32_t size = sizeof(SkMatrix); + SkFlatMatrix* result = (SkFlatMatrix*) INHERITED::Alloc(heap, size, index); + memcpy(&result->fMatrixData, &matrix, sizeof(SkMatrix)); + return result; +} + +#ifdef SK_DEBUG_DUMP +void SkFlatMatrix::dump() const { + const SkMatrix* matrix = (const SkMatrix*) fMatrixData; + char pBuffer[DUMP_BUFFER_SIZE]; + char* bufferPtr = pBuffer; + bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), + "matrix: "); + SkScalar scaleX = matrix->getScaleX(); + SkMatrix defaultMatrix; + defaultMatrix.reset(); + if (scaleX != defaultMatrix.getScaleX()) + bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), + "scaleX:%g ", SkScalarToFloat(scaleX)); + SkScalar scaleY = matrix->getScaleY(); + if (scaleY != defaultMatrix.getScaleY()) + bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), + "scaleY:%g ", SkScalarToFloat(scaleY)); + SkScalar skewX = matrix->getSkewX(); + if (skewX != defaultMatrix.getSkewX()) + bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), + "skewX:%g ", SkScalarToFloat(skewX)); + SkScalar skewY = matrix->getSkewY(); + if (skewY != defaultMatrix.getSkewY()) + bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), + "skewY:%g ", SkScalarToFloat(skewY)); + SkScalar translateX = matrix->getTranslateX(); + if (translateX != defaultMatrix.getTranslateX()) + bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), + "translateX:%g ", SkScalarToFloat(translateX)); + SkScalar translateY = matrix->getTranslateY(); + if (translateY != defaultMatrix.getTranslateY()) + bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), + "translateY:%g ", SkScalarToFloat(translateY)); + SkScalar perspX = matrix->getPerspX(); + if (perspX != defaultMatrix.getPerspX()) + bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), + "perspX:%g ", SkFractToFloat(perspX)); + SkScalar perspY = matrix->getPerspY(); + if (perspY != defaultMatrix.getPerspY()) + bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), + "perspY:%g ", SkFractToFloat(perspY)); + SkDebugf("%s\n", pBuffer); +} +#endif + +/////////////////////////////////////////////////////////////////////////////// + +SkFlatPaint* SkFlatPaint::Flatten(SkChunkAlloc* heap, const SkPaint& paint, + int index, SkRefCntRecorder* rec, + SkRefCntRecorder* faceRecorder) { + SkFlattenableWriteBuffer buffer(2*sizeof(SkPaint)); + buffer.setRefCntRecorder(rec); + buffer.setTypefaceRecorder(faceRecorder); + + paint.flatten(buffer); + uint32_t size = buffer.size(); + SkFlatPaint* result = (SkFlatPaint*) INHERITED::Alloc(heap, size, index); + buffer.flatten(&result->fPaintData); + return result; +} + +void SkFlatPaint::Read(const void* storage, SkPaint* paint, + SkRefCntPlayback* rcp, SkTypefacePlayback* facePlayback) { + SkFlattenableReadBuffer buffer(storage); + if (rcp) { + rcp->setupBuffer(buffer); + } + if (facePlayback) { + facePlayback->setupBuffer(buffer); + } + paint->unflatten(buffer); +} + +#ifdef SK_DEBUG_DUMP +void SkFlatPaint::dump() const { + SkPaint defaultPaint; + SkFlattenableReadBuffer buffer(fPaintData); + SkTypeface* typeface = (SkTypeface*) buffer.readPtr(); + char pBuffer[DUMP_BUFFER_SIZE]; + char* bufferPtr = pBuffer; + bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), + "paint: "); + if (typeface != defaultPaint.getTypeface()) + bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), + "typeface:%p ", typeface); + SkScalar textSize = buffer.readScalar(); + if (textSize != defaultPaint.getTextSize()) + bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), + "textSize:%g ", SkScalarToFloat(textSize)); + SkScalar textScaleX = buffer.readScalar(); + if (textScaleX != defaultPaint.getTextScaleX()) + bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), + "textScaleX:%g ", SkScalarToFloat(textScaleX)); + SkScalar textSkewX = buffer.readScalar(); + if (textSkewX != defaultPaint.getTextSkewX()) + bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), + "textSkewX:%g ", SkScalarToFloat(textSkewX)); + const SkPathEffect* pathEffect = (const SkPathEffect*) buffer.readFlattenable(); + if (pathEffect != defaultPaint.getPathEffect()) + bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), + "pathEffect:%p ", pathEffect); + SkDELETE(pathEffect); + const SkShader* shader = (const SkShader*) buffer.readFlattenable(); + if (shader != defaultPaint.getShader()) + bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), + "shader:%p ", shader); + SkDELETE(shader); + const SkXfermode* xfermode = (const SkXfermode*) buffer.readFlattenable(); + if (xfermode != defaultPaint.getXfermode()) + bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), + "xfermode:%p ", xfermode); + SkDELETE(xfermode); + const SkMaskFilter* maskFilter = (const SkMaskFilter*) buffer.readFlattenable(); + if (maskFilter != defaultPaint.getMaskFilter()) + bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), + "maskFilter:%p ", maskFilter); + SkDELETE(maskFilter); + const SkColorFilter* colorFilter = (const SkColorFilter*) buffer.readFlattenable(); + if (colorFilter != defaultPaint.getColorFilter()) + bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), + "colorFilter:%p ", colorFilter); + SkDELETE(colorFilter); + const SkRasterizer* rasterizer = (const SkRasterizer*) buffer.readFlattenable(); + if (rasterizer != defaultPaint.getRasterizer()) + bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), + "rasterizer:%p ", rasterizer); + SkDELETE(rasterizer); + const SkDrawLooper* drawLooper = (const SkDrawLooper*) buffer.readFlattenable(); + if (drawLooper != defaultPaint.getLooper()) + bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), + "drawLooper:%p ", drawLooper); + SkDELETE(drawLooper); + unsigned color = buffer.readU32(); + if (color != defaultPaint.getColor()) + bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), + "color:0x%x ", color); + SkScalar strokeWidth = buffer.readScalar(); + if (strokeWidth != defaultPaint.getStrokeWidth()) + bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), + "strokeWidth:%g ", SkScalarToFloat(strokeWidth)); + SkScalar strokeMiter = buffer.readScalar(); + if (strokeMiter != defaultPaint.getStrokeMiter()) + bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), + "strokeMiter:%g ", SkScalarToFloat(strokeMiter)); + unsigned flags = buffer.readU16(); + if (flags != defaultPaint.getFlags()) + bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), + "flags:0x%x ", flags); + int align = buffer.readU8(); + if (align != defaultPaint.getTextAlign()) + bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), + "align:0x%x ", align); + int strokeCap = buffer.readU8(); + if (strokeCap != defaultPaint.getStrokeCap()) + bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), + "strokeCap:0x%x ", strokeCap); + int strokeJoin = buffer.readU8(); + if (strokeJoin != defaultPaint.getStrokeJoin()) + bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), + "align:0x%x ", strokeJoin); + int style = buffer.readU8(); + if (style != defaultPaint.getStyle()) + bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), + "style:0x%x ", style); + int textEncoding = buffer.readU8(); + if (textEncoding != defaultPaint.getTextEncoding()) + bufferPtr += snprintf(bufferPtr, DUMP_BUFFER_SIZE - (bufferPtr - pBuffer), + "textEncoding:0x%x ", textEncoding); + SkDebugf("%s\n", pBuffer); +} +#endif + +SkFlatPath* SkFlatPath::Flatten(SkChunkAlloc* heap, const SkPath& path, int index) { + SkFlattenableWriteBuffer buffer(1024); + path.flatten(buffer); + uint32_t size = buffer.size(); + SkFlatPath* result = (SkFlatPath*) INHERITED::Alloc(heap, size, index); + buffer.flatten(&result->fPathData); + return result; +} + +SkFlatRegion* SkFlatRegion::Flatten(SkChunkAlloc* heap, const SkRegion& region, int index) { + uint32_t size = region.flatten(NULL); + SkFlatRegion* result = (SkFlatRegion*) INHERITED::Alloc(heap, size, index); + region.flatten(&result->fRegionData); + return result; +} + +/////////////////////////////////////////////////////////////////////////////// + +SkRefCntPlayback::SkRefCntPlayback() : fCount(0), fArray(NULL) {} + +SkRefCntPlayback::~SkRefCntPlayback() { + this->reset(NULL); +} + +void SkRefCntPlayback::reset(const SkRefCntRecorder* rec) { + for (int i = 0; i < fCount; i++) { + SkASSERT(fArray[i]); + fArray[i]->unref(); + } + SkDELETE_ARRAY(fArray); + + if (rec) { + fCount = rec->count(); + fArray = SkNEW_ARRAY(SkRefCnt*, fCount); + rec->get(fArray); + for (int i = 0; i < fCount; i++) { + fArray[i]->ref(); + } + } else { + fCount = 0; + fArray = NULL; + } +} + +void SkRefCntPlayback::setCount(int count) { + this->reset(NULL); + + fCount = count; + fArray = SkNEW_ARRAY(SkRefCnt*, count); + bzero(fArray, count * sizeof(SkRefCnt*)); +} + +SkRefCnt* SkRefCntPlayback::set(int index, SkRefCnt* obj) { + SkASSERT((unsigned)index < (unsigned)fCount); + SkRefCnt_SafeAssign(fArray[index], obj); + return obj; +} + |