src/core/SkPictureReplacementPlayback.cpp

/*
 * Copyright 2014 Google Inc.
 * 
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */

#include "SkCanvas.h"
#include "SkPicture.h"
#include "SkPictureData.h"
#include "SkPictureReplacementPlayback.h"


SkPictureReplacementPlayback::PlaybackReplacements::ReplacementInfo*
SkPictureReplacementPlayback::PlaybackReplacements::push() {
    SkDEBUGCODE(this->validate());
    return fReplacements.push();
}

void SkPictureReplacementPlayback::PlaybackReplacements::freeAll() {
    for (int i = 0; i < fReplacements.count(); ++i) {
        SkDELETE(fReplacements[i].fBM);
    }
    fReplacements.reset();
}

#ifdef SK_DEBUG
void SkPictureReplacementPlayback::PlaybackReplacements::validate() const {
    // Check that the ranges are monotonically increasing and non-overlapping
    if (fReplacements.count() > 0) {
        SkASSERT(fReplacements[0].fStart < fReplacements[0].fStop);

        for (int i = 1; i < fReplacements.count(); ++i) {
            SkASSERT(fReplacements[i].fStart < fReplacements[i].fStop);
            SkASSERT(fReplacements[i - 1].fStop < fReplacements[i].fStart);
        }
    }
}
#endif

// TODO: Replace with hash or pass in "lastLookedUp" hint
SkPictureReplacementPlayback::PlaybackReplacements::ReplacementInfo*
SkPictureReplacementPlayback::PlaybackReplacements::lookupByStart(size_t start) {
    SkDEBUGCODE(this->validate());
    for (int i = 0; i < fReplacements.count(); ++i) {
        if (start == fReplacements[i].fStart) {
            return &fReplacements[i];
        } else if (start < fReplacements[i].fStart) {
            return NULL;  // the ranges are monotonically increasing and non-overlapping
        }
    }

    return NULL;
}

bool SkPictureReplacementPlayback::replaceOps(SkPictureStateTree::Iterator* iter,
                                              SkReader32* reader,
                                              SkCanvas* canvas,
                                              const SkMatrix& initialMatrix) {
    if (NULL != fReplacements) {
        // Potentially replace a block of operations with a single drawBitmap call
        PlaybackReplacements::ReplacementInfo* temp =
                                  fReplacements->lookupByStart(reader->offset());
        if (NULL != temp) {
            SkASSERT(NULL != temp->fBM);
            SkASSERT(NULL != temp->fPaint);
            canvas->save();
            canvas->setMatrix(initialMatrix);
            SkRect src = SkRect::Make(temp->fSrcRect);
            SkRect dst = SkRect::MakeXYWH(temp->fPos.fX, temp->fPos.fY,
                                          temp->fSrcRect.width(),
                                          temp->fSrcRect.height());
            canvas->drawBitmapRectToRect(*temp->fBM, &src, dst, temp->fPaint);
            canvas->restore();

            if (iter->isValid()) {
                // This save is needed since the BBH will automatically issue
                // a restore to balanced the saveLayer we're skipping
                canvas->save();

                // At this point we know that the PictureStateTree was aiming
                // for some draw op within temp's saveLayer (although potentially
                // in a separate saveLayer nested inside it).
                // We need to skip all the operations inside temp's range
                // along with all the associated state changes but update
                // the state tree to the first operation outside temp's range.

                uint32_t skipTo;
                do {
                    skipTo = iter->nextDraw();
                    if (SkPictureStateTree::Iterator::kDrawComplete == skipTo) {
                        break;
                    }

                    if (skipTo <= temp->fStop) {
                        reader->setOffset(skipTo);
                        uint32_t size;
                        DrawType op = ReadOpAndSize(reader, &size);
                        // Since we are relying on the normal SkPictureStateTree
                        // playback we need to convert any nested saveLayer calls
                        // it may issue into saves (so that all its internal
                        // restores will be balanced).
                        if (SAVE_LAYER == op) {
                            canvas->save();
                        }
                    }
                } while (skipTo <= temp->fStop);

                if (SkPictureStateTree::Iterator::kDrawComplete == skipTo) {
                    reader->setOffset(reader->size());      // skip to end
                    return true;
                }

                reader->setOffset(skipTo);
            } else {
                reader->setOffset(temp->fStop);
                uint32_t size;
                SkDEBUGCODE(DrawType op = ) ReadOpAndSize(reader, &size);
                SkASSERT(RESTORE == op);
            }

            return true;
        }
    }

    return false;
}

void SkPictureReplacementPlayback::draw(SkCanvas* canvas, SkDrawPictureCallback* callback) {
    AutoResetOpID aroi(this);
    SkASSERT(0 == fCurOffset);

    SkPictureStateTree::Iterator it;

    if (!this->initIterator(&it, canvas, fActiveOpsList)) {
        return;  // nothing to draw
    }

    SkReader32 reader(fPictureData->opData()->bytes(), fPictureData->opData()->size());

    StepIterator(&it, &reader);

    // Record this, so we can concat w/ it if we encounter a setMatrix()
    SkMatrix initialMatrix = canvas->getTotalMatrix();

    SkAutoCanvasRestore acr(canvas, false);

    while (!reader.eof()) {
        if (NULL != callback && callback->abortDrawing()) {
            return;
        }

        if (this->replaceOps(&it, &reader, canvas, initialMatrix)) {
            continue;
        }

        fCurOffset = reader.offset();
        uint32_t size;
        DrawType op = ReadOpAndSize(&reader, &size);
        if (NOOP == op) {
            // NOOPs are to be ignored - do not propagate them any further
            SkipIterTo(&it, &reader, fCurOffset + size);
            continue;
        }

        this->handleOp(&reader, op, size, canvas, initialMatrix);

        StepIterator(&it, &reader);
    }
}