Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit eecff56f authored by Florin Malita's avatar Florin Malita
Browse files

Add internal Canvas save flags 

Skia's SkCanvas::SaveFlags are being deprecated.  This CL introduces
the equivalent android::SaveFlags, converts all internal clients to
the new enum, and switches the saveLayer glue to the
SaveLayerRec-based API.

Change-Id: Icb1785f4e7c0f652b1f04b34a1e3ccb063c408f3
parent 36c297f4

core/jni/android_graphics_Canvas.cpp

+5 −5
Original line number Diff line number Diff line
@@ -86,20 +86,20 @@ static jint getSaveCount(JNIEnv*, jobject, jlong canvasHandle) { 
}



static jint save(JNIEnv*, jobject, jlong canvasHandle, jint flagsHandle) {

    SkCanvas::SaveFlags flags = static_cast<SkCanvas::SaveFlags>(flagsHandle);

    SaveFlags::Flags flags = static_cast<SaveFlags::Flags>(flagsHandle);

    return static_cast<jint>(get_canvas(canvasHandle)->save(flags));

}



static jint saveLayer(JNIEnv* env, jobject, jlong canvasHandle, jfloat l, jfloat t,

                      jfloat r, jfloat b, jlong paintHandle, jint flagsHandle) {

    Paint* paint  = reinterpret_cast<Paint*>(paintHandle);

    SkCanvas::SaveFlags flags = static_cast<SkCanvas::SaveFlags>(flagsHandle);

    SaveFlags::Flags flags = static_cast<SaveFlags::Flags>(flagsHandle);

    return static_cast<jint>(get_canvas(canvasHandle)->saveLayer(l, t, r, b, paint, flags));

}



