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

Commit 76d3a1b8 authored by Derek Sollenberger's avatar Derek Sollenberger
Browse files

Removing SkiaColorFilter and inspecting the native object directly.

bug: 10650594
Change-Id: I4fcf66d008765afa0e35d011f58bc792183cb74f
parent 8852ab43
Loading
Loading
Loading
Loading
+22 −80
Original line number Diff line number Diff line
@@ -46,7 +46,6 @@ class GLES20Canvas extends HardwareCanvas {
    private static final int MODIFIER_NONE = 0;
    private static final int MODIFIER_SHADOW = 1;
    private static final int MODIFIER_SHADER = 2;
    private static final int MODIFIER_COLOR_FILTER = 4;

    private final boolean mOpaque;
    private long mRenderer;
@@ -627,15 +626,8 @@ class GLES20Canvas extends HardwareCanvas {
            return saveLayer(bounds.left, bounds.top, bounds.right, bounds.bottom, paint, saveFlags);
        }

        int count;
        int modifier = paint != null ? setupColorFilter(paint) : MODIFIER_NONE;
        try {
        final long nativePaint = paint == null ? 0 : paint.mNativePaint;
            count = nSaveLayer(mRenderer, nativePaint, saveFlags);
        } finally {
            if (modifier != MODIFIER_NONE) nResetModifiers(mRenderer, modifier);
        }
        return count;
        return nSaveLayer(mRenderer, nativePaint, saveFlags);
    }

    private static native int nSaveLayer(long renderer, long paint, int saveFlags);
