Merge "Revert "Enforce that RuntimeShader is only hardware accelerated""

2021-12-20 13:47:12 +00:00
parent cf50b2ab23 f95fdd9472
commit 4d6ea2fb47
3 changed files with 67 additions and 73 deletions
--- a/core/java/android/view/ViewDebug.java
+++ b/core/java/android/view/ViewDebug.java
@@ -1896,7 +1896,7 @@ public class ViewDebug {

        private Canvas mCanvas;
        private Bitmap mBitmap;
-        private boolean mEnabledHwFeaturesInSwMode;
+        private boolean mEnabledHwBitmapsInSwMode;

        @Override
        public Canvas getCanvas(View view, int width, int height) {
@@ -1913,7 +1913,7 @@ public class ViewDebug {
            if (mCanvas == null) {
                mCanvas = new Canvas();
            }
-            mEnabledHwFeaturesInSwMode = mCanvas.isHwFeaturesInSwModeEnabled();
+            mEnabledHwBitmapsInSwMode = mCanvas.isHwBitmapsInSwModeEnabled();
            mCanvas.setBitmap(mBitmap);
            return mCanvas;
        }
@@ -1921,7 +1921,7 @@ public class ViewDebug {
        @Override
        public Bitmap createBitmap() {
            mCanvas.setBitmap(null);
-            mCanvas.setHwFeaturesInSwModeEnabled(mEnabledHwFeaturesInSwMode);
+            mCanvas.setHwBitmapsInSwModeEnabled(mEnabledHwBitmapsInSwMode);
            return mBitmap;
        }
    }
--- a/graphics/java/android/graphics/BaseCanvas.java
+++ b/graphics/java/android/graphics/BaseCanvas.java
@@ -67,7 +67,7 @@ public abstract class BaseCanvas {
     * @hide
     */
    protected int mDensity = Bitmap.DENSITY_NONE;
-    private boolean mAllowHwFeaturesInSwMode = false;
+    private boolean mAllowHwBitmapsInSwMode = false;

    protected void throwIfCannotDraw(Bitmap bitmap) {
        if (bitmap.isRecycled()) {
@@ -101,14 +101,14 @@ public abstract class BaseCanvas {

    public void drawArc(float left, float top, float right, float bottom, float startAngle,
            float sweepAngle, boolean useCenter, @NonNull Paint paint) {
-        throwIfHasHwFeaturesInSwMode(paint);
+        throwIfHasHwBitmapInSwMode(paint);
        nDrawArc(mNativeCanvasWrapper, left, top, right, bottom, startAngle, sweepAngle,
                useCenter, paint.getNativeInstance());
    }

    public void drawArc(@NonNull RectF oval, float startAngle, float sweepAngle, boolean useCenter,
            @NonNull Paint paint) {
-        throwIfHasHwFeaturesInSwMode(paint);
+        throwIfHasHwBitmapInSwMode(paint);
        drawArc(oval.left, oval.top, oval.right, oval.bottom, startAngle, sweepAngle, useCenter,
                paint);
    }
@@ -119,14 +119,14 @@ public abstract class BaseCanvas {

    public void drawBitmap(@NonNull Bitmap bitmap, float left, float top, @Nullable Paint paint) {
        throwIfCannotDraw(bitmap);
-        throwIfHasHwFeaturesInSwMode(paint);
+        throwIfHasHwBitmapInSwMode(paint);
        nDrawBitmap(mNativeCanvasWrapper, bitmap.getNativeInstance(), left, top,
                paint != null ? paint.getNativeInstance() : 0, mDensity, mScreenDensity,
                bitmap.mDensity);
    }

    public void drawBitmap(@NonNull Bitmap bitmap, @NonNull Matrix matrix, @Nullable Paint paint) {
-        throwIfHasHwFeaturesInSwMode(paint);
+        throwIfHasHwBitmapInSwMode(paint);
        nDrawBitmapMatrix(mNativeCanvasWrapper, bitmap.getNativeInstance(), matrix.ni(),
                paint != null ? paint.getNativeInstance() : 0);
    }
@@ -137,7 +137,7 @@ public abstract class BaseCanvas {
            throw new NullPointerException();
        }
        throwIfCannotDraw(bitmap);
-        throwIfHasHwFeaturesInSwMode(paint);
+        throwIfHasHwBitmapInSwMode(paint);
        final long nativePaint = paint == null ? 0 : paint.getNativeInstance();

        int left, top, right, bottom;
@@ -163,7 +163,7 @@ public abstract class BaseCanvas {
            throw new NullPointerException();
        }
        throwIfCannotDraw(bitmap);
-        throwIfHasHwFeaturesInSwMode(paint);
+        throwIfHasHwBitmapInSwMode(paint);
        final long nativePaint = paint == null ? 0 : paint.getNativeInstance();

        float left, top, right, bottom;
@@ -202,7 +202,7 @@ public abstract class BaseCanvas {
                || (lastScanline + width > length)) {
            throw new ArrayIndexOutOfBoundsException();
        }
-        throwIfHasHwFeaturesInSwMode(paint);
+        throwIfHasHwBitmapInSwMode(paint);
        // quick escape if there's nothing to draw
        if (width == 0 || height == 0) {
            return;
@@ -226,7 +226,7 @@ public abstract class BaseCanvas {
        if ((meshWidth | meshHeight | vertOffset | colorOffset) < 0) {
            throw new ArrayIndexOutOfBoundsException();
        }
-        throwIfHasHwFeaturesInSwMode(paint);
+        throwIfHasHwBitmapInSwMode(paint);
        if (meshWidth == 0 || meshHeight == 0) {
            return;
        }
@@ -243,7 +243,7 @@ public abstract class BaseCanvas {
    }

    public void drawCircle(float cx, float cy, float radius, @NonNull Paint paint) {
-        throwIfHasHwFeaturesInSwMode(paint);
+        throwIfHasHwBitmapInSwMode(paint);
        nDrawCircle(mNativeCanvasWrapper, cx, cy, radius, paint.getNativeInstance());
    }

@@ -275,23 +275,23 @@ public abstract class BaseCanvas {

    public void drawLine(float startX, float startY, float stopX, float stopY,
            @NonNull Paint paint) {
-        throwIfHasHwFeaturesInSwMode(paint);
+        throwIfHasHwBitmapInSwMode(paint);
        nDrawLine(mNativeCanvasWrapper, startX, startY, stopX, stopY, paint.getNativeInstance());
    }

    public void drawLines(@Size(multiple = 4) @NonNull float[] pts, int offset, int count,
            @NonNull Paint paint) {
-        throwIfHasHwFeaturesInSwMode(paint);
+        throwIfHasHwBitmapInSwMode(paint);
        nDrawLines(mNativeCanvasWrapper, pts, offset, count, paint.getNativeInstance());
    }

    public void drawLines(@Size(multiple = 4) @NonNull float[] pts, @NonNull Paint paint) {
-        throwIfHasHwFeaturesInSwMode(paint);
+        throwIfHasHwBitmapInSwMode(paint);
        drawLines(pts, 0, pts.length, paint);
    }

    public void drawOval(float left, float top, float right, float bottom, @NonNull Paint paint) {
-        throwIfHasHwFeaturesInSwMode(paint);
+        throwIfHasHwBitmapInSwMode(paint);
        nDrawOval(mNativeCanvasWrapper, left, top, right, bottom, paint.getNativeInstance());
    }

@@ -299,19 +299,18 @@ public abstract class BaseCanvas {
        if (oval == null) {
            throw new NullPointerException();
        }
-        throwIfHasHwFeaturesInSwMode(paint);
+        throwIfHasHwBitmapInSwMode(paint);
        drawOval(oval.left, oval.top, oval.right, oval.bottom, paint);
    }

    public void drawPaint(@NonNull Paint paint) {
-        throwIfHasHwFeaturesInSwMode(paint);
        nDrawPaint(mNativeCanvasWrapper, paint.getNativeInstance());
    }

    public void drawPatch(@NonNull NinePatch patch, @NonNull Rect dst, @Nullable Paint paint) {
        Bitmap bitmap = patch.getBitmap();
        throwIfCannotDraw(bitmap);
-        throwIfHasHwFeaturesInSwMode(paint);
+        throwIfHasHwBitmapInSwMode(paint);
        final long nativePaint = paint == null ? 0 : paint.getNativeInstance();
        nDrawNinePatch(mNativeCanvasWrapper, bitmap.getNativeInstance(), patch.mNativeChunk,
                dst.left, dst.top, dst.right, dst.bottom, nativePaint,
@@ -321,7 +320,7 @@ public abstract class BaseCanvas {
    public void drawPatch(@NonNull NinePatch patch, @NonNull RectF dst, @Nullable Paint paint) {
        Bitmap bitmap = patch.getBitmap();
        throwIfCannotDraw(bitmap);
-        throwIfHasHwFeaturesInSwMode(paint);
+        throwIfHasHwBitmapInSwMode(paint);
        final long nativePaint = paint == null ? 0 : paint.getNativeInstance();
        nDrawNinePatch(mNativeCanvasWrapper, bitmap.getNativeInstance(), patch.mNativeChunk,
                dst.left, dst.top, dst.right, dst.bottom, nativePaint,
@@ -329,7 +328,7 @@ public abstract class BaseCanvas {
    }

    public void drawPath(@NonNull Path path, @NonNull Paint paint) {
-        throwIfHasHwFeaturesInSwMode(paint);
+        throwIfHasHwBitmapInSwMode(paint);
        if (path.isSimplePath && path.rects != null) {
            nDrawRegion(mNativeCanvasWrapper, path.rects.mNativeRegion, paint.getNativeInstance());
        } else {
@@ -338,18 +337,18 @@ public abstract class BaseCanvas {
    }

    public void drawPoint(float x, float y, @NonNull Paint paint) {
-        throwIfHasHwFeaturesInSwMode(paint);
+        throwIfHasHwBitmapInSwMode(paint);
        nDrawPoint(mNativeCanvasWrapper, x, y, paint.getNativeInstance());
    }

    public void drawPoints(@Size(multiple = 2) float[] pts, int offset, int count,
            @NonNull Paint paint) {
-        throwIfHasHwFeaturesInSwMode(paint);
+        throwIfHasHwBitmapInSwMode(paint);
        nDrawPoints(mNativeCanvasWrapper, pts, offset, count, paint.getNativeInstance());
    }

    public void drawPoints(@Size(multiple = 2) @NonNull float[] pts, @NonNull Paint paint) {
-        throwIfHasHwFeaturesInSwMode(paint);
+        throwIfHasHwBitmapInSwMode(paint);
        drawPoints(pts, 0, pts.length, paint);
    }

@@ -360,7 +359,7 @@ public abstract class BaseCanvas {
        if (index < 0 || index + count > text.length || count * 2 > pos.length) {
            throw new IndexOutOfBoundsException();
        }
-        throwIfHasHwFeaturesInSwMode(paint);
+        throwIfHasHwBitmapInSwMode(paint);
        for (int i = 0; i < count; i++) {
            drawText(text, index + i, 1, pos[i * 2], pos[i * 2 + 1], paint);
        }
@@ -369,22 +368,22 @@ public abstract class BaseCanvas {
    @Deprecated
    public void drawPosText(@NonNull String text, @NonNull @Size(multiple = 2) float[] pos,
            @NonNull Paint paint) {
-        throwIfHasHwFeaturesInSwMode(paint);
+        throwIfHasHwBitmapInSwMode(paint);
        drawPosText(text.toCharArray(), 0, text.length(), pos, paint);
    }

    public void drawRect(float left, float top, float right, float bottom, @NonNull Paint paint) {
-        throwIfHasHwFeaturesInSwMode(paint);
+        throwIfHasHwBitmapInSwMode(paint);
        nDrawRect(mNativeCanvasWrapper, left, top, right, bottom, paint.getNativeInstance());
    }

    public void drawRect(@NonNull Rect r, @NonNull Paint paint) {
-        throwIfHasHwFeaturesInSwMode(paint);
+        throwIfHasHwBitmapInSwMode(paint);
        drawRect(r.left, r.top, r.right, r.bottom, paint);
    }

    public void drawRect(@NonNull RectF rect, @NonNull Paint paint) {
-        throwIfHasHwFeaturesInSwMode(paint);
+        throwIfHasHwBitmapInSwMode(paint);
        nDrawRect(mNativeCanvasWrapper,
                rect.left, rect.top, rect.right, rect.bottom, paint.getNativeInstance());
    }
@@ -395,13 +394,13 @@ public abstract class BaseCanvas {

    public void drawRoundRect(float left, float top, float right, float bottom, float rx, float ry,
            @NonNull Paint paint) {
-        throwIfHasHwFeaturesInSwMode(paint);
+        throwIfHasHwBitmapInSwMode(paint);
        nDrawRoundRect(mNativeCanvasWrapper, left, top, right, bottom, rx, ry,
                paint.getNativeInstance());
    }

    public void drawRoundRect(@NonNull RectF rect, float rx, float ry, @NonNull Paint paint) {
-        throwIfHasHwFeaturesInSwMode(paint);
+        throwIfHasHwBitmapInSwMode(paint);
        drawRoundRect(rect.left, rect.top, rect.right, rect.bottom, rx, ry, paint);
    }

@@ -411,7 +410,7 @@ public abstract class BaseCanvas {
     */
    public void drawDoubleRoundRect(@NonNull RectF outer, float outerRx, float outerRy,
            @NonNull RectF inner, float innerRx, float innerRy, @NonNull Paint paint) {
-        throwIfHasHwFeaturesInSwMode(paint);
+        throwIfHasHwBitmapInSwMode(paint);
        float outerLeft = outer.left;
        float outerTop = outer.top;
        float outerRight = outer.right;
@@ -432,7 +431,7 @@ public abstract class BaseCanvas {
     */
    public void drawDoubleRoundRect(@NonNull RectF outer, @NonNull float[] outerRadii,
            @NonNull RectF inner, @NonNull float[] innerRadii, @NonNull Paint paint) {
-        throwIfHasHwFeaturesInSwMode(paint);
+        throwIfHasHwBitmapInSwMode(paint);
        if (innerRadii == null || outerRadii == null
                || innerRadii.length != 8 || outerRadii.length != 8) {
            throw new IllegalArgumentException("Both inner and outer radii arrays must contain "
@@ -510,7 +509,7 @@ public abstract class BaseCanvas {
                (text.length - index - count)) < 0) {
            throw new IndexOutOfBoundsException();
        }
-        throwIfHasHwFeaturesInSwMode(paint);
+        throwIfHasHwBitmapInSwMode(paint);
        nDrawText(mNativeCanvasWrapper, text, index, count, x, y, paint.mBidiFlags,
                paint.getNativeInstance());
    }
@@ -520,7 +519,7 @@ public abstract class BaseCanvas {
        if ((start | end | (end - start) | (text.length() - end)) < 0) {
            throw new IndexOutOfBoundsException();
        }
-        throwIfHasHwFeaturesInSwMode(paint);
+        throwIfHasHwBitmapInSwMode(paint);
        if (text instanceof String || text instanceof SpannedString ||
                text instanceof SpannableString) {
            nDrawText(mNativeCanvasWrapper, text.toString(), start, end, x, y,
@@ -538,7 +537,7 @@ public abstract class BaseCanvas {
    }

    public void drawText(@NonNull String text, float x, float y, @NonNull Paint paint) {
-        throwIfHasHwFeaturesInSwMode(paint);
+        throwIfHasHwBitmapInSwMode(paint);
        nDrawText(mNativeCanvasWrapper, text, 0, text.length(), x, y, paint.mBidiFlags,
                paint.getNativeInstance());
    }
@@ -548,7 +547,7 @@ public abstract class BaseCanvas {
        if ((start | end | (end - start) | (text.length() - end)) < 0) {
            throw new IndexOutOfBoundsException();
        }
-        throwIfHasHwFeaturesInSwMode(paint);
+        throwIfHasHwBitmapInSwMode(paint);
        nDrawText(mNativeCanvasWrapper, text, start, end, x, y, paint.mBidiFlags,
                paint.getNativeInstance());
    }
@@ -558,7 +557,7 @@ public abstract class BaseCanvas {
        if (index < 0 || index + count > text.length) {
            throw new ArrayIndexOutOfBoundsException();
        }
-        throwIfHasHwFeaturesInSwMode(paint);
+        throwIfHasHwBitmapInSwMode(paint);
        nDrawTextOnPath(mNativeCanvasWrapper, text, index, count,
                path.readOnlyNI(), hOffset, vOffset,
                paint.mBidiFlags, paint.getNativeInstance());
@@ -567,7 +566,7 @@ public abstract class BaseCanvas {
    public void drawTextOnPath(@NonNull String text, @NonNull Path path, float hOffset,
            float vOffset, @NonNull Paint paint) {
        if (text.length() > 0) {
-            throwIfHasHwFeaturesInSwMode(paint);
+            throwIfHasHwBitmapInSwMode(paint);
            nDrawTextOnPath(mNativeCanvasWrapper, text, path.readOnlyNI(), hOffset, vOffset,
                    paint.mBidiFlags, paint.getNativeInstance());
        }
@@ -588,7 +587,7 @@ public abstract class BaseCanvas {
            throw new IndexOutOfBoundsException();
        }

-        throwIfHasHwFeaturesInSwMode(paint);
+        throwIfHasHwBitmapInSwMode(paint);
        nDrawTextRun(mNativeCanvasWrapper, text, index, count, contextIndex, contextCount,
                x, y, isRtl, paint.getNativeInstance(), 0 /* measured text */);
    }
@@ -607,7 +606,7 @@ public abstract class BaseCanvas {
            throw new IndexOutOfBoundsException();
        }

-        throwIfHasHwFeaturesInSwMode(paint);
+        throwIfHasHwBitmapInSwMode(paint);
        if (text instanceof String || text instanceof SpannedString ||
                text instanceof SpannableString) {
            nDrawTextRun(mNativeCanvasWrapper, text.toString(), start, end, contextStart,
@@ -665,7 +664,7 @@ public abstract class BaseCanvas {
        if (indices != null) {
            checkRange(indices.length, indexOffset, indexCount);
        }
-        throwIfHasHwFeaturesInSwMode(paint);
+        throwIfHasHwBitmapInSwMode(paint);
        nDrawVertices(mNativeCanvasWrapper, mode.nativeInt, vertexCount, verts,
                vertOffset, texs, texOffset, colors, colorOffset,
                indices, indexOffset, indexCount, paint.getNativeInstance());
@@ -681,52 +680,50 @@ public abstract class BaseCanvas {
    /**
     * @hide
     */
-    public void setHwFeaturesInSwModeEnabled(boolean enabled) {
-        mAllowHwFeaturesInSwMode = enabled;
+    public void setHwBitmapsInSwModeEnabled(boolean enabled) {
+        mAllowHwBitmapsInSwMode = enabled;
    }

    /**
     * @hide
     */
-    public boolean isHwFeaturesInSwModeEnabled() {
-        return mAllowHwFeaturesInSwMode;
+    public boolean isHwBitmapsInSwModeEnabled() {
+        return mAllowHwBitmapsInSwMode;
    }

    /**
-     * If true throw an exception
     * @hide
     */
-    protected boolean onHwFeatureInSwMode() {
-        return !mAllowHwFeaturesInSwMode;
-    }
-
-    private void throwIfHwBitmapInSwMode(Bitmap bitmap) {
-        if (!isHardwareAccelerated() && bitmap.getConfig() == Bitmap.Config.HARDWARE
-                && onHwFeatureInSwMode()) {
+    protected void onHwBitmapInSwMode() {
+        if (!mAllowHwBitmapsInSwMode) {
            throw new IllegalArgumentException(
                    "Software rendering doesn't support hardware bitmaps");
        }
    }

-    private void throwIfHasHwFeaturesInSwMode(Paint p) {
+    private void throwIfHwBitmapInSwMode(Bitmap bitmap) {
+        if (!isHardwareAccelerated() && bitmap.getConfig() == Bitmap.Config.HARDWARE) {
+            onHwBitmapInSwMode();
+        }
+    }
+
+    private void throwIfHasHwBitmapInSwMode(Paint p) {
        if (isHardwareAccelerated() || p == null) {
            return;
        }
-        throwIfHasHwFeaturesInSwMode(p.getShader());
+        throwIfHasHwBitmapInSwMode(p.getShader());
    }

-    private void throwIfHasHwFeaturesInSwMode(Shader shader) {
+    private void throwIfHasHwBitmapInSwMode(Shader shader) {
        if (shader == null) {
            return;
        }
        if (shader instanceof BitmapShader) {
            throwIfHwBitmapInSwMode(((BitmapShader) shader).mBitmap);
-        } else if (shader instanceof RuntimeShader && onHwFeatureInSwMode()) {
-            throw new IllegalArgumentException(
-                    "Software rendering doesn't support RuntimeShader");
-        } else if (shader instanceof ComposeShader) {
-            throwIfHasHwFeaturesInSwMode(((ComposeShader) shader).mShaderA);
-            throwIfHasHwFeaturesInSwMode(((ComposeShader) shader).mShaderB);
+        }
+        if (shader instanceof ComposeShader) {
+            throwIfHasHwBitmapInSwMode(((ComposeShader) shader).mShaderA);
+            throwIfHasHwBitmapInSwMode(((ComposeShader) shader).mShaderB);
        }
    }

--- a/graphics/java/android/graphics/Picture.java
+++ b/graphics/java/android/graphics/Picture.java
@@ -124,7 +124,7 @@ public class Picture {
    public void endRecording() {
        verifyValid();
        if (mRecordingCanvas != null) {
-            mRequiresHwAcceleration = mRecordingCanvas.mUsesHwFeature;
+            mRequiresHwAcceleration = mRecordingCanvas.mHoldsHwBitmap;
            mRecordingCanvas = null;
            nativeEndRecording(mNativePicture);
        }
@@ -182,10 +182,8 @@ public class Picture {
        if (mRecordingCanvas != null) {
            endRecording();
        }
-        if (mRequiresHwAcceleration && !canvas.isHardwareAccelerated()
-                && canvas.onHwFeatureInSwMode()) {
-            throw new IllegalArgumentException("Software rendering not supported for Pictures that"
-                    + " require hardware acceleration");
+        if (mRequiresHwAcceleration && !canvas.isHardwareAccelerated()) {
+            canvas.onHwBitmapInSwMode();
        }
        nativeDraw(canvas.getNativeCanvasWrapper(), mNativePicture);
    }
@@ -244,7 +242,7 @@ public class Picture {

    private static class PictureCanvas extends Canvas {
        private final Picture mPicture;
-        boolean mUsesHwFeature;
+        boolean mHoldsHwBitmap;

        public PictureCanvas(Picture pict, long nativeCanvas) {
            super(nativeCanvas);
@@ -267,9 +265,8 @@ public class Picture {
        }

        @Override
-        protected boolean onHwFeatureInSwMode() {
-            mUsesHwFeature = true;
-            return false;
+        protected void onHwBitmapInSwMode() {
+            mHoldsHwBitmap = true;
        }
    }
 }