static jint saveLayerAlpha(JNIEnv* env, jobject, jlong canvasHandle, jfloat l, jfloat t,

                           jfloat r, jfloat b, jint alpha, jint flagsHandle) {

    SkCanvas::SaveFlags flags = static_cast<SkCanvas::SaveFlags>(flagsHandle);

    SaveFlags::Flags flags = static_cast<SaveFlags::Flags>(flagsHandle);

    return static_cast<jint>(get_canvas(canvasHandle)->saveLayerAlpha(l, t, r, b, alpha, flags));

}
@@ -351,7 +351,7 @@ static void drawNinePatch(JNIEnv* env, jobject, jlong canvasHandle, jlong bitmap 
    if (CC_LIKELY(dstDensity == srcDensity || dstDensity == 0 || srcDensity == 0)) {

        canvas->drawNinePatch(skiaBitmap, *chunk, left, top, right, bottom, paint);

    } else {

        canvas->save(SkCanvas::kMatrixClip_SaveFlag);

        canvas->save(SaveFlags::MatrixClip);



        SkScalar scale = dstDensity / (float)srcDensity;

        canvas->translate(left, top);
@@ -390,7 +390,7 @@ static void drawBitmap(JNIEnv* env, jobject jcanvas, jlong canvasHandle, jobject 
            canvas->drawBitmap(bitmap, left, top, paint);

        }

    } else {

        canvas->save(SkCanvas::kMatrixClip_SaveFlag);

        canvas->save(SaveFlags::MatrixClip);

        SkScalar scale = canvasDensity / (float)bitmapDensity;

        canvas->translate(left, top);

        canvas->scale(scale, scale);

libs/hwui/Canvas.h

+20 −3
Original line number Diff line number Diff line
@@ -27,6 +27,22 @@ 


namespace android {



namespace SaveFlags {



// These must match the corresponding Canvas API constants.

enum {

    Matrix        = 0x01,

    Clip          = 0x02,

    HasAlphaLayer = 0x04,

    ClipToLayer   = 0x10,



    // Helper constant

    MatrixClip    = Matrix | Clip,

};

typedef uint32_t Flags;



} // namespace SaveFlags



class ANDROID_API Canvas {

public:

    virtual ~Canvas() {};
@@ -70,16 +86,17 @@ public: 
// ----------------------------------------------------------------------------

// Canvas state operations

// ----------------------------------------------------------------------------



    // Save (layer)

    virtual int getSaveCount() const = 0;

    virtual int save(SkCanvas::SaveFlags flags) = 0;

    virtual int save(SaveFlags::Flags flags) = 0;

    virtual void restore() = 0;

    virtual void restoreToCount(int saveCount) = 0;



    virtual int saveLayer(float left, float top, float right, float bottom,

                const SkPaint* paint, SkCanvas::SaveFlags flags) = 0;

                const SkPaint* paint, SaveFlags::Flags flags) = 0;

    virtual int saveLayerAlpha(float left, float top, float right, float bottom,

            int alpha, SkCanvas::SaveFlags flags) = 0;

            int alpha, SaveFlags::Flags flags) = 0;



    // Matrix

    virtual void getMatrix(SkMatrix* outMatrix) const = 0;

libs/hwui/CanvasState.cpp

+3 −6
Original line number Diff line number Diff line
@@ -14,8 +14,7 @@ 
 * limitations under the License.

 */



#include <SkCanvas.h>



#include "Canvas.h"

#include "CanvasState.h"

#include "utils/MathUtils.h"
@@ -54,8 +53,7 @@ void CanvasState::initializeRecordingSaveStack(int viewportWidth, int viewportHe 
    }



    freeAllSnapshots();

    mSnapshot = allocSnapshot(&mFirstSnapshot,

            SkCanvas::kMatrix_SaveFlag | SkCanvas::kClip_SaveFlag);

    mSnapshot = allocSnapshot(&mFirstSnapshot, SaveFlags::MatrixClip);

    mSnapshot->setRelativeLightCenter(Vector3());

    mSaveCount = 1;

}
@@ -72,8 +70,7 @@ void CanvasState::initializeSaveStack( 
    }



    freeAllSnapshots();

    mSnapshot = allocSnapshot(&mFirstSnapshot,

            SkCanvas::kMatrix_SaveFlag | SkCanvas::kClip_SaveFlag);

    mSnapshot = allocSnapshot(&mFirstSnapshot, SaveFlags::MatrixClip);

    mSnapshot->setClip(clipLeft, clipTop, clipRight, clipBottom);

    mSnapshot->fbo = mCanvas.getTargetFbo();

    mSnapshot->setRelativeLightCenter(lightCenter);

libs/hwui/DeferredDisplayList.cpp

+4 −6
Original line number Diff line number Diff line
@@ -14,8 +14,6 @@ 
 * limitations under the License.

 */



#include <SkCanvas.h>



#include <utils/Trace.h>

#include <ui/Rect.h>

#include <ui/Region.h>
@@ -419,7 +417,7 @@ void DeferredDisplayList::addClip(OpenGLRenderer& renderer, ClipOp* op) { 
 * beginning of the frame. This would avoid targetting and removing an FBO in the middle of a frame.

 *

 * saveLayer operations should be pulled to the beginning of the frame if the canvas doesn't have a

 * complex clip, and if the flags (kClip_SaveFlag & kClipToLayer_SaveFlag) are set.

 * complex clip, and if the flags (SaveFlags::Clip & SaveFlags::ClipToLayer) are set.

 */

void DeferredDisplayList::addSaveLayer(OpenGLRenderer& renderer,

        SaveLayerOp* op, int newSaveCount) {
@@ -438,7 +436,7 @@ void DeferredDisplayList::addSave(OpenGLRenderer& renderer, SaveOp* op, int newS 
    int saveFlags = op->getFlags();

    DEFER_LOGD("%p adding saveOp %p, flags %x, new count %d", this, op, saveFlags, newSaveCount);



    if (recordingComplexClip() && (saveFlags & SkCanvas::kClip_SaveFlag)) {

    if (recordingComplexClip() && (saveFlags & SaveFlags::Clip)) {

        // store and replay the save operation, as it may be needed to correctly playback the clip

        DEFER_LOGD("    adding save barrier with new save count %d", newSaveCount);

        storeStateOpBarrier(renderer, op);
@@ -621,7 +619,7 @@ void DeferredDisplayList::storeRestoreToCountBarrier(OpenGLRenderer& renderer, S 
            this, newSaveCount, mBatches.size());



    // store displayState for the restore operation, as it may be associated with a saveLayer that

    // doesn't have kClip_SaveFlag set

    // doesn't have SaveFlags::Clip set

    DeferredDisplayState* state = createState();

    renderer.storeDisplayState(*state, getStateOpDeferFlags());

    mBatches.push_back(new RestoreToCountBatch(op, state, newSaveCount));
@@ -654,7 +652,7 @@ void DeferredDisplayList::flush(OpenGLRenderer& renderer, Rect& dirty) { 
    renderer.eventMark("Flush");



    // save and restore so that reordering doesn't affect final state

    renderer.save(SkCanvas::kMatrix_SaveFlag | SkCanvas::kClip_SaveFlag);

    renderer.save(SaveFlags::MatrixClip);



    if (CC_LIKELY(avoidOverdraw())) {

        for (unsigned int i = 1; i < mBatches.size(); i++) {

libs/hwui/DisplayListCanvas.cpp

+7 −7
Original line number Diff line number Diff line
@@ -102,7 +102,7 @@ SkCanvas* DisplayListCanvas::asSkCanvas() { 
    return mSkiaCanvasProxy.get();

}



int DisplayListCanvas::save(SkCanvas::SaveFlags flags) {

int DisplayListCanvas::save(SaveFlags::Flags flags) {

    addStateOp(new (alloc()) SaveOp((int) flags));

    return mState.save((int) flags);

}
@@ -125,9 +125,9 @@ void DisplayListCanvas::restoreToCount(int saveCount) { 
}



int DisplayListCanvas::saveLayer(float left, float top, float right, float bottom,

        const SkPaint* paint, SkCanvas::SaveFlags flags) {

        const SkPaint* paint, SaveFlags::Flags flags) {

    // force matrix/clip isolation for layer

    flags |= SkCanvas::kClip_SaveFlag | SkCanvas::kMatrix_SaveFlag;

    flags |= SaveFlags::MatrixClip;



    paint = refPaint(paint);

    addStateOp(new (alloc()) SaveLayerOp(left, top, right, bottom, paint, (int) flags));
@@ -232,7 +232,7 @@ void DisplayListCanvas::drawBitmap(const SkBitmap* bitmap, const SkPaint* paint) 


void DisplayListCanvas::drawBitmap(const SkBitmap& bitmap, float left, float top,

        const SkPaint* paint) {

    save(SkCanvas::kMatrix_SaveFlag);

    save(SaveFlags::Matrix);

    translate(left, top);

    drawBitmap(&bitmap, paint);

    restore();
@@ -253,7 +253,7 @@ void DisplayListCanvas::drawBitmap(const SkBitmap& bitmap, const SkMatrix& matri 
        drawBitmap(bitmap, src.fLeft, src.fTop, src.fRight, src.fBottom,

                   dst.fLeft, dst.fTop, dst.fRight, dst.fBottom, paint);

    } else {

        save(SkCanvas::kMatrix_SaveFlag);

        save(SaveFlags::Matrix);

        concat(matrix);

        drawBitmap(&bitmap, paint);

        restore();
@@ -269,7 +269,7 @@ void DisplayListCanvas::drawBitmap(const SkBitmap& bitmap, float srcLeft, float 
            && (srcBottom - srcTop == dstBottom - dstTop)

            && (srcRight - srcLeft == dstRight - dstLeft)) {

        // transform simple rect to rect drawing case into position bitmap ops, since they merge

        save(SkCanvas::kMatrix_SaveFlag);

        save(SaveFlags::Matrix);

        translate(dstLeft, dstTop);

        drawBitmap(&bitmap, paint);

        restore();
@@ -283,7 +283,7 @@ void DisplayListCanvas::drawBitmap(const SkBitmap& bitmap, float srcLeft, float 
                // Apply the scale transform on the canvas, so that the shader

                // effectively calculates positions relative to src rect space



                save(SkCanvas::kMatrix_SaveFlag);

                save(SaveFlags::Matrix);

                translate(dstLeft, dstTop);

                scale(scaleX, scaleY);