@@ -644,15 +636,8 @@ class GLES20Canvas extends HardwareCanvas {
    public int saveLayer(float left, float top, float right, float bottom, Paint paint,
            int saveFlags) {
        if (left < right && top < bottom) {
            int count;
            int modifier = paint != null ? setupColorFilter(paint) : MODIFIER_NONE;
            try {
            final long nativePaint = paint == null ? 0 : paint.mNativePaint;
                count = nSaveLayer(mRenderer, left, top, right, bottom, nativePaint, saveFlags);
            } finally {
                if (modifier != MODIFIER_NONE) nResetModifiers(mRenderer, modifier);
            }
            return count;
            return nSaveLayer(mRenderer, left, top, right, bottom, nativePaint, saveFlags);
        }
        return save(saveFlags);
    }
@@ -734,7 +719,7 @@ class GLES20Canvas extends HardwareCanvas {
    @Override
    public void drawArc(RectF oval, float startAngle, float sweepAngle, boolean useCenter,
            Paint paint) {
        int modifiers = setupModifiers(paint, MODIFIER_COLOR_FILTER | MODIFIER_SHADER);
        int modifiers = setupModifiers(paint, MODIFIER_SHADER);
        try {
            nDrawArc(mRenderer, oval.left, oval.top, oval.right, oval.bottom,
                    startAngle, sweepAngle, useCenter, paint.mNativePaint);
@@ -757,14 +742,9 @@ class GLES20Canvas extends HardwareCanvas {
        Bitmap bitmap = patch.getBitmap();
        throwIfCannotDraw(bitmap);
        // Shaders are ignored when drawing patches
        int modifier = paint != null ? setupColorFilter(paint) : MODIFIER_NONE;
        try {
        final long nativePaint = paint == null ? 0 : paint.mNativePaint;
        nDrawPatch(mRenderer, bitmap.mNativeBitmap, bitmap.mBuffer, patch.mNativeChunk,
                dst.left, dst.top, dst.right, dst.bottom, nativePaint);
        } finally {
            if (modifier != MODIFIER_NONE) nResetModifiers(mRenderer, modifier);
        }
    }

    @Override
@@ -772,14 +752,9 @@ class GLES20Canvas extends HardwareCanvas {
        Bitmap bitmap = patch.getBitmap();
        throwIfCannotDraw(bitmap);
        // Shaders are ignored when drawing patches
        int modifier = paint != null ? setupColorFilter(paint) : MODIFIER_NONE;
        try {
        final long nativePaint = paint == null ? 0 : paint.mNativePaint;
        nDrawPatch(mRenderer, bitmap.mNativeBitmap, bitmap.mBuffer, patch.mNativeChunk,
                dst.left, dst.top, dst.right, dst.bottom, nativePaint);
        } finally {
            if (modifier != MODIFIER_NONE) nResetModifiers(mRenderer, modifier);
        }
    }

    private static native void nDrawPatch(long renderer, long bitmap, byte[] buffer, long chunk,
@@ -900,14 +875,9 @@ class GLES20Canvas extends HardwareCanvas {
        }

        // Shaders are ignored when drawing bitmaps
        int modifier = paint != null ? setupColorFilter(paint) : MODIFIER_NONE;
        try {
        final long nativePaint = paint == null ? 0 : paint.mNativePaint;
        nDrawBitmap(mRenderer, colors, offset, stride, x, y,
                width, height, hasAlpha, nativePaint);
        } finally {
            if (modifier != MODIFIER_NONE) nResetModifiers(mRenderer, modifier);
        }
    }

    private static native void nDrawBitmap(long renderer, int[] colors, int offset, int stride,
@@ -955,7 +925,7 @@ class GLES20Canvas extends HardwareCanvas {

    @Override
    public void drawCircle(float cx, float cy, float radius, Paint paint) {
        int modifiers = setupModifiers(paint, MODIFIER_COLOR_FILTER | MODIFIER_SHADER);
        int modifiers = setupModifiers(paint, MODIFIER_SHADER);
        try {
            nDrawCircle(mRenderer, cx, cy, radius, paint.mNativePaint);
        } finally {
@@ -995,7 +965,7 @@ class GLES20Canvas extends HardwareCanvas {
        if ((offset | count) < 0 || offset + count > pts.length) {
            throw new IllegalArgumentException("The lines array must contain 4 elements per line.");
        }
        int modifiers = setupModifiers(paint, MODIFIER_COLOR_FILTER | MODIFIER_SHADER);
        int modifiers = setupModifiers(paint, MODIFIER_SHADER);
        try {
            nDrawLines(mRenderer, pts, offset, count, paint.mNativePaint);
        } finally {
@@ -1013,7 +983,7 @@ class GLES20Canvas extends HardwareCanvas {

    @Override
    public void drawOval(RectF oval, Paint paint) {
        int modifiers = setupModifiers(paint, MODIFIER_COLOR_FILTER | MODIFIER_SHADER);
        int modifiers = setupModifiers(paint, MODIFIER_SHADER);
        try {
            nDrawOval(mRenderer, oval.left, oval.top, oval.right, oval.bottom, paint.mNativePaint);
        } finally {
@@ -1033,7 +1003,7 @@ class GLES20Canvas extends HardwareCanvas {

    @Override
    public void drawPath(Path path, Paint paint) {
        int modifiers = setupModifiers(paint, MODIFIER_COLOR_FILTER | MODIFIER_SHADER);
        int modifiers = setupModifiers(paint, MODIFIER_SHADER);
        try {
            if (path.isSimplePath) {
                if (path.rects != null) {
@@ -1051,7 +1021,7 @@ class GLES20Canvas extends HardwareCanvas {
    private static native void nDrawRects(long renderer, long region, long paint);

    void drawRects(float[] rects, int count, Paint paint) {
        int modifiers = setupModifiers(paint, MODIFIER_COLOR_FILTER | MODIFIER_SHADER);
        int modifiers = setupModifiers(paint, MODIFIER_SHADER);
        try {
            nDrawRects(mRenderer, rects, count, paint.mNativePaint);
        } finally {
@@ -1118,7 +1088,7 @@ class GLES20Canvas extends HardwareCanvas {
    public void drawPoints(float[] pts, int offset, int count, Paint paint) {
        if (count < 2) return;

        int modifiers = setupModifiers(paint, MODIFIER_COLOR_FILTER | MODIFIER_SHADER);
        int modifiers = setupModifiers(paint, MODIFIER_SHADER);
        try {
            nDrawPoints(mRenderer, pts, offset, count, paint.mNativePaint);
        } finally {
@@ -1168,7 +1138,7 @@ class GLES20Canvas extends HardwareCanvas {
    @Override
    public void drawRect(float left, float top, float right, float bottom, Paint paint) {
        if (left == right || top == bottom) return;
        int modifiers = setupModifiers(paint, MODIFIER_COLOR_FILTER | MODIFIER_SHADER);
        int modifiers = setupModifiers(paint, MODIFIER_SHADER);
        try {
            nDrawRect(mRenderer, left, top, right, bottom, paint.mNativePaint);
        } finally {
@@ -1196,7 +1166,7 @@ class GLES20Canvas extends HardwareCanvas {

    @Override
    public void drawRoundRect(RectF rect, float rx, float ry, Paint paint) {
        int modifiers = setupModifiers(paint, MODIFIER_COLOR_FILTER | MODIFIER_SHADER);
        int modifiers = setupModifiers(paint, MODIFIER_SHADER);
        try {
            nDrawRoundRect(mRenderer, rect.left, rect.top, rect.right, rect.bottom,
                    rx, ry, paint.mNativePaint);
@@ -1376,12 +1346,6 @@ class GLES20Canvas extends HardwareCanvas {

    private int setupModifiers(Bitmap b, Paint paint) {
        if (b.getConfig() != Bitmap.Config.ALPHA_8) {
            final ColorFilter filter = paint.getColorFilter();
            if (filter != null) {
                nSetupColorFilter(mRenderer, filter.nativeColorFilter);
                return MODIFIER_COLOR_FILTER;
            }

            return MODIFIER_NONE;
        } else {
            return setupModifiers(paint);
@@ -1403,12 +1367,6 @@ class GLES20Canvas extends HardwareCanvas {
            modifiers |= MODIFIER_SHADER;
        }

        final ColorFilter filter = paint.getColorFilter();
        if (filter != null) {
            nSetupColorFilter(mRenderer, filter.nativeColorFilter);
            modifiers |= MODIFIER_COLOR_FILTER;
        }

        return modifiers;
    }

@@ -1427,26 +1385,10 @@ class GLES20Canvas extends HardwareCanvas {
            modifiers |= MODIFIER_SHADER;
        }

        final ColorFilter filter = paint.getColorFilter();
        if (filter != null && (flags & MODIFIER_COLOR_FILTER) != 0) {
            nSetupColorFilter(mRenderer, filter.nativeColorFilter);
            modifiers |= MODIFIER_COLOR_FILTER;
        }

        return modifiers;
    }

    private int setupColorFilter(Paint paint) {
        final ColorFilter filter = paint.getColorFilter();
        if (filter != null) {
            nSetupColorFilter(mRenderer, filter.nativeColorFilter);
            return MODIFIER_COLOR_FILTER;
        }
        return MODIFIER_NONE;
    }

    private static native void nSetupShader(long renderer, long shader);
    private static native void nSetupColorFilter(long renderer, long colorFilter);
    private static native void nSetupShadow(long renderer, float radius,
            float dx, float dy, int color);

+1 −1
Original line number Diff line number Diff line
@@ -48,7 +48,7 @@ abstract class GLES20Layer extends HardwareLayer {
        if (paint != null) {
            GLES20Canvas.nSetLayerPaint(mLayer, paint.mNativePaint);
            GLES20Canvas.nSetLayerColorFilter(mLayer, paint.getColorFilter() != null ?
                    paint.getColorFilter().nativeColorFilter : 0);
                    paint.getColorFilter().native_instance : 0);
        }
    }

+4 −63
Original line number Diff line number Diff line
@@ -23,7 +23,6 @@
#include "SkColorMatrixFilter.h"
#include "SkPorterDuff.h"

#include <SkiaColorFilter.h>
#include <Caches.h>

namespace android {
@@ -32,64 +31,9 @@ using namespace uirenderer;

class SkColorFilterGlue {
public:
    static void finalizer(JNIEnv* env, jobject clazz, jlong objHandle, jlong fHandle) {
        SkColorFilter* obj = reinterpret_cast<SkColorFilter *>(objHandle);
        SkiaColorFilter* f = reinterpret_cast<SkiaColorFilter *>(fHandle);
        if (obj) SkSafeUnref(obj);
        // f == NULL when not !USE_OPENGL_RENDERER, so no need to delete outside the ifdef
#ifdef USE_OPENGL_RENDERER
        if (f && android::uirenderer::Caches::hasInstance()) {
            android::uirenderer::Caches::getInstance().resourceCache.destructor(f);
        } else {
            delete f;
        }
#endif
    }

    static jlong glCreatePorterDuffFilter(JNIEnv* env, jobject, jlong skFilterHandle,
            jint srcColor, jint modeHandle) {
        SkColorFilter *skFilter = reinterpret_cast<SkColorFilter *>(skFilterHandle);
        SkPorterDuff::Mode mode = static_cast<SkPorterDuff::Mode>(modeHandle);
#ifdef USE_OPENGL_RENDERER
        return reinterpret_cast<jlong>(new SkiaBlendFilter(skFilter, srcColor, SkPorterDuff::ToXfermodeMode(mode)));
#else
        return NULL;
#endif
    }

    static jlong glCreateLightingFilter(JNIEnv* env, jobject, jlong skFilterHandle,
            jint mul, jint add) {
        SkColorFilter *skFilter = reinterpret_cast<SkColorFilter *>(skFilterHandle);
#ifdef USE_OPENGL_RENDERER
        return reinterpret_cast<jlong>(new SkiaLightingFilter(skFilter, mul, add));
#else
        return NULL;
#endif
    }

    static jlong glCreateColorMatrixFilter(JNIEnv* env, jobject, jlong skFilterHandle,
            jfloatArray jarray) {
        SkColorFilter *skFilter = reinterpret_cast<SkColorFilter *>(skFilterHandle);
#ifdef USE_OPENGL_RENDERER
        AutoJavaFloatArray autoArray(env, jarray, 20);
        const float* src = autoArray.ptr();

        float* colorMatrix = new float[16];
        memcpy(colorMatrix, src, 4 * sizeof(float));
        memcpy(&colorMatrix[4], &src[5], 4 * sizeof(float));
        memcpy(&colorMatrix[8], &src[10], 4 * sizeof(float));
        memcpy(&colorMatrix[12], &src[15], 4 * sizeof(float));

        float* colorVector = new float[4];
        colorVector[0] = src[4];
        colorVector[1] = src[9];
        colorVector[2] = src[14];
        colorVector[3] = src[19];

        return reinterpret_cast<jlong>(new SkiaColorMatrixFilter(skFilter, colorMatrix, colorVector));
#else
        return NULL;
#endif
    static void finalizer(JNIEnv* env, jobject clazz, jlong skFilterHandle) {
        SkColorFilter* filter = reinterpret_cast<SkColorFilter *>(skFilterHandle);
        if (filter) SkSafeUnref(filter);
    }

    static jlong CreatePorterDuffFilter(JNIEnv* env, jobject, jint srcColor,
@@ -119,22 +63,19 @@ public:
};

static JNINativeMethod colorfilter_methods[] = {
    {"destroyFilter", "(JJ)V", (void*) SkColorFilterGlue::finalizer}
    {"destroyFilter", "(J)V", (void*) SkColorFilterGlue::finalizer}
};

static JNINativeMethod porterduff_methods[] = {
    { "native_CreatePorterDuffFilter", "(II)J", (void*) SkColorFilterGlue::CreatePorterDuffFilter   },
    { "nCreatePorterDuffFilter",       "(JII)J", (void*) SkColorFilterGlue::glCreatePorterDuffFilter }
};

static JNINativeMethod lighting_methods[] = {
    { "native_CreateLightingFilter", "(II)J", (void*) SkColorFilterGlue::CreateLightingFilter   },
    { "nCreateLightingFilter",       "(JII)J", (void*) SkColorFilterGlue::glCreateLightingFilter },
};

static JNINativeMethod colormatrix_methods[] = {
    { "nativeColorMatrixFilter", "([F)J", (void*) SkColorFilterGlue::CreateColorMatrixFilter   },
    { "nColorMatrixFilter",      "(J[F)J", (void*) SkColorFilterGlue::glCreateColorMatrixFilter }
};

#define REG(env, name, array) \
+1 −11
Original line number Diff line number Diff line
@@ -47,7 +47,6 @@
#include <LayerRenderer.h>
#include <OpenGLRenderer.h>
#include <SkiaShader.h>
#include <SkiaColorFilter.h>
#include <Stencil.h>
#include <Rect.h>

@@ -81,7 +80,6 @@ using namespace uirenderer;

#define MODIFIER_SHADOW 1
#define MODIFIER_SHADER 2
#define MODIFIER_COLOR_FILTER 4

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

@@ -638,7 +636,6 @@ static void android_view_GLES20Canvas_resetModifiers(JNIEnv* env, jobject clazz,
    OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
    if (modifiers & MODIFIER_SHADOW) renderer->resetShadow();
    if (modifiers & MODIFIER_SHADER) renderer->resetShader();
    if (modifiers & MODIFIER_COLOR_FILTER) renderer->resetColorFilter();
}

static void android_view_GLES20Canvas_setupShader(JNIEnv* env, jobject clazz,
@@ -648,12 +645,6 @@ static void android_view_GLES20Canvas_setupShader(JNIEnv* env, jobject clazz,
    renderer->setupShader(shader);
}

static void android_view_GLES20Canvas_setupColorFilter(JNIEnv* env, jobject clazz,
        jlong rendererPtr, jlong colorFilterPtr) {
    OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
    SkiaColorFilter* colorFilter = reinterpret_cast<SkiaColorFilter*>(colorFilterPtr);
    renderer->setupColorFilter(colorFilter);
}

static void android_view_GLES20Canvas_setupShadow(JNIEnv* env, jobject clazz,
        jlong rendererPtr, jfloat radius, jfloat dx, jfloat dy, jint color) {
@@ -987,7 +978,7 @@ static void android_view_GLES20Canvas_setLayerColorFilter(JNIEnv* env, jobject c
        jlong layerPtr, jlong colorFilterPtr) {
    Layer* layer = reinterpret_cast<Layer*>(layerPtr);
    if (layer) {
        SkiaColorFilter* colorFilter = reinterpret_cast<SkiaColorFilter*>(colorFilterPtr);
        SkColorFilter* colorFilter = reinterpret_cast<SkColorFilter*>(colorFilterPtr);
        layer->setColorFilter(colorFilter);
    }
}
@@ -1222,7 +1213,6 @@ static JNINativeMethod gMethods[] = {

    { "nResetModifiers",    "(JI)V",           (void*) android_view_GLES20Canvas_resetModifiers },
    { "nSetupShader",       "(JJ)V",           (void*) android_view_GLES20Canvas_setupShader },
    { "nSetupColorFilter",  "(JJ)V",           (void*) android_view_GLES20Canvas_setupColorFilter },
    { "nSetupShadow",       "(JFFFI)V",        (void*) android_view_GLES20Canvas_setupShadow },

    { "nSetupPaintFilter",  "(JII)V",          (void*) android_view_GLES20Canvas_setupPaintFilter },
+4 −7
Original line number Diff line number Diff line
@@ -27,24 +27,21 @@ package android.graphics;
 * never be used directly.
 */
public class ColorFilter {
    // Holds the pointer to the native SkColorFilter instance
    long native_instance;

    /**
     * Holds the pointer to the native SkiaColorFilter instance, from libhwui.
     * Holds the pointer to the native SkColorFilter instance.
     *
     * @hide
     */
    public long nativeColorFilter;
    public long native_instance;

    @Override
    protected void finalize() throws Throwable {
        try {
            super.finalize();
        } finally {
            destroyFilter(native_instance, nativeColorFilter);
            destroyFilter(native_instance);
        }
    }

    static native void destroyFilter(long native_instance, long nativeColorFilter);
    static native void destroyFilter(long native_instance);
}
Loading