michael@0: 
michael@0: /*
michael@0:  * Copyright 2011 Google Inc.
michael@0:  *
michael@0:  * Use of this source code is governed by a BSD-style license that can be
michael@0:  * found in the LICENSE file.
michael@0:  */
michael@0: 
michael@0: 
michael@0: #include "SkBitmapHeap.h"
michael@0: #include "SkCanvas.h"
michael@0: #include "SkPaint.h"
michael@0: #include "SkGPipe.h"
michael@0: #include "SkGPipePriv.h"
michael@0: #include "SkReader32.h"
michael@0: #include "SkStream.h"
michael@0: 
michael@0: #include "SkAnnotation.h"
michael@0: #include "SkColorFilter.h"
michael@0: #include "SkDrawLooper.h"
michael@0: #include "SkImageFilter.h"
michael@0: #include "SkMaskFilter.h"
michael@0: #include "SkReadBuffer.h"
michael@0: #include "SkPathEffect.h"
michael@0: #include "SkRasterizer.h"
michael@0: #include "SkRRect.h"
michael@0: #include "SkShader.h"
michael@0: #include "SkTypeface.h"
michael@0: #include "SkXfermode.h"
michael@0: 
michael@0: static SkFlattenable::Type paintflat_to_flattype(PaintFlats pf) {
michael@0:     static const uint8_t gEffectTypesInPaintFlatsOrder[] = {
michael@0:         SkFlattenable::kSkColorFilter_Type,
michael@0:         SkFlattenable::kSkDrawLooper_Type,
michael@0:         SkFlattenable::kSkImageFilter_Type,
michael@0:         SkFlattenable::kSkMaskFilter_Type,
michael@0:         SkFlattenable::kSkPathEffect_Type,
michael@0:         SkFlattenable::kSkRasterizer_Type,
michael@0:         SkFlattenable::kSkShader_Type,
michael@0:         SkFlattenable::kSkXfermode_Type,
michael@0:     };
michael@0: 
michael@0:     SkASSERT((size_t)pf < SK_ARRAY_COUNT(gEffectTypesInPaintFlatsOrder));
michael@0:     return (SkFlattenable::Type)gEffectTypesInPaintFlatsOrder[pf];
michael@0: }
michael@0: 
michael@0: static void set_paintflat(SkPaint* paint, SkFlattenable* obj, unsigned paintFlat) {
michael@0:     SkASSERT(paintFlat < kCount_PaintFlats);
michael@0:     switch (paintFlat) {
michael@0:         case kColorFilter_PaintFlat:
michael@0:             paint->setColorFilter((SkColorFilter*)obj);
michael@0:             break;
michael@0:         case kDrawLooper_PaintFlat:
michael@0:             paint->setLooper((SkDrawLooper*)obj);
michael@0:             break;
michael@0:         case kMaskFilter_PaintFlat:
michael@0:             paint->setMaskFilter((SkMaskFilter*)obj);
michael@0:             break;
michael@0:         case kPathEffect_PaintFlat:
michael@0:             paint->setPathEffect((SkPathEffect*)obj);
michael@0:             break;
michael@0:         case kRasterizer_PaintFlat:
michael@0:             paint->setRasterizer((SkRasterizer*)obj);
michael@0:             break;
michael@0:         case kShader_PaintFlat:
michael@0:             paint->setShader((SkShader*)obj);
michael@0:             break;
michael@0:         case kImageFilter_PaintFlat:
michael@0:             paint->setImageFilter((SkImageFilter*)obj);
michael@0:             break;
michael@0:         case kXfermode_PaintFlat:
michael@0:             paint->setXfermode((SkXfermode*)obj);
michael@0:             break;
michael@0:         default:
michael@0:             SkDEBUGFAIL("never gets here");
michael@0:     }
michael@0: }
michael@0: 
michael@0: template <typename T> class SkRefCntTDArray : public SkTDArray<T> {
michael@0: public:
michael@0:     ~SkRefCntTDArray() { this->unrefAll(); }
michael@0: };
michael@0: 
michael@0: class SkGPipeState : public SkBitmapHeapReader {
michael@0: public:
michael@0:     SkGPipeState();
michael@0:     ~SkGPipeState();
michael@0: 
michael@0:     void setSilent(bool silent) {
michael@0:         fSilent = silent;
michael@0:     }
michael@0: 
michael@0:     bool shouldDraw() {
michael@0:         return !fSilent;
michael@0:     }
michael@0: 
michael@0:     void setFlags(unsigned flags) {
michael@0:         if (fFlags != flags) {
michael@0:             fFlags = flags;
michael@0:             this->updateReader();
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     unsigned getFlags() const {
michael@0:         return fFlags;
michael@0:     }
michael@0: 
michael@0:     void setReader(SkReadBuffer* reader) {
michael@0:         fReader = reader;
michael@0:         this->updateReader();
michael@0:     }
michael@0: 
michael@0:     const SkPaint& paint() const { return fPaint; }
michael@0:     SkPaint* editPaint() { return &fPaint; }
michael@0: 
michael@0:     SkFlattenable* getFlat(unsigned index) const {
michael@0:         if (0 == index) {
michael@0:             return NULL;
michael@0:         }
michael@0:         return fFlatArray[index - 1];
michael@0:     }
michael@0: 
michael@0:     void defFlattenable(PaintFlats pf, int index) {
michael@0:         index--;
michael@0:         SkFlattenable* obj = fReader->readFlattenable(paintflat_to_flattype(pf));
michael@0:         if (fFlatArray.count() == index) {
michael@0:             *fFlatArray.append() = obj;
michael@0:         } else {
michael@0:             SkSafeUnref(fFlatArray[index]);
michael@0:             fFlatArray[index] = obj;
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     void defFactory(const char* name) {
michael@0:         SkFlattenable::Factory factory = SkFlattenable::NameToFactory(name);
michael@0:         if (factory) {
michael@0:             SkASSERT(fFactoryArray.find(factory) < 0);
michael@0:             *fFactoryArray.append() = factory;
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     /**
michael@0:      * Add a bitmap to the array of bitmaps, or replace an existing one.
michael@0:      * This is only used when in cross process mode without a shared heap.
michael@0:      */
michael@0:     void addBitmap(int index) {
michael@0:         SkASSERT(shouldFlattenBitmaps(fFlags));
michael@0:         SkBitmap* bm;
michael@0:         if(fBitmaps.count() == index) {
michael@0:             bm = SkNEW(SkBitmap);
michael@0:             *fBitmaps.append() = bm;
michael@0:         } else {
michael@0:             bm = fBitmaps[index];
michael@0:         }
michael@0:         fReader->readBitmap(bm);
michael@0:     }
michael@0: 
michael@0:     /**
michael@0:      * Override of SkBitmapHeapReader, so that SkReadBuffer can use
michael@0:      * these SkBitmaps for bitmap shaders. Used only in cross process mode
michael@0:      * without a shared heap.
michael@0:      */
michael@0:     virtual SkBitmap* getBitmap(int32_t index) const SK_OVERRIDE {
michael@0:         SkASSERT(shouldFlattenBitmaps(fFlags));
michael@0:         return fBitmaps[index];
michael@0:     }
michael@0: 
michael@0:     /**
michael@0:      * Needed to be a non-abstract subclass of SkBitmapHeapReader.
michael@0:      */
michael@0:     virtual void releaseRef(int32_t) SK_OVERRIDE {}
michael@0: 
michael@0:     void setSharedHeap(SkBitmapHeap* heap) {
michael@0:         SkASSERT(!shouldFlattenBitmaps(fFlags) || NULL == heap);
michael@0:         SkRefCnt_SafeAssign(fSharedHeap, heap);
michael@0:         this->updateReader();
michael@0:     }
michael@0: 
michael@0:     /**
michael@0:      * Access the shared heap. Only used in the case when bitmaps are not
michael@0:      * flattened.
michael@0:      */
michael@0:     SkBitmapHeap* getSharedHeap() const {
michael@0:         SkASSERT(!shouldFlattenBitmaps(fFlags));
michael@0:         return fSharedHeap;
michael@0:     }
michael@0: 
michael@0:     void addTypeface() {
michael@0:         size_t size = fReader->read32();
michael@0:         const void* data = fReader->skip(SkAlign4(size));
michael@0:         SkMemoryStream stream(data, size, false);
michael@0:         *fTypefaces.append() = SkTypeface::Deserialize(&stream);
michael@0:     }
michael@0: 
michael@0:     void setTypeface(SkPaint* paint, unsigned id) {
michael@0:         paint->setTypeface(id ? fTypefaces[id - 1] : NULL);
michael@0:     }
michael@0: 
michael@0: private:
michael@0:     void updateReader() {
michael@0:         if (NULL == fReader) {
michael@0:             return;
michael@0:         }
michael@0:         bool crossProcess = SkToBool(fFlags & SkGPipeWriter::kCrossProcess_Flag);
michael@0:         fReader->setFlags(SkSetClearMask(fReader->getFlags(), crossProcess,
michael@0:                                          SkReadBuffer::kCrossProcess_Flag));
michael@0:         if (crossProcess) {
michael@0:             fReader->setFactoryArray(&fFactoryArray);
michael@0:         } else {
michael@0:             fReader->setFactoryArray(NULL);
michael@0:         }
michael@0: 
michael@0:         if (shouldFlattenBitmaps(fFlags)) {
michael@0:             fReader->setBitmapStorage(this);
michael@0:         } else {
michael@0:             fReader->setBitmapStorage(fSharedHeap);
michael@0:         }
michael@0:     }
michael@0:     SkReadBuffer*             fReader;
michael@0:     SkPaint                   fPaint;
michael@0:     SkTDArray<SkFlattenable*> fFlatArray;
michael@0:     SkTDArray<SkTypeface*>    fTypefaces;
michael@0:     SkTDArray<SkFlattenable::Factory> fFactoryArray;
michael@0:     SkTDArray<SkBitmap*>      fBitmaps;
michael@0:     bool                      fSilent;
michael@0:     // Only used when sharing bitmaps with the writer.
michael@0:     SkBitmapHeap*             fSharedHeap;
michael@0:     unsigned                  fFlags;
michael@0: };
michael@0: 
michael@0: ///////////////////////////////////////////////////////////////////////////////
michael@0: 
michael@0: template <typename T> const T* skip(SkReader32* reader, int count = 1) {
michael@0:     SkASSERT(count >= 0);
michael@0:     size_t size = sizeof(T) * count;
michael@0:     SkASSERT(SkAlign4(size) == size);
michael@0:     return reinterpret_cast<const T*>(reader->skip(size));
michael@0: }
michael@0: 
michael@0: template <typename T> const T* skipAlign(SkReader32* reader, int count = 1) {
michael@0:     SkASSERT(count >= 0);
michael@0:     size_t size = SkAlign4(sizeof(T) * count);
michael@0:     return reinterpret_cast<const T*>(reader->skip(size));
michael@0: }
michael@0: 
michael@0: ///////////////////////////////////////////////////////////////////////////////
michael@0: ///////////////////////////////////////////////////////////////////////////////
michael@0: 
michael@0: static void clipPath_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
michael@0:                         SkGPipeState* state) {
michael@0:     SkPath path;
michael@0:     reader->readPath(&path);
michael@0:     bool doAA = SkToBool(DrawOp_unpackFlags(op32) & kClip_HasAntiAlias_DrawOpFlag);
michael@0:     canvas->clipPath(path, (SkRegion::Op)DrawOp_unpackData(op32), doAA);
michael@0: }
michael@0: 
michael@0: static void clipRegion_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
michael@0:                           SkGPipeState* state) {
michael@0:     SkRegion rgn;
michael@0:     reader->readRegion(&rgn);
michael@0:     canvas->clipRegion(rgn, (SkRegion::Op)DrawOp_unpackData(op32));
michael@0: }
michael@0: 
michael@0: static void clipRect_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
michael@0:                         SkGPipeState* state) {
michael@0:     const SkRect* rect = skip<SkRect>(reader);
michael@0:     bool doAA = SkToBool(DrawOp_unpackFlags(op32) & kClip_HasAntiAlias_DrawOpFlag);
michael@0:     canvas->clipRect(*rect, (SkRegion::Op)DrawOp_unpackData(op32), doAA);
michael@0: }
michael@0: 
michael@0: static void clipRRect_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
michael@0:                          SkGPipeState* state) {
michael@0:     SkRRect rrect;
michael@0:     reader->readRRect(&rrect);
michael@0:     bool doAA = SkToBool(DrawOp_unpackFlags(op32) & kClip_HasAntiAlias_DrawOpFlag);
michael@0:     canvas->clipRRect(rrect, (SkRegion::Op)DrawOp_unpackData(op32), doAA);
michael@0: }
michael@0: 
michael@0: ///////////////////////////////////////////////////////////////////////////////
michael@0: 
michael@0: static void setMatrix_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
michael@0:                       SkGPipeState* state) {
michael@0:     SkMatrix matrix;
michael@0:     reader->readMatrix(&matrix);
michael@0:     canvas->setMatrix(matrix);
michael@0: }
michael@0: 
michael@0: static void concat_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
michael@0:                       SkGPipeState* state) {
michael@0:     SkMatrix matrix;
michael@0:     reader->readMatrix(&matrix);
michael@0:     canvas->concat(matrix);
michael@0: }
michael@0: 
michael@0: static void scale_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
michael@0:                       SkGPipeState* state) {
michael@0:     const SkScalar* param = skip<SkScalar>(reader, 2);
michael@0:     canvas->scale(param[0], param[1]);
michael@0: }
michael@0: 
michael@0: static void skew_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
michael@0:                       SkGPipeState* state) {
michael@0:     const SkScalar* param = skip<SkScalar>(reader, 2);
michael@0:     canvas->skew(param[0], param[1]);
michael@0: }
michael@0: 
michael@0: static void rotate_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
michael@0:                       SkGPipeState* state) {
michael@0:     canvas->rotate(reader->readScalar());
michael@0: }
michael@0: 
michael@0: static void translate_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
michael@0:                       SkGPipeState* state) {
michael@0:     const SkScalar* param = skip<SkScalar>(reader, 2);
michael@0:     canvas->translate(param[0], param[1]);
michael@0: }
michael@0: 
michael@0: ///////////////////////////////////////////////////////////////////////////////
michael@0: 
michael@0: static void save_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
michael@0:                     SkGPipeState* state) {
michael@0:     canvas->save((SkCanvas::SaveFlags)DrawOp_unpackData(op32));
michael@0: }
michael@0: 
michael@0: static void saveLayer_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
michael@0:                          SkGPipeState* state) {
michael@0:     unsigned flags = DrawOp_unpackFlags(op32);
michael@0:     SkCanvas::SaveFlags saveFlags = (SkCanvas::SaveFlags)DrawOp_unpackData(op32);
michael@0: 
michael@0:     const SkRect* bounds = NULL;
michael@0:     if (flags & kSaveLayer_HasBounds_DrawOpFlag) {
michael@0:         bounds = skip<SkRect>(reader);
michael@0:     }
michael@0:     const SkPaint* paint = NULL;
michael@0:     if (flags & kSaveLayer_HasPaint_DrawOpFlag) {
michael@0:         paint = &state->paint();
michael@0:     }
michael@0:     canvas->saveLayer(bounds, paint, saveFlags);
michael@0: }
michael@0: 
michael@0: static void restore_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
michael@0:                        SkGPipeState* state) {
michael@0:     canvas->restore();
michael@0: }
michael@0: 
michael@0: ///////////////////////////////////////////////////////////////////////////////
michael@0: 
michael@0: static void drawClear_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
michael@0:                          SkGPipeState* state) {
michael@0:     SkColor color = 0;
michael@0:     if (DrawOp_unpackFlags(op32) & kClear_HasColor_DrawOpFlag) {
michael@0:         color = reader->readU32();
michael@0:     }
michael@0:     canvas->clear(color);
michael@0: }
michael@0: 
michael@0: static void drawPaint_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
michael@0:                          SkGPipeState* state) {
michael@0:     if (state->shouldDraw()) {
michael@0:         canvas->drawPaint(state->paint());
michael@0:     }
michael@0: }
michael@0: 
michael@0: static void drawPoints_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
michael@0:                           SkGPipeState* state) {
michael@0:     SkCanvas::PointMode mode = (SkCanvas::PointMode)DrawOp_unpackFlags(op32);
michael@0:     size_t count = reader->readU32();
michael@0:     const SkPoint* pts = skip<SkPoint>(reader, count);
michael@0:     if (state->shouldDraw()) {
michael@0:         canvas->drawPoints(mode, count, pts, state->paint());
michael@0:     }
michael@0: }
michael@0: 
michael@0: static void drawOval_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
michael@0:                         SkGPipeState* state) {
michael@0:     const SkRect* rect = skip<SkRect>(reader);
michael@0:     if (state->shouldDraw()) {
michael@0:         canvas->drawOval(*rect, state->paint());
michael@0:     }
michael@0: }
michael@0: 
michael@0: static void drawRect_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
michael@0:                         SkGPipeState* state) {
michael@0:     const SkRect* rect = skip<SkRect>(reader);
michael@0:     if (state->shouldDraw()) {
michael@0:         canvas->drawRect(*rect, state->paint());
michael@0:     }
michael@0: }
michael@0: 
michael@0: static void drawRRect_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
michael@0:                          SkGPipeState* state) {
michael@0:     SkRRect rrect;
michael@0:     reader->readRRect(&rrect);
michael@0:     if (state->shouldDraw()) {
michael@0:         canvas->drawRRect(rrect, state->paint());
michael@0:     }
michael@0: }
michael@0: 
michael@0: static void drawDRRect_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
michael@0:                           SkGPipeState* state) {
michael@0:     SkRRect outer, inner;
michael@0:     reader->readRRect(&outer);
michael@0:     reader->readRRect(&inner);
michael@0:     if (state->shouldDraw()) {
michael@0:         canvas->drawDRRect(outer, inner, state->paint());
michael@0:     }
michael@0: }
michael@0: 
michael@0: static void drawPath_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
michael@0:                         SkGPipeState* state) {
michael@0:     SkPath path;
michael@0:     reader->readPath(&path);
michael@0:     if (state->shouldDraw()) {
michael@0:         canvas->drawPath(path, state->paint());
michael@0:     }
michael@0: }
michael@0: 
michael@0: static void drawVertices_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
michael@0:                             SkGPipeState* state) {
michael@0:     unsigned flags = DrawOp_unpackFlags(op32);
michael@0: 
michael@0:     SkCanvas::VertexMode vmode = (SkCanvas::VertexMode)reader->readU32();
michael@0:     int vertexCount = reader->readU32();
michael@0:     const SkPoint* verts = skip<SkPoint>(reader, vertexCount);
michael@0: 
michael@0:     const SkPoint* texs = NULL;
michael@0:     if (flags & kDrawVertices_HasTexs_DrawOpFlag) {
michael@0:         texs = skip<SkPoint>(reader, vertexCount);
michael@0:     }
michael@0: 
michael@0:     const SkColor* colors = NULL;
michael@0:     if (flags & kDrawVertices_HasColors_DrawOpFlag) {
michael@0:         colors = skip<SkColor>(reader, vertexCount);
michael@0:     }
michael@0: 
michael@0:     SkAutoTUnref<SkXfermode> xfer;
michael@0:     if (flags & kDrawVertices_HasXfermode_DrawOpFlag) {
michael@0:         SkXfermode::Mode mode = (SkXfermode::Mode)reader->readU32();
michael@0:         xfer.reset(SkXfermode::Create(mode));
michael@0:     }
michael@0: 
michael@0:     int indexCount = 0;
michael@0:     const uint16_t* indices = NULL;
michael@0:     if (flags & kDrawVertices_HasIndices_DrawOpFlag) {
michael@0:         indexCount = reader->readU32();
michael@0:         indices = skipAlign<uint16_t>(reader, indexCount);
michael@0:     }
michael@0:     if (state->shouldDraw()) {
michael@0:         canvas->drawVertices(vmode, vertexCount, verts, texs, colors, xfer,
michael@0:                              indices, indexCount, state->paint());
michael@0:     }
michael@0: }
michael@0: 
michael@0: ///////////////////////////////////////////////////////////////////////////////
michael@0: 
michael@0: static void drawText_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
michael@0:                         SkGPipeState* state) {
michael@0:     size_t len = reader->readU32();
michael@0:     const void* text = reader->skip(SkAlign4(len));
michael@0:     const SkScalar* xy = skip<SkScalar>(reader, 2);
michael@0:     if (state->shouldDraw()) {
michael@0:         canvas->drawText(text, len, xy[0], xy[1], state->paint());
michael@0:     }
michael@0: }
michael@0: 
michael@0: static void drawPosText_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
michael@0:                         SkGPipeState* state) {
michael@0:     size_t len = reader->readU32();
michael@0:     const void* text = reader->skip(SkAlign4(len));
michael@0:     size_t posCount = reader->readU32();    // compute by our writer
michael@0:     const SkPoint* pos = skip<SkPoint>(reader, posCount);
michael@0:     if (state->shouldDraw()) {
michael@0:         canvas->drawPosText(text, len, pos, state->paint());
michael@0:     }
michael@0: }
michael@0: 
michael@0: static void drawPosTextH_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
michael@0:                         SkGPipeState* state) {
michael@0:     size_t len = reader->readU32();
michael@0:     const void* text = reader->skip(SkAlign4(len));
michael@0:     size_t posCount = reader->readU32();    // compute by our writer
michael@0:     const SkScalar* xpos = skip<SkScalar>(reader, posCount);
michael@0:     SkScalar constY = reader->readScalar();
michael@0:     if (state->shouldDraw()) {
michael@0:         canvas->drawPosTextH(text, len, xpos, constY, state->paint());
michael@0:     }
michael@0: }
michael@0: 
michael@0: static void drawTextOnPath_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
michael@0:                               SkGPipeState* state) {
michael@0:     size_t len = reader->readU32();
michael@0:     const void* text = reader->skip(SkAlign4(len));
michael@0: 
michael@0:     SkPath path;
michael@0:     reader->readPath(&path);
michael@0: 
michael@0:     SkMatrix matrixStorage;
michael@0:     const SkMatrix* matrix = NULL;
michael@0:     if (DrawOp_unpackFlags(op32) & kDrawTextOnPath_HasMatrix_DrawOpFlag) {
michael@0:         reader->readMatrix(&matrixStorage);
michael@0:         matrix = &matrixStorage;
michael@0:     }
michael@0:     if (state->shouldDraw()) {
michael@0:         canvas->drawTextOnPath(text, len, path, matrix, state->paint());
michael@0:     }
michael@0: }
michael@0: 
michael@0: ///////////////////////////////////////////////////////////////////////////////
michael@0: 
michael@0: class BitmapHolder : SkNoncopyable {
michael@0: public:
michael@0:     BitmapHolder(SkReader32* reader, uint32_t op32, SkGPipeState* state);
michael@0:     ~BitmapHolder() {
michael@0:         if (fHeapEntry != NULL) {
michael@0:             fHeapEntry->releaseRef();
michael@0:         }
michael@0:     }
michael@0:     const SkBitmap* getBitmap() {
michael@0:         return fBitmap;
michael@0:     }
michael@0: private:
michael@0:     SkBitmapHeapEntry* fHeapEntry;
michael@0:     const SkBitmap*    fBitmap;
michael@0:     SkBitmap           fBitmapStorage;
michael@0: };
michael@0: 
michael@0: BitmapHolder::BitmapHolder(SkReader32* reader, uint32_t op32,
michael@0:                            SkGPipeState* state) {
michael@0:     const unsigned flags = state->getFlags();
michael@0:     const unsigned index = DrawOp_unpackData(op32);
michael@0:     if (shouldFlattenBitmaps(flags)) {
michael@0:         fHeapEntry = NULL;
michael@0:         fBitmap = state->getBitmap(index);
michael@0:     } else {
michael@0:         SkBitmapHeapEntry* entry = state->getSharedHeap()->getEntry(index);
michael@0:         if (SkToBool(flags & SkGPipeWriter::kSimultaneousReaders_Flag)) {
michael@0:             // Make a shallow copy for thread safety. Each thread will point to the same SkPixelRef,
michael@0:             // which is thread safe.
michael@0:             fBitmapStorage = *entry->getBitmap();
michael@0:             fBitmap = &fBitmapStorage;
michael@0:             // Release the ref on the bitmap now, since we made our own copy.
michael@0:             entry->releaseRef();
michael@0:             fHeapEntry = NULL;
michael@0:         } else {
michael@0:             SkASSERT(!shouldFlattenBitmaps(flags));
michael@0:             SkASSERT(!SkToBool(flags & SkGPipeWriter::kSimultaneousReaders_Flag));
michael@0:             fHeapEntry = entry;
michael@0:             fBitmap = fHeapEntry->getBitmap();
michael@0:         }
michael@0:     }
michael@0: }
michael@0: 
michael@0: static void drawBitmap_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
michael@0:                           SkGPipeState* state) {
michael@0:     BitmapHolder holder(reader, op32, state);
michael@0:     bool hasPaint = SkToBool(DrawOp_unpackFlags(op32) & kDrawBitmap_HasPaint_DrawOpFlag);
michael@0:     SkScalar left = reader->readScalar();
michael@0:     SkScalar top = reader->readScalar();
michael@0:     const SkBitmap* bitmap = holder.getBitmap();
michael@0:     if (state->shouldDraw()) {
michael@0:         canvas->drawBitmap(*bitmap, left, top, hasPaint ? &state->paint() : NULL);
michael@0:     }
michael@0: }
michael@0: 
michael@0: static void drawBitmapMatrix_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
michael@0:                                 SkGPipeState* state) {
michael@0:     BitmapHolder holder(reader, op32, state);
michael@0:     bool hasPaint = SkToBool(DrawOp_unpackFlags(op32) & kDrawBitmap_HasPaint_DrawOpFlag);
michael@0:     SkMatrix matrix;
michael@0:     reader->readMatrix(&matrix);
michael@0:     const SkBitmap* bitmap = holder.getBitmap();
michael@0:     if (state->shouldDraw()) {
michael@0:         canvas->drawBitmapMatrix(*bitmap, matrix,
michael@0:                                  hasPaint ? &state->paint() : NULL);
michael@0:     }
michael@0: }
michael@0: 
michael@0: static void drawBitmapNine_rp(SkCanvas* canvas, SkReader32* reader,
michael@0:                               uint32_t op32, SkGPipeState* state) {
michael@0:     BitmapHolder holder(reader, op32, state);
michael@0:     bool hasPaint = SkToBool(DrawOp_unpackFlags(op32) & kDrawBitmap_HasPaint_DrawOpFlag);
michael@0:     const SkIRect* center = skip<SkIRect>(reader);
michael@0:     const SkRect* dst = skip<SkRect>(reader);
michael@0:     const SkBitmap* bitmap = holder.getBitmap();
michael@0:     if (state->shouldDraw()) {
michael@0:         canvas->drawBitmapNine(*bitmap, *center, *dst,
michael@0:                                hasPaint ? &state->paint() : NULL);
michael@0:     }
michael@0: }
michael@0: 
michael@0: static void drawBitmapRect_rp(SkCanvas* canvas, SkReader32* reader,
michael@0:                               uint32_t op32, SkGPipeState* state) {
michael@0:     BitmapHolder holder(reader, op32, state);
michael@0:     unsigned flags = DrawOp_unpackFlags(op32);
michael@0:     bool hasPaint = SkToBool(flags & kDrawBitmap_HasPaint_DrawOpFlag);
michael@0:     bool hasSrc = SkToBool(flags & kDrawBitmap_HasSrcRect_DrawOpFlag);
michael@0:     const SkRect* src;
michael@0:     if (hasSrc) {
michael@0:         src = skip<SkRect>(reader);
michael@0:     } else {
michael@0:         src = NULL;
michael@0:     }
michael@0:     SkCanvas::DrawBitmapRectFlags dbmrFlags = SkCanvas::kNone_DrawBitmapRectFlag;
michael@0:     if (flags & kDrawBitmap_Bleed_DrawOpFlag) {
michael@0:         dbmrFlags = (SkCanvas::DrawBitmapRectFlags)(dbmrFlags|SkCanvas::kBleed_DrawBitmapRectFlag);
michael@0:     }
michael@0:     const SkRect* dst = skip<SkRect>(reader);
michael@0:     const SkBitmap* bitmap = holder.getBitmap();
michael@0:     if (state->shouldDraw()) {
michael@0:         canvas->drawBitmapRectToRect(*bitmap, src, *dst,
michael@0:                                      hasPaint ? &state->paint() : NULL, dbmrFlags);
michael@0:     }
michael@0: }
michael@0: 
michael@0: static void drawSprite_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
michael@0:                           SkGPipeState* state) {
michael@0:     BitmapHolder holder(reader, op32, state);
michael@0:     bool hasPaint = SkToBool(DrawOp_unpackFlags(op32) & kDrawBitmap_HasPaint_DrawOpFlag);
michael@0:     const SkIPoint* point = skip<SkIPoint>(reader);
michael@0:     const SkBitmap* bitmap = holder.getBitmap();
michael@0:     if (state->shouldDraw()) {
michael@0:         canvas->drawSprite(*bitmap, point->fX, point->fY, hasPaint ? &state->paint() : NULL);
michael@0:     }
michael@0: }
michael@0: 
michael@0: ///////////////////////////////////////////////////////////////////////////////
michael@0: 
michael@0: static void drawData_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
michael@0:                         SkGPipeState* state) {
michael@0:     // since we don't have a paint, we can use data for our (small) sizes
michael@0:     size_t size = DrawOp_unpackData(op32);
michael@0:     if (0 == size) {
michael@0:         size = reader->readU32();
michael@0:     }
michael@0:     const void* data = reader->skip(SkAlign4(size));
michael@0:     if (state->shouldDraw()) {
michael@0:         canvas->drawData(data, size);
michael@0:     }
michael@0: }
michael@0: 
michael@0: static void drawPicture_rp(SkCanvas* canvas, SkReader32* reader, uint32_t op32,
michael@0:                            SkGPipeState* state) {
michael@0:     UNIMPLEMENTED
michael@0: }
michael@0: 
michael@0: ///////////////////////////////////////////////////////////////////////////////
michael@0: 
michael@0: static void paintOp_rp(SkCanvas*, SkReader32* reader, uint32_t op32,
michael@0:                        SkGPipeState* state) {
michael@0:     size_t offset = reader->offset();
michael@0:     size_t stop = offset + PaintOp_unpackData(op32);
michael@0:     SkPaint* p = state->editPaint();
michael@0: 
michael@0:     do {
michael@0:         uint32_t p32 = reader->readU32();
michael@0:         unsigned op = PaintOp_unpackOp(p32);
michael@0:         unsigned data = PaintOp_unpackData(p32);
michael@0: 
michael@0: //        SkDebugf(" read %08X op=%d flags=%d data=%d\n", p32, op, done, data);
michael@0: 
michael@0:         switch (op) {
michael@0:             case kReset_PaintOp: p->reset(); break;
michael@0:             case kFlags_PaintOp: p->setFlags(data); break;
michael@0:             case kColor_PaintOp: p->setColor(reader->readU32()); break;
michael@0:             case kStyle_PaintOp: p->setStyle((SkPaint::Style)data); break;
michael@0:             case kJoin_PaintOp: p->setStrokeJoin((SkPaint::Join)data); break;
michael@0:             case kCap_PaintOp: p->setStrokeCap((SkPaint::Cap)data); break;
michael@0:             case kWidth_PaintOp: p->setStrokeWidth(reader->readScalar()); break;
michael@0:             case kMiter_PaintOp: p->setStrokeMiter(reader->readScalar()); break;
michael@0:             case kEncoding_PaintOp:
michael@0:                 p->setTextEncoding((SkPaint::TextEncoding)data);
michael@0:                 break;
michael@0:             case kHinting_PaintOp: p->setHinting((SkPaint::Hinting)data); break;
michael@0:             case kAlign_PaintOp: p->setTextAlign((SkPaint::Align)data); break;
michael@0:             case kTextSize_PaintOp: p->setTextSize(reader->readScalar()); break;
michael@0:             case kTextScaleX_PaintOp: p->setTextScaleX(reader->readScalar()); break;
michael@0:             case kTextSkewX_PaintOp: p->setTextSkewX(reader->readScalar()); break;
michael@0: 
michael@0:             case kFlatIndex_PaintOp: {
michael@0:                 PaintFlats pf = (PaintFlats)PaintOp_unpackFlags(p32);
michael@0:                 unsigned index = data;
michael@0:                 set_paintflat(p, state->getFlat(index), pf);
michael@0:                 break;
michael@0:             }
michael@0: 
michael@0:             case kTypeface_PaintOp:
michael@0:                 SkASSERT(SkToBool(state->getFlags() &
michael@0:                                   SkGPipeWriter::kCrossProcess_Flag));
michael@0:                 state->setTypeface(p, data); break;
michael@0:             default: SkDEBUGFAIL("bad paintop"); return;
michael@0:         }
michael@0:         SkASSERT(reader->offset() <= stop);
michael@0:     } while (reader->offset() < stop);
michael@0: }
michael@0: 
michael@0: static void typeface_rp(SkCanvas*, SkReader32* reader, uint32_t,
michael@0:                         SkGPipeState* state) {
michael@0:     SkASSERT(!SkToBool(state->getFlags() & SkGPipeWriter::kCrossProcess_Flag));
michael@0:     SkPaint* p = state->editPaint();
michael@0:     p->setTypeface(static_cast<SkTypeface*>(reader->readPtr()));
michael@0: }
michael@0: 
michael@0: static void annotation_rp(SkCanvas*, SkReader32* reader, uint32_t op32,
michael@0:                           SkGPipeState* state) {
michael@0:     SkPaint* p = state->editPaint();
michael@0: 
michael@0:     const size_t size = DrawOp_unpackData(op32);
michael@0:     if (size > 0) {
michael@0:         SkReadBuffer buffer(reader->skip(size), size);
michael@0:         p->setAnnotation(SkAnnotation::Create(buffer))->unref();
michael@0:         SkASSERT(buffer.offset() == size);
michael@0:     } else {
michael@0:         p->setAnnotation(NULL);
michael@0:     }
michael@0: }
michael@0: 
michael@0: ///////////////////////////////////////////////////////////////////////////////
michael@0: 
michael@0: static void def_Typeface_rp(SkCanvas*, SkReader32*, uint32_t, SkGPipeState* state) {
michael@0:     state->addTypeface();
michael@0: }
michael@0: 
michael@0: static void def_PaintFlat_rp(SkCanvas*, SkReader32*, uint32_t op32,
michael@0:                              SkGPipeState* state) {
michael@0:     PaintFlats pf = (PaintFlats)DrawOp_unpackFlags(op32);
michael@0:     unsigned index = DrawOp_unpackData(op32);
michael@0:     state->defFlattenable(pf, index);
michael@0: }
michael@0: 
michael@0: static void def_Bitmap_rp(SkCanvas*, SkReader32*, uint32_t op32,
michael@0:                           SkGPipeState* state) {
michael@0:     unsigned index = DrawOp_unpackData(op32);
michael@0:     state->addBitmap(index);
michael@0: }
michael@0: 
michael@0: static void def_Factory_rp(SkCanvas*, SkReader32* reader, uint32_t,
michael@0:                            SkGPipeState* state) {
michael@0:     state->defFactory(reader->readString());
michael@0: }
michael@0: 
michael@0: ///////////////////////////////////////////////////////////////////////////////
michael@0: 
michael@0: static void skip_rp(SkCanvas*, SkReader32* reader, uint32_t op32, SkGPipeState*) {
michael@0:     size_t bytes = DrawOp_unpackData(op32);
michael@0:     (void)reader->skip(bytes);
michael@0: }
michael@0: 
michael@0: static void reportFlags_rp(SkCanvas*, SkReader32*, uint32_t op32,
michael@0:                            SkGPipeState* state) {
michael@0:     unsigned flags = DrawOp_unpackFlags(op32);
michael@0:     state->setFlags(flags);
michael@0: }
michael@0: 
michael@0: static void shareBitmapHeap_rp(SkCanvas*, SkReader32* reader, uint32_t,
michael@0:                            SkGPipeState* state) {
michael@0:     state->setSharedHeap(static_cast<SkBitmapHeap*>(reader->readPtr()));
michael@0: }
michael@0: 
michael@0: static void done_rp(SkCanvas*, SkReader32*, uint32_t, SkGPipeState*) {}
michael@0: 
michael@0: typedef void (*ReadProc)(SkCanvas*, SkReader32*, uint32_t op32, SkGPipeState*);
michael@0: 
michael@0: static const ReadProc gReadTable[] = {
michael@0:     skip_rp,
michael@0:     clipPath_rp,
michael@0:     clipRegion_rp,
michael@0:     clipRect_rp,
michael@0:     clipRRect_rp,
michael@0:     concat_rp,
michael@0:     drawBitmap_rp,
michael@0:     drawBitmapMatrix_rp,
michael@0:     drawBitmapNine_rp,
michael@0:     drawBitmapRect_rp,
michael@0:     drawClear_rp,
michael@0:     drawData_rp,
michael@0:     drawDRRect_rp,
michael@0:     drawOval_rp,
michael@0:     drawPaint_rp,
michael@0:     drawPath_rp,
michael@0:     drawPicture_rp,
michael@0:     drawPoints_rp,
michael@0:     drawPosText_rp,
michael@0:     drawPosTextH_rp,
michael@0:     drawRect_rp,
michael@0:     drawRRect_rp,
michael@0:     drawSprite_rp,
michael@0:     drawText_rp,
michael@0:     drawTextOnPath_rp,
michael@0:     drawVertices_rp,
michael@0:     restore_rp,
michael@0:     rotate_rp,
michael@0:     save_rp,
michael@0:     saveLayer_rp,
michael@0:     scale_rp,
michael@0:     setMatrix_rp,
michael@0:     skew_rp,
michael@0:     translate_rp,
michael@0: 
michael@0:     paintOp_rp,
michael@0:     typeface_rp,
michael@0:     annotation_rp,
michael@0: 
michael@0:     def_Typeface_rp,
michael@0:     def_PaintFlat_rp,
michael@0:     def_Bitmap_rp,
michael@0:     def_Factory_rp,
michael@0: 
michael@0:     reportFlags_rp,
michael@0:     shareBitmapHeap_rp,
michael@0:     done_rp
michael@0: };
michael@0: 
michael@0: ///////////////////////////////////////////////////////////////////////////////
michael@0: 
michael@0: SkGPipeState::SkGPipeState()
michael@0:     : fReader(0)
michael@0:     , fSilent(false)
michael@0:     , fSharedHeap(NULL)
michael@0:     , fFlags(0) {
michael@0: 
michael@0: }
michael@0: 
michael@0: SkGPipeState::~SkGPipeState() {
michael@0:     fTypefaces.safeUnrefAll();
michael@0:     fFlatArray.safeUnrefAll();
michael@0:     fBitmaps.deleteAll();
michael@0:     SkSafeUnref(fSharedHeap);
michael@0: }
michael@0: 
michael@0: ///////////////////////////////////////////////////////////////////////////////
michael@0: 
michael@0: #include "SkGPipe.h"
michael@0: 
michael@0: SkGPipeReader::SkGPipeReader() {
michael@0:     fCanvas = NULL;
michael@0:     fState = NULL;
michael@0:     fProc = NULL;
michael@0: }
michael@0: 
michael@0: SkGPipeReader::SkGPipeReader(SkCanvas* target) {
michael@0:     fCanvas = NULL;
michael@0:     this->setCanvas(target);
michael@0:     fState = NULL;
michael@0:     fProc = NULL;
michael@0: }
michael@0: 
michael@0: void SkGPipeReader::setCanvas(SkCanvas *target) {
michael@0:     SkRefCnt_SafeAssign(fCanvas, target);
michael@0: }
michael@0: 
michael@0: SkGPipeReader::~SkGPipeReader() {
michael@0:     SkSafeUnref(fCanvas);
michael@0:     delete fState;
michael@0: }
michael@0: 
michael@0: SkGPipeReader::Status SkGPipeReader::playback(const void* data, size_t length,
michael@0:                                               uint32_t playbackFlags, size_t* bytesRead) {
michael@0:     if (NULL == fCanvas) {
michael@0:         return kError_Status;
michael@0:     }
michael@0: 
michael@0:     if (NULL == fState) {
michael@0:         fState = new SkGPipeState;
michael@0:     }
michael@0: 
michael@0:     fState->setSilent(playbackFlags & kSilent_PlaybackFlag);
michael@0: 
michael@0:     SkASSERT(SK_ARRAY_COUNT(gReadTable) == (kDone_DrawOp + 1));
michael@0: 
michael@0:     const ReadProc* table = gReadTable;
michael@0:     SkReadBuffer reader(data, length);
michael@0:     reader.setBitmapDecoder(fProc);
michael@0:     SkCanvas* canvas = fCanvas;
michael@0:     Status status = kEOF_Status;
michael@0: 
michael@0:     fState->setReader(&reader);
michael@0:     while (!reader.eof()) {
michael@0:         uint32_t op32 = reader.readUInt();
michael@0:         unsigned op = DrawOp_unpackOp(op32);
michael@0:         // SkDEBUGCODE(DrawOps drawOp = (DrawOps)op;)
michael@0: 
michael@0:         if (op >= SK_ARRAY_COUNT(gReadTable)) {
michael@0:             SkDebugf("---- bad op during GPipeState::playback\n");
michael@0:             status = kError_Status;
michael@0:             break;
michael@0:         }
michael@0:         if (kDone_DrawOp == op) {
michael@0:             status = kDone_Status;
michael@0:             break;
michael@0:         }
michael@0:         table[op](canvas, reader.getReader32(), op32, fState);
michael@0:         if ((playbackFlags & kReadAtom_PlaybackFlag) &&
michael@0:             (table[op] != paintOp_rp &&
michael@0:              table[op] != def_Typeface_rp &&
michael@0:              table[op] != def_PaintFlat_rp &&
michael@0:              table[op] != def_Bitmap_rp
michael@0:              )) {
michael@0:                 status = kReadAtom_Status;
michael@0:                 break;
michael@0:             }
michael@0:     }
michael@0: 
michael@0:     if (bytesRead) {
michael@0:         *bytesRead = reader.offset();
michael@0:     }
michael@0:     return status;
michael@0: }