Read premultiplied status from the SkBitmap.
Replace the Java variable with mRequestPremultiplied, to better
reflect what it represents. In both native and Java, the SkBitmap
is used as the decision maker of whether a Bitmap is premultiplied.
When changing other settings, mRequestedPremultiplied is used to
determine whether it should be premultiplied (if the new config/
hasAlpha-ness etc supports it).
ChooseFromColorProc now reads both the colortype (instead of the
deprecated Config) and alphatype on the SkBitmap. Same with
ChooseToColorProc. In the process, this caught a bug, where the
wrong procs were being used for Index8.
Replace instances of SkBitmap::Config with SkColorType where I
was already changing code.
Use the new versions of setConfig/allocPixels that take an SkImageInfo
as a parameter.
Document isPremultiplied's return value for ALPHA_8.
BUG:13618134
Change-Id: I91fc1f1e46e9294364b1af0ab4bdb37c68d7058e
diff --git a/core/jni/android/graphics/Bitmap.cpp b/core/jni/android/graphics/Bitmap.cpp
index c139c9d..f7886d3 100644
--- a/core/jni/android/graphics/Bitmap.cpp
+++ b/core/jni/android/graphics/Bitmap.cpp
@@ -1,6 +1,7 @@
#include "SkBitmap.h"
#include "SkPixelRef.h"
#include "SkImageEncoder.h"
+#include "SkImageInfo.h"
#include "SkColorPriv.h"
#include "GraphicsJNI.h"
#include "SkDither.h"
@@ -97,13 +98,14 @@
}
// can return NULL
-static FromColorProc ChooseFromColorProc(SkBitmap::Config config, bool isPremultiplied) {
- switch (config) {
- case SkBitmap::kARGB_8888_Config:
- return isPremultiplied ? FromColor_D32 : FromColor_D32_Raw;
- case SkBitmap::kARGB_4444_Config:
- return isPremultiplied ? FromColor_D4444 : FromColor_D4444_Raw;
- case SkBitmap::kRGB_565_Config:
+static FromColorProc ChooseFromColorProc(const SkBitmap& bitmap) {
+ switch (bitmap.colorType()) {
+ case kN32_SkColorType:
+ return bitmap.alphaType() == kPremul_SkAlphaType ? FromColor_D32 : FromColor_D32_Raw;
+ case kARGB_4444_SkColorType:
+ return bitmap.alphaType() == kPremul_SkAlphaType ? FromColor_D4444 :
+ FromColor_D4444_Raw;
+ case kRGB_565_SkColorType:
return FromColor_D565;
default:
break;
@@ -112,11 +114,10 @@
}
bool GraphicsJNI::SetPixels(JNIEnv* env, jintArray srcColors, int srcOffset, int srcStride,
- int x, int y, int width, int height,
- const SkBitmap& dstBitmap, bool isPremultiplied) {
+ int x, int y, int width, int height, const SkBitmap& dstBitmap) {
SkAutoLockPixels alp(dstBitmap);
void* dst = dstBitmap.getPixels();
- FromColorProc proc = ChooseFromColorProc(dstBitmap.config(), isPremultiplied);
+ FromColorProc proc = ChooseFromColorProc(dstBitmap);
if (NULL == dst || NULL == proc) {
return false;
@@ -257,22 +258,46 @@
}
// can return NULL
-static ToColorProc ChooseToColorProc(const SkBitmap& src, bool isPremultiplied) {
+static ToColorProc ChooseToColorProc(const SkBitmap& src) {
switch (src.colorType()) {
case kN32_SkColorType:
- if (src.isOpaque()) return ToColor_S32_Opaque;
- return isPremultiplied ? ToColor_S32_Alpha : ToColor_S32_Raw;
+ switch (src.alphaType()) {
+ case kOpaque_SkAlphaType:
+ return ToColor_S32_Opaque;
+ case kPremul_SkAlphaType:
+ return ToColor_S32_Alpha;
+ case kUnpremul_SkAlphaType:
+ return ToColor_S32_Raw;
+ default:
+ return NULL;
+ }
case kARGB_4444_SkColorType:
- if (src.isOpaque()) return ToColor_S4444_Opaque;
- return isPremultiplied ? ToColor_S4444_Alpha : ToColor_S4444_Raw;
+ switch (src.alphaType()) {
+ case kOpaque_SkAlphaType:
+ return ToColor_S4444_Opaque;
+ case kPremul_SkAlphaType:
+ return ToColor_S4444_Alpha;
+ case kUnpremul_SkAlphaType:
+ return ToColor_S4444_Raw;
+ default:
+ return NULL;
+ }
case kRGB_565_SkColorType:
return ToColor_S565;
case kIndex_8_SkColorType:
if (src.getColorTable() == NULL) {
return NULL;
}
- if (src.isOpaque()) return ToColor_SI8_Opaque;
- return isPremultiplied ? ToColor_SI8_Raw : ToColor_SI8_Alpha;
+ switch (src.alphaType()) {
+ case kOpaque_SkAlphaType:
+ return ToColor_SI8_Opaque;
+ case kPremul_SkAlphaType:
+ return ToColor_SI8_Alpha;
+ case kUnpremul_SkAlphaType:
+ return ToColor_SI8_Raw;
+ default:
+ return NULL;
+ }
default:
break;
}
@@ -315,7 +340,7 @@
if (jColors != NULL) {
GraphicsJNI::SetPixels(env, jColors, offset, stride,
- 0, 0, width, height, bitmap, true);
+ 0, 0, width, height, bitmap);
}
return GraphicsJNI::createBitmap(env, new SkBitmap(bitmap), buff,
@@ -477,20 +502,38 @@
return static_cast<jint>(bitmap->getGenerationID());
}
+static jboolean Bitmap_isPremultiplied(JNIEnv* env, jobject, jlong bitmapHandle) {
+ SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
+ if (bitmap->alphaType() == kPremul_SkAlphaType) {
+ return JNI_TRUE;
+ }
+ return JNI_FALSE;
+}
+
static jboolean Bitmap_hasAlpha(JNIEnv* env, jobject, jlong bitmapHandle) {
SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
return !bitmap->isOpaque() ? JNI_TRUE : JNI_FALSE;
}
-static void Bitmap_setAlphaAndPremultiplied(JNIEnv* env, jobject, jlong bitmapHandle,
- jboolean hasAlpha, jboolean isPremul) {
+static void Bitmap_setHasAlpha(JNIEnv* env, jobject, jlong bitmapHandle,
+ jboolean hasAlpha, jboolean requestPremul) {
SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
- if (!hasAlpha) {
- bitmap->setAlphaType(kOpaque_SkAlphaType);
- } else if (isPremul) {
- bitmap->setAlphaType(kPremul_SkAlphaType);
+ if (hasAlpha) {
+ bitmap->setAlphaType(requestPremul ? kPremul_SkAlphaType : kUnpremul_SkAlphaType);
} else {
- bitmap->setAlphaType(kUnpremul_SkAlphaType);
+ bitmap->setAlphaType(kOpaque_SkAlphaType);
+ }
+}
+
+static void Bitmap_setPremultiplied(JNIEnv* env, jobject, jlong bitmapHandle,
+ jboolean isPremul) {
+ SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
+ if (!bitmap->isOpaque()) {
+ if (isPremul) {
+ bitmap->setAlphaType(kPremul_SkAlphaType);
+ } else {
+ bitmap->setAlphaType(kUnpremul_SkAlphaType);
+ }
}
}
@@ -661,11 +704,11 @@
///////////////////////////////////////////////////////////////////////////////
static jint Bitmap_getPixel(JNIEnv* env, jobject, jlong bitmapHandle,
- jint x, jint y, jboolean isPremultiplied) {
+ jint x, jint y) {
const SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
SkAutoLockPixels alp(*bitmap);
- ToColorProc proc = ChooseToColorProc(*bitmap, isPremultiplied);
+ ToColorProc proc = ChooseToColorProc(*bitmap);
if (NULL == proc) {
return 0;
}
@@ -681,11 +724,11 @@
static void Bitmap_getPixels(JNIEnv* env, jobject, jlong bitmapHandle,
jintArray pixelArray, jint offset, jint stride,
- jint x, jint y, jint width, jint height, jboolean isPremultiplied) {
+ jint x, jint y, jint width, jint height) {
const SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
SkAutoLockPixels alp(*bitmap);
- ToColorProc proc = ChooseToColorProc(*bitmap, isPremultiplied);
+ ToColorProc proc = ChooseToColorProc(*bitmap);
if (NULL == proc) {
return;
}
@@ -708,7 +751,7 @@
///////////////////////////////////////////////////////////////////////////////
static void Bitmap_setPixel(JNIEnv* env, jobject, jlong bitmapHandle,
- jint x, jint y, jint colorHandle, jboolean isPremultiplied) {
+ jint x, jint y, jint colorHandle) {
const SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
SkColor color = static_cast<SkColor>(colorHandle);
SkAutoLockPixels alp(*bitmap);
@@ -716,7 +759,7 @@
return;
}
- FromColorProc proc = ChooseFromColorProc(bitmap->config(), isPremultiplied);
+ FromColorProc proc = ChooseFromColorProc(*bitmap);
if (NULL == proc) {
return;
}
@@ -727,10 +770,10 @@
static void Bitmap_setPixels(JNIEnv* env, jobject, jlong bitmapHandle,
jintArray pixelArray, jint offset, jint stride,
- jint x, jint y, jint width, jint height, jboolean isPremultiplied) {
+ jint x, jint y, jint width, jint height) {
const SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
GraphicsJNI::SetPixels(env, pixelArray, offset, stride,
- x, y, width, height, *bitmap, isPremultiplied);
+ x, y, width, height, *bitmap);
}
static void Bitmap_copyPixelsToBuffer(JNIEnv* env, jobject,
@@ -834,7 +877,9 @@
{ "nativeRowBytes", "(J)I", (void*)Bitmap_rowBytes },
{ "nativeConfig", "(J)I", (void*)Bitmap_config },
{ "nativeHasAlpha", "(J)Z", (void*)Bitmap_hasAlpha },
- { "nativeSetAlphaAndPremultiplied", "(JZZ)V", (void*)Bitmap_setAlphaAndPremultiplied},
+ { "nativeIsPremultiplied", "(J)Z", (void*)Bitmap_isPremultiplied},
+ { "nativeSetHasAlpha", "(JZZ)V", (void*)Bitmap_setHasAlpha},
+ { "nativeSetPremultiplied", "(JZ)V", (void*)Bitmap_setPremultiplied},
{ "nativeHasMipMap", "(J)Z", (void*)Bitmap_hasMipMap },
{ "nativeSetHasMipMap", "(JZ)V", (void*)Bitmap_setHasMipMap },
{ "nativeCreateFromParcel",
@@ -845,10 +890,10 @@
{ "nativeExtractAlpha", "(JJ[I)Landroid/graphics/Bitmap;",
(void*)Bitmap_extractAlpha },
{ "nativeGenerationId", "(J)I", (void*)Bitmap_getGenerationId },
- { "nativeGetPixel", "(JIIZ)I", (void*)Bitmap_getPixel },
- { "nativeGetPixels", "(J[IIIIIIIZ)V", (void*)Bitmap_getPixels },
- { "nativeSetPixel", "(JIIIZ)V", (void*)Bitmap_setPixel },
- { "nativeSetPixels", "(J[IIIIIIIZ)V", (void*)Bitmap_setPixels },
+ { "nativeGetPixel", "(JII)I", (void*)Bitmap_getPixel },
+ { "nativeGetPixels", "(J[IIIIIII)V", (void*)Bitmap_getPixels },
+ { "nativeSetPixel", "(JIII)V", (void*)Bitmap_setPixel },
+ { "nativeSetPixels", "(J[IIIIIII)V", (void*)Bitmap_setPixels },
{ "nativeCopyPixelsToBuffer", "(JLjava/nio/Buffer;)V",
(void*)Bitmap_copyPixelsToBuffer },
{ "nativeCopyPixelsFromBuffer", "(JLjava/nio/Buffer;)V",
diff --git a/core/jni/android/graphics/Canvas.cpp b/core/jni/android/graphics/Canvas.cpp
index 3f323ab..6254f3d 100644
--- a/core/jni/android/graphics/Canvas.cpp
+++ b/core/jni/android/graphics/Canvas.cpp
@@ -24,6 +24,7 @@
#include "SkDeque.h"
#include "SkDrawFilter.h"
#include "SkGraphics.h"
+#include <SkImageInfo.h>
#include "SkPorterDuff.h"
#include "SkShader.h"
#include "SkTArray.h"
@@ -699,6 +700,8 @@
jboolean hasAlpha, jlong paintHandle) {
SkCanvas* canvas = getNativeCanvas(canvasHandle);
SkPaint* paint = reinterpret_cast<SkPaint*>(paintHandle);
+ // Note: If hasAlpha is false, kRGB_565_SkColorType will be used, which will
+ // correct the alphaType to kOpaque_SkAlphaType.
SkImageInfo info = SkImageInfo::Make(width, height,
hasAlpha ? kN32_SkColorType : kRGB_565_SkColorType,
kPremul_SkAlphaType);
@@ -708,7 +711,7 @@
}
if (!GraphicsJNI::SetPixels(env, jcolors, offset, stride,
- 0, 0, width, height, bitmap, true)) {
+ 0, 0, width, height, bitmap)) {
return;
}
diff --git a/core/jni/android/graphics/GraphicsJNI.h b/core/jni/android/graphics/GraphicsJNI.h
index 7fda3d9..0ad7fd8 100644
--- a/core/jni/android/graphics/GraphicsJNI.h
+++ b/core/jni/android/graphics/GraphicsJNI.h
@@ -90,10 +90,11 @@
/** Copy the colors in colors[] to the bitmap, convert to the correct
format along the way.
+ Whether to use premultiplied pixels is determined by dstBitmap's alphaType.
*/
static bool SetPixels(JNIEnv* env, jintArray colors, int srcOffset,
int srcStride, int x, int y, int width, int height,
- const SkBitmap& dstBitmap, bool isPremultiplied);
+ const SkBitmap& dstBitmap);
static jbyteArray getBitmapStorageObj(SkPixelRef *pixref);
};
diff --git a/core/jni/android_view_GLES20Canvas.cpp b/core/jni/android_view_GLES20Canvas.cpp
index b38f5f2..c352398 100644
--- a/core/jni/android_view_GLES20Canvas.cpp
+++ b/core/jni/android_view_GLES20Canvas.cpp
@@ -30,6 +30,7 @@
#include <SkBitmap.h>
#include <SkCanvas.h>
+#include <SkImageInfo.h>
#include <SkMatrix.h>
#include <SkPaint.h>
#include <SkPorterDuff.h>
@@ -376,6 +377,8 @@
static void android_view_GLES20Canvas_drawBitmapData(JNIEnv* env, jobject clazz,
jlong rendererPtr, jintArray colors, jint offset, jint stride,
jfloat left, jfloat top, jint width, jint height, jboolean hasAlpha, jlong paintPtr) {
+ // Note: If hasAlpha is false, kRGB_565_SkColorType will be used, which will
+ // correct the alphaType to kOpaque_SkAlphaType.
const SkImageInfo info = SkImageInfo::Make(width, height,
hasAlpha ? kN32_SkColorType : kRGB_565_SkColorType,
kPremul_SkAlphaType);
@@ -385,7 +388,7 @@
return;
}
- if (!GraphicsJNI::SetPixels(env, colors, offset, stride, 0, 0, width, height, *bitmap, true)) {
+ if (!GraphicsJNI::SetPixels(env, colors, offset, stride, 0, 0, width, height, *bitmap)) {
delete bitmap;
return;
}
diff --git a/graphics/java/android/graphics/Bitmap.java b/graphics/java/android/graphics/Bitmap.java
index ef0a411..9d7ef45 100644
--- a/graphics/java/android/graphics/Bitmap.java
+++ b/graphics/java/android/graphics/Bitmap.java
@@ -59,14 +59,18 @@
private final boolean mIsMutable;
/**
- * Represents whether the Bitmap's content is expected to be pre-multiplied.
+ * Represents whether the Bitmap's content is requested to be pre-multiplied.
* Note that isPremultiplied() does not directly return this value, because
- * isPremultiplied() may never return true for a 565 Bitmap.
+ * isPremultiplied() may never return true for a 565 Bitmap or a bitmap
+ * without alpha.
*
* setPremultiplied() does directly set the value so that setConfig() and
* setPremultiplied() aren't order dependent, despite being setters.
+ *
+ * The native bitmap's premultiplication state is kept up to date by
+ * pushing down this preference for every config change.
*/
- private boolean mIsPremultiplied;
+ private boolean mRequestPremultiplied;
private byte[] mNinePatchChunk; // may be null
private int[] mLayoutBounds; // may be null
@@ -105,7 +109,7 @@
*/
@SuppressWarnings({"UnusedDeclaration"}) // called from JNI
Bitmap(long nativeBitmap, byte[] buffer, int width, int height, int density,
- boolean isMutable, boolean isPremultiplied,
+ boolean isMutable, boolean requestPremultiplied,
byte[] ninePatchChunk, int[] layoutBounds) {
if (nativeBitmap == 0) {
throw new RuntimeException("internal error: native bitmap is 0");
@@ -114,7 +118,7 @@
mWidth = width;
mHeight = height;
mIsMutable = isMutable;
- mIsPremultiplied = isPremultiplied;
+ mRequestPremultiplied = requestPremultiplied;
mBuffer = buffer;
// we delete this in our finalizer
mNativeBitmap = nativeBitmap;
@@ -132,10 +136,10 @@
* width/height values
*/
@SuppressWarnings({"UnusedDeclaration"}) // called from JNI
- void reinit(int width, int height, boolean isPremultiplied) {
+ void reinit(int width, int height, boolean requestPremultiplied) {
mWidth = width;
mHeight = height;
- mIsPremultiplied = isPremultiplied;
+ mRequestPremultiplied = requestPremultiplied;
}
/**
@@ -223,7 +227,7 @@
}
nativeReconfigure(mNativeBitmap, width, height, config.nativeInt, mBuffer.length,
- mIsPremultiplied);
+ mRequestPremultiplied);
mWidth = width;
mHeight = height;
}
@@ -561,7 +565,7 @@
checkRecycled("Can't copy a recycled bitmap");
Bitmap b = nativeCopy(mNativeBitmap, config.nativeInt, isMutable);
if (b != null) {
- b.setAlphaAndPremultiplied(hasAlpha(), mIsPremultiplied);
+ b.setPremultiplied(mRequestPremultiplied);
b.mDensity = mDensity;
}
return b;
@@ -738,7 +742,8 @@
// The new bitmap was created from a known bitmap source so assume that
// they use the same density
bitmap.mDensity = source.mDensity;
- bitmap.setAlphaAndPremultiplied(source.hasAlpha(), source.mIsPremultiplied);
+ bitmap.setHasAlpha(source.hasAlpha());
+ bitmap.setPremultiplied(source.mRequestPremultiplied);
canvas.setBitmap(bitmap);
canvas.drawBitmap(source, srcR, dstR, paint);
@@ -1018,6 +1023,9 @@
* <p>This method always returns false if {@link #getConfig()} is
* {@link Bitmap.Config#RGB_565}.</p>
*
+ * <p>The return value is undefined if {@link #getConfig()} is
+ * {@link Bitmap.Config#ALPHA_8}.</p>
+ *
* <p>This method only returns true if {@link #hasAlpha()} returns true.
* A bitmap with no alpha channel can be used both as a pre-multiplied and
* as a non pre-multiplied bitmap.</p>
@@ -1033,7 +1041,7 @@
* @see BitmapFactory.Options#inPremultiplied
*/
public final boolean isPremultiplied() {
- return mIsPremultiplied && getConfig() != Config.RGB_565 && hasAlpha();
+ return nativeIsPremultiplied(mNativeBitmap);
}
/**
@@ -1057,14 +1065,8 @@
* @see BitmapFactory.Options#inPremultiplied
*/
public final void setPremultiplied(boolean premultiplied) {
- mIsPremultiplied = premultiplied;
- nativeSetAlphaAndPremultiplied(mNativeBitmap, hasAlpha(), premultiplied);
- }
-
- /** Helper function to set both alpha and premultiplied. **/
- private final void setAlphaAndPremultiplied(boolean hasAlpha, boolean premultiplied) {
- mIsPremultiplied = premultiplied;
- nativeSetAlphaAndPremultiplied(mNativeBitmap, hasAlpha, premultiplied);
+ mRequestPremultiplied = premultiplied;
+ nativeSetPremultiplied(mNativeBitmap, premultiplied);
}
/** Returns the bitmap's width */
@@ -1225,7 +1227,7 @@
* non-opaque per-pixel alpha values.
*/
public void setHasAlpha(boolean hasAlpha) {
- nativeSetAlphaAndPremultiplied(mNativeBitmap, hasAlpha, mIsPremultiplied);
+ nativeSetHasAlpha(mNativeBitmap, hasAlpha, mRequestPremultiplied);
}
/**
@@ -1299,7 +1301,7 @@
public int getPixel(int x, int y) {
checkRecycled("Can't call getPixel() on a recycled bitmap");
checkPixelAccess(x, y);
- return nativeGetPixel(mNativeBitmap, x, y, mIsPremultiplied);
+ return nativeGetPixel(mNativeBitmap, x, y);
}
/**
@@ -1333,7 +1335,7 @@
}
checkPixelsAccess(x, y, width, height, offset, stride, pixels);
nativeGetPixels(mNativeBitmap, pixels, offset, stride,
- x, y, width, height, mIsPremultiplied);
+ x, y, width, height);
}
/**
@@ -1413,7 +1415,7 @@
throw new IllegalStateException();
}
checkPixelAccess(x, y);
- nativeSetPixel(mNativeBitmap, x, y, color, mIsPremultiplied);
+ nativeSetPixel(mNativeBitmap, x, y, color);
}
/**
@@ -1450,7 +1452,7 @@
}
checkPixelsAccess(x, y, width, height, offset, stride, pixels);
nativeSetPixels(mNativeBitmap, pixels, offset, stride,
- x, y, width, height, mIsPremultiplied);
+ x, y, width, height);
}
public static final Parcelable.Creator<Bitmap> CREATOR
@@ -1602,17 +1604,15 @@
private static native int nativeRowBytes(long nativeBitmap);
private static native int nativeConfig(long nativeBitmap);
- private static native int nativeGetPixel(long nativeBitmap, int x, int y,
- boolean isPremultiplied);
+ private static native int nativeGetPixel(long nativeBitmap, int x, int y);
private static native void nativeGetPixels(long nativeBitmap, int[] pixels,
int offset, int stride, int x, int y,
- int width, int height, boolean isPremultiplied);
+ int width, int height);
- private static native void nativeSetPixel(long nativeBitmap, int x, int y,
- int color, boolean isPremultiplied);
+ private static native void nativeSetPixel(long nativeBitmap, int x, int y, int color);
private static native void nativeSetPixels(long nativeBitmap, int[] colors,
int offset, int stride, int x, int y,
- int width, int height, boolean isPremultiplied);
+ int width, int height);
private static native void nativeCopyPixelsToBuffer(long nativeBitmap,
Buffer dst);
private static native void nativeCopyPixelsFromBuffer(long nativeBitmap, Buffer src);
@@ -1631,9 +1631,12 @@
private static native void nativePrepareToDraw(long nativeBitmap);
private static native boolean nativeHasAlpha(long nativeBitmap);
- private static native void nativeSetAlphaAndPremultiplied(long nativeBitmap,
- boolean hasAlpha,
- boolean isPremul);
+ private static native boolean nativeIsPremultiplied(long nativeBitmap);
+ private static native void nativeSetPremultiplied(long nativeBitmap,
+ boolean isPremul);
+ private static native void nativeSetHasAlpha(long nativeBitmap,
+ boolean hasAlpha,
+ boolean requestPremul);
private static native boolean nativeHasMipMap(long nativeBitmap);
private static native void nativeSetHasMipMap(long nativeBitmap, boolean hasMipMap);
private static native boolean nativeSameAs(long nativeBitmap0, long nativeBitmap1);