blob: 10c287d1e07df5fbf427d3f5ca94a27fe52943e4 [file] [log] [blame]
Derek Sollenberger5368eda2019-10-25 11:20:03 -04001#undef LOG_TAG
John Reckf29ed282015-04-07 07:32:03 -07002#define LOG_TAG "Bitmap"
John Reckf29ed282015-04-07 07:32:03 -07003#include "Bitmap.h"
4
Nader Jawad7612c612022-11-15 10:55:54 -08005#include <hwui/Bitmap.h>
6#include <hwui/Paint.h>
7
8#include "CreateJavaOutputStreamAdaptor.h"
John Reck5bd537e2023-01-24 20:13:45 -05009#include "Gainmap.h"
Kevin Lubick1175dc02022-02-28 12:41:27 -050010#include "GraphicsJNI.h"
Nader Jawad7612c612022-11-15 10:55:54 -080011#include "HardwareBufferHelpers.h"
Chris Craik32054b02014-05-09 13:58:56 -070012#include "SkBitmap.h"
Kevin Lubick1175dc02022-02-28 12:41:27 -050013#include "SkBlendMode.h"
John Reckbe671952021-01-13 22:39:32 -050014#include "SkCanvas.h"
15#include "SkColor.h"
16#include "SkColorSpace.h"
Kevin Lubick1175dc02022-02-28 12:41:27 -050017#include "SkData.h"
Leon Scroggins III57ee6202014-06-04 18:51:07 -040018#include "SkImageInfo.h"
Kevin Lubick1175dc02022-02-28 12:41:27 -050019#include "SkPaint.h"
Kevin Lubick1175dc02022-02-28 12:41:27 -050020#include "SkPixmap.h"
21#include "SkPoint.h"
22#include "SkRefCnt.h"
Chris Craik32054b02014-05-09 13:58:56 -070023#include "SkStream.h"
Kevin Lubick1175dc02022-02-28 12:41:27 -050024#include "SkTypes.h"
Chris Craik32054b02014-05-09 13:58:56 -070025#include "android_nio_utils.h"
Chris Craik32054b02014-05-09 13:58:56 -070026
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +010027#ifdef __ANDROID__ // Layoutlib does not support graphic buffer, parcel or render thread
John Recka18d7c82020-03-02 09:41:33 -080028#include <android-base/unique_fd.h>
29#include <android/binder_parcel.h>
30#include <android/binder_parcel_jni.h>
31#include <android/binder_parcel_platform.h>
John Recka18d7c82020-03-02 09:41:33 -080032#include <cutils/ashmem.h>
Leon Scroggins III5a190b12020-02-18 13:52:18 -050033#include <renderthread/RenderProxy.h>
John Recka18d7c82020-03-02 09:41:33 -080034#include <sys/mman.h>
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +010035#endif
rennb2e9f522018-09-26 10:49:00 -070036
John Recka18d7c82020-03-02 09:41:33 -080037#include <inttypes.h>
Romain Guyce217fa2017-03-08 15:58:06 -080038#include <string.h>
Nader Jawad7612c612022-11-15 10:55:54 -080039
Riley Andrews39d7f302014-11-13 17:43:25 -080040#include <memory>
Chris Craik32054b02014-05-09 13:58:56 -070041
Jeff Browna316c5d2015-06-05 15:14:06 -070042#define DEBUG_PARCEL 0
43
sergeyvc69853c2016-10-07 14:14:09 -070044static jclass gBitmap_class;
45static jfieldID gBitmap_nativePtr;
46static jmethodID gBitmap_constructorMethodID;
47static jmethodID gBitmap_reinitMethodID;
sergeyvc69853c2016-10-07 14:14:09 -070048
John Reckf29ed282015-04-07 07:32:03 -070049namespace android {
50
John Reck5bd537e2023-01-24 20:13:45 -050051jobject Gainmap_extractFromBitmap(JNIEnv* env, const Bitmap& bitmap);
52
sergeyvc1c54062016-10-19 18:47:26 -070053class BitmapWrapper {
John Reckf29ed282015-04-07 07:32:03 -070054public:
Chih-Hung Hsieh0727be12018-12-20 13:43:46 -080055 explicit BitmapWrapper(Bitmap* bitmap)
sergeyvc1c54062016-10-19 18:47:26 -070056 : mBitmap(bitmap) { }
sergeyvc69853c2016-10-07 14:14:09 -070057
58 void freePixels() {
sergeyvc1c54062016-10-19 18:47:26 -070059 mInfo = mBitmap->info();
60 mHasHardwareMipMap = mBitmap->hasHardwareMipMap();
61 mAllocationSize = mBitmap->getAllocationByteCount();
62 mRowBytes = mBitmap->rowBytes();
63 mGenerationId = mBitmap->getGenerationID();
sergeyv15a10852016-12-27 14:32:03 -080064 mIsHardware = mBitmap->isHardware();
sergeyvc1c54062016-10-19 18:47:26 -070065 mBitmap.reset();
John Reckf29ed282015-04-07 07:32:03 -070066 }
67
sergeyvc69853c2016-10-07 14:14:09 -070068 bool valid() {
Ben Wagner6b62ac02018-05-29 14:16:02 -040069 return mBitmap != nullptr;
John Reckf29ed282015-04-07 07:32:03 -070070 }
71
sergeyvaed7f582016-10-14 16:30:21 -070072 Bitmap& bitmap() {
73 assertValid();
74 return *mBitmap;
75 }
sergeyvc69853c2016-10-07 14:14:09 -070076
77 void assertValid() {
78 LOG_ALWAYS_FATAL_IF(!valid(), "Error, cannot access an invalid/free'd bitmap here!");
79 }
80
81 void getSkBitmap(SkBitmap* outBitmap) {
82 assertValid();
sergeyvc1c54062016-10-19 18:47:26 -070083 mBitmap->getSkBitmap(outBitmap);
sergeyvc69853c2016-10-07 14:14:09 -070084 }
85
86 bool hasHardwareMipMap() {
sergeyvc1c54062016-10-19 18:47:26 -070087 if (mBitmap) {
88 return mBitmap->hasHardwareMipMap();
John Reckf29ed282015-04-07 07:32:03 -070089 }
John Reckf29ed282015-04-07 07:32:03 -070090 return mHasHardwareMipMap;
91 }
92
93 void setHasHardwareMipMap(bool hasMipMap) {
sergeyvc69853c2016-10-07 14:14:09 -070094 assertValid();
sergeyvc1c54062016-10-19 18:47:26 -070095 mBitmap->setHasHardwareMipMap(hasMipMap);
John Reckf29ed282015-04-07 07:32:03 -070096 }
97
sergeyvc69853c2016-10-07 14:14:09 -070098 void setAlphaType(SkAlphaType alphaType) {
99 assertValid();
sergeyvc1c54062016-10-19 18:47:26 -0700100 mBitmap->setAlphaType(alphaType);
John Reckf29ed282015-04-07 07:32:03 -0700101 }
102
Derek Sollenberger202084c2019-01-14 13:55:08 -0500103 void setColorSpace(sk_sp<SkColorSpace> colorSpace) {
104 assertValid();
105 mBitmap->setColorSpace(colorSpace);
106 }
107
sergeyvc69853c2016-10-07 14:14:09 -0700108 const SkImageInfo& info() {
sergeyvc1c54062016-10-19 18:47:26 -0700109 if (mBitmap) {
110 return mBitmap->info();
sergeyvc69853c2016-10-07 14:14:09 -0700111 }
112 return mInfo;
John Reckf29ed282015-04-07 07:32:03 -0700113 }
114
sergeyvc69853c2016-10-07 14:14:09 -0700115 size_t getAllocationByteCount() const {
sergeyvc1c54062016-10-19 18:47:26 -0700116 if (mBitmap) {
117 return mBitmap->getAllocationByteCount();
sergeyvc69853c2016-10-07 14:14:09 -0700118 }
119 return mAllocationSize;
John Reckf29ed282015-04-07 07:32:03 -0700120 }
121
sergeyvc69853c2016-10-07 14:14:09 -0700122 size_t rowBytes() const {
sergeyvc1c54062016-10-19 18:47:26 -0700123 if (mBitmap) {
124 return mBitmap->rowBytes();
sergeyvc69853c2016-10-07 14:14:09 -0700125 }
126 return mRowBytes;
127 }
128
129 uint32_t getGenerationID() const {
sergeyvc1c54062016-10-19 18:47:26 -0700130 if (mBitmap) {
131 return mBitmap->getGenerationID();
sergeyvc69853c2016-10-07 14:14:09 -0700132 }
133 return mGenerationId;
134 }
135
sergeyv15a10852016-12-27 14:32:03 -0800136 bool isHardware() {
137 if (mBitmap) {
138 return mBitmap->isHardware();
139 }
140 return mIsHardware;
141 }
142
sergeyvc1c54062016-10-19 18:47:26 -0700143 ~BitmapWrapper() { }
sergeyvc69853c2016-10-07 14:14:09 -0700144
John Reckf29ed282015-04-07 07:32:03 -0700145private:
sergeyvc1c54062016-10-19 18:47:26 -0700146 sk_sp<Bitmap> mBitmap;
sergeyvc69853c2016-10-07 14:14:09 -0700147 SkImageInfo mInfo;
148 bool mHasHardwareMipMap;
149 size_t mAllocationSize;
150 size_t mRowBytes;
151 uint32_t mGenerationId;
sergeyv15a10852016-12-27 14:32:03 -0800152 bool mIsHardware;
John Reckf29ed282015-04-07 07:32:03 -0700153};
154
John Reckf29ed282015-04-07 07:32:03 -0700155// Convenience class that does not take a global ref on the pixels, relying
156// on the caller already having a local JNI ref
157class LocalScopedBitmap {
158public:
Chih-Hung Hsiehc6baf562016-04-27 11:29:23 -0700159 explicit LocalScopedBitmap(jlong bitmapHandle)
sergeyvc1c54062016-10-19 18:47:26 -0700160 : mBitmapWrapper(reinterpret_cast<BitmapWrapper*>(bitmapHandle)) {}
John Reckf29ed282015-04-07 07:32:03 -0700161
sergeyvc1c54062016-10-19 18:47:26 -0700162 BitmapWrapper* operator->() {
163 return mBitmapWrapper;
John Reckf29ed282015-04-07 07:32:03 -0700164 }
165
166 void* pixels() {
sergeyvaed7f582016-10-14 16:30:21 -0700167 return mBitmapWrapper->bitmap().pixels();
John Reckf29ed282015-04-07 07:32:03 -0700168 }
169
170 bool valid() {
sergeyvc1c54062016-10-19 18:47:26 -0700171 return mBitmapWrapper && mBitmapWrapper->valid();
John Reckf29ed282015-04-07 07:32:03 -0700172 }
173
174private:
sergeyvc1c54062016-10-19 18:47:26 -0700175 BitmapWrapper* mBitmapWrapper;
John Reckf29ed282015-04-07 07:32:03 -0700176};
177
sergeyvc69853c2016-10-07 14:14:09 -0700178namespace bitmap {
179
180// Assert that bitmap's SkAlphaType is consistent with isPremultiplied.
181static void assert_premultiplied(const SkImageInfo& info, bool isPremultiplied) {
182 // kOpaque_SkAlphaType and kIgnore_SkAlphaType mean that isPremultiplied is
183 // irrelevant. This just tests to ensure that the SkAlphaType is not
184 // opposite of isPremultiplied.
185 if (isPremultiplied) {
186 SkASSERT(info.alphaType() != kUnpremul_SkAlphaType);
187 } else {
188 SkASSERT(info.alphaType() != kPremul_SkAlphaType);
189 }
190}
191
192void reinitBitmap(JNIEnv* env, jobject javaBitmap, const SkImageInfo& info,
193 bool isPremultiplied)
194{
195 // The caller needs to have already set the alpha type properly, so the
196 // native SkBitmap stays in sync with the Java Bitmap.
197 assert_premultiplied(info, isPremultiplied);
198
199 env->CallVoidMethod(javaBitmap, gBitmap_reinitMethodID,
200 info.width(), info.height(), isPremultiplied);
201}
202
sergeyvc1c54062016-10-19 18:47:26 -0700203jobject createBitmap(JNIEnv* env, Bitmap* bitmap,
sergeyvc69853c2016-10-07 14:14:09 -0700204 int bitmapCreateFlags, jbyteArray ninePatchChunk, jobject ninePatchInsets,
205 int density) {
206 bool isMutable = bitmapCreateFlags & kBitmapCreateFlag_Mutable;
207 bool isPremultiplied = bitmapCreateFlags & kBitmapCreateFlag_Premultiplied;
208 // The caller needs to have already set the alpha type properly, so the
209 // native SkBitmap stays in sync with the Java Bitmap.
sergeyvc1c54062016-10-19 18:47:26 -0700210 assert_premultiplied(bitmap->info(), isPremultiplied);
Leon Scroggins IIIbbdb7312019-01-31 14:35:54 -0500211 bool fromMalloc = bitmap->pixelStorageType() == PixelStorageType::Heap;
sergeyvc1c54062016-10-19 18:47:26 -0700212 BitmapWrapper* bitmapWrapper = new BitmapWrapper(bitmap);
Nader Jawade7b51292018-04-12 17:55:31 -0700213 if (!isMutable) {
214 bitmapWrapper->bitmap().setImmutable();
215 }
sergeyvc69853c2016-10-07 14:14:09 -0700216 jobject obj = env->NewObject(gBitmap_class, gBitmap_constructorMethodID,
sergeyvc1c54062016-10-19 18:47:26 -0700217 reinterpret_cast<jlong>(bitmapWrapper), bitmap->width(), bitmap->height(), density,
Leon Scroggins IIIbbdb7312019-01-31 14:35:54 -0500218 isPremultiplied, ninePatchChunk, ninePatchInsets, fromMalloc);
sergeyvc69853c2016-10-07 14:14:09 -0700219
220 if (env->ExceptionCheck() != 0) {
221 ALOGE("*** Uncaught exception returned from Java call!\n");
222 env->ExceptionDescribe();
223 }
224 return obj;
225}
226
227void toSkBitmap(jlong bitmapHandle, SkBitmap* outBitmap) {
228 LocalScopedBitmap bitmap(bitmapHandle);
229 bitmap->getSkBitmap(outBitmap);
230}
231
Leon Scroggins III71fae622019-03-26 16:28:41 -0400232Bitmap& toBitmap(jlong bitmapHandle) {
sergeyv5fd2a1c2016-10-20 15:04:28 -0700233 LocalScopedBitmap localBitmap(bitmapHandle);
234 return localBitmap->bitmap();
235}
236
sergeyvc69853c2016-10-07 14:14:09 -0700237} // namespace bitmap
238
239} // namespace android
240
241using namespace android;
242using namespace android::bitmap;
243
Derek Sollenberger6c41ab12019-11-08 08:50:58 -0500244Bitmap* GraphicsJNI::getNativeBitmap(JNIEnv* env, jobject bitmap) {
245 SkASSERT(env);
246 SkASSERT(bitmap);
247 SkASSERT(env->IsInstanceOf(bitmap, gBitmap_class));
248 jlong bitmapHandle = env->GetLongField(bitmap, gBitmap_nativePtr);
249 LocalScopedBitmap localBitmap(bitmapHandle);
250 return localBitmap.valid() ? &localBitmap->bitmap() : nullptr;
251}
252
Leon Scroggins III84a2afc2020-01-19 19:27:16 -0500253SkImageInfo GraphicsJNI::getBitmapInfo(JNIEnv* env, jobject bitmap, uint32_t* outRowBytes,
254 bool* isHardware) {
Derek Sollenberger6c41ab12019-11-08 08:50:58 -0500255 SkASSERT(env);
256 SkASSERT(bitmap);
257 SkASSERT(env->IsInstanceOf(bitmap, gBitmap_class));
258 jlong bitmapHandle = env->GetLongField(bitmap, gBitmap_nativePtr);
259 LocalScopedBitmap localBitmap(bitmapHandle);
260 if (outRowBytes) {
261 *outRowBytes = localBitmap->rowBytes();
262 }
Leon Scroggins III84a2afc2020-01-19 19:27:16 -0500263 if (isHardware) {
264 *isHardware = localBitmap->isHardware();
265 }
Derek Sollenberger6c41ab12019-11-08 08:50:58 -0500266 return localBitmap->info();
267}
268
Chris Craik32054b02014-05-09 13:58:56 -0700269bool GraphicsJNI::SetPixels(JNIEnv* env, jintArray srcColors, int srcOffset, int srcStride,
Brian Osman91c9c282018-08-17 16:57:15 -0400270 int x, int y, int width, int height, SkBitmap* dstBitmap) {
Chris Craik32054b02014-05-09 13:58:56 -0700271 const jint* array = env->GetIntArrayElements(srcColors, NULL);
272 const SkColor* src = (const SkColor*)array + srcOffset;
273
Brian Osman91c9c282018-08-17 16:57:15 -0400274 auto sRGB = SkColorSpace::MakeSRGB();
275 SkImageInfo srcInfo = SkImageInfo::Make(
276 width, height, kBGRA_8888_SkColorType, kUnpremul_SkAlphaType, sRGB);
277 SkPixmap srcPM(srcInfo, src, srcStride * 4);
Romain Guyce217fa2017-03-08 15:58:06 -0800278
Brian Osman91c9c282018-08-17 16:57:15 -0400279 dstBitmap->writePixels(srcPM, x, y);
Chris Craik32054b02014-05-09 13:58:56 -0700280
Romain Guy9505a652016-12-14 09:43:50 -0800281 env->ReleaseIntArrayElements(srcColors, const_cast<jint*>(array), JNI_ABORT);
Chris Craik32054b02014-05-09 13:58:56 -0700282 return true;
283}
284
Chris Craik32054b02014-05-09 13:58:56 -0700285///////////////////////////////////////////////////////////////////////////////
286///////////////////////////////////////////////////////////////////////////////
287
288static int getPremulBitmapCreateFlags(bool isMutable) {
sergeyvc69853c2016-10-07 14:14:09 -0700289 int flags = android::bitmap::kBitmapCreateFlag_Premultiplied;
290 if (isMutable) flags |= android::bitmap::kBitmapCreateFlag_Mutable;
Chris Craik32054b02014-05-09 13:58:56 -0700291 return flags;
292}
293
294static jobject Bitmap_creator(JNIEnv* env, jobject, jintArray jColors,
295 jint offset, jint stride, jint width, jint height,
Romain Guy82426562017-04-04 19:38:50 -0700296 jint configHandle, jboolean isMutable,
Leon Scroggins III0e443d12018-12-19 11:38:35 -0500297 jlong colorSpacePtr) {
Mike Reed1103b322014-07-08 12:36:44 -0400298 SkColorType colorType = GraphicsJNI::legacyBitmapConfigToColorType(configHandle);
Chris Craik32054b02014-05-09 13:58:56 -0700299 if (NULL != jColors) {
300 size_t n = env->GetArrayLength(jColors);
301 if (n < SkAbs32(stride) * (size_t)height) {
302 doThrowAIOOBE(env);
303 return NULL;
304 }
305 }
306
307 // ARGB_4444 is a deprecated format, convert automatically to 8888
Mike Reedb9330552014-06-16 17:31:48 -0400308 if (colorType == kARGB_4444_SkColorType) {
309 colorType = kN32_SkColorType;
Chris Craik32054b02014-05-09 13:58:56 -0700310 }
311
Derek Sollenbergerbf3e4642019-01-30 11:28:27 -0500312 sk_sp<SkColorSpace> colorSpace;
313 if (colorType == kAlpha_8_SkColorType) {
314 colorSpace = nullptr;
315 } else {
316 colorSpace = GraphicsJNI::getNativeColorSpace(colorSpacePtr);
317 }
318
Chris Craik32054b02014-05-09 13:58:56 -0700319 SkBitmap bitmap;
Leon Scroggins III0e443d12018-12-19 11:38:35 -0500320 bitmap.setInfo(SkImageInfo::Make(width, height, colorType, kPremul_SkAlphaType,
Derek Sollenbergerbf3e4642019-01-30 11:28:27 -0500321 colorSpace));
Chris Craik32054b02014-05-09 13:58:56 -0700322
Leon Scroggins IIIf51a80d2017-07-12 10:46:35 -0400323 sk_sp<Bitmap> nativeBitmap = Bitmap::allocateHeapBitmap(&bitmap);
John Reckf29ed282015-04-07 07:32:03 -0700324 if (!nativeBitmap) {
Leon Scroggins IIIf3a02992017-10-03 14:00:20 -0400325 ALOGE("OOM allocating Bitmap with dimensions %i x %i", width, height);
326 doThrowOOME(env);
Chris Craik32054b02014-05-09 13:58:56 -0700327 return NULL;
328 }
329
330 if (jColors != NULL) {
Brian Osman91c9c282018-08-17 16:57:15 -0400331 GraphicsJNI::SetPixels(env, jColors, offset, stride, 0, 0, width, height, &bitmap);
Chris Craik32054b02014-05-09 13:58:56 -0700332 }
333
sergeyvc36bd6c2016-10-11 15:49:16 -0700334 return createBitmap(env, nativeBitmap.release(), getPremulBitmapCreateFlags(isMutable));
Chris Craik32054b02014-05-09 13:58:56 -0700335}
336
Matt Sarett5320a722017-03-20 13:51:29 -0400337static bool bitmapCopyTo(SkBitmap* dst, SkColorType dstCT, const SkBitmap& src,
338 SkBitmap::Allocator* alloc) {
Matt Sarette9834402017-04-25 13:49:42 -0400339 SkPixmap srcPM;
340 if (!src.peekPixels(&srcPM)) {
341 return false;
342 }
343
344 SkImageInfo dstInfo = srcPM.info().makeColorType(dstCT);
345 switch (dstCT) {
346 case kRGB_565_SkColorType:
Brian Osmanbaf13e82018-09-21 11:21:30 -0400347 dstInfo = dstInfo.makeAlphaType(kOpaque_SkAlphaType);
Matt Sarette9834402017-04-25 13:49:42 -0400348 break;
Derek Sollenbergerbf3e4642019-01-30 11:28:27 -0500349 case kAlpha_8_SkColorType:
350 dstInfo = dstInfo.makeColorSpace(nullptr);
Matt Sarette9834402017-04-25 13:49:42 -0400351 break;
352 default:
353 break;
354 }
355
Derek Sollenbergerbf3e4642019-01-30 11:28:27 -0500356 if (!dstInfo.colorSpace() && dstCT != kAlpha_8_SkColorType) {
357 dstInfo = dstInfo.makeColorSpace(SkColorSpace::MakeSRGB());
358 }
359
Matt Sarette9834402017-04-25 13:49:42 -0400360 if (!dst->setInfo(dstInfo)) {
361 return false;
362 }
Mike Reed81397c42017-07-18 17:04:16 -0400363 if (!dst->tryAllocPixels(alloc)) {
Matt Sarette9834402017-04-25 13:49:42 -0400364 return false;
365 }
366
Matt Sarette9834402017-04-25 13:49:42 -0400367 SkPixmap dstPM;
368 if (!dst->peekPixels(&dstPM)) {
369 return false;
370 }
371
Matt Sarette9834402017-04-25 13:49:42 -0400372 return srcPM.readPixels(dstPM);
Matt Sarett5320a722017-03-20 13:51:29 -0400373}
374
Chris Craik32054b02014-05-09 13:58:56 -0700375static jobject Bitmap_copy(JNIEnv* env, jobject, jlong srcHandle,
376 jint dstConfigHandle, jboolean isMutable) {
John Reckf29ed282015-04-07 07:32:03 -0700377 SkBitmap src;
sergeyvc1c54062016-10-19 18:47:26 -0700378 reinterpret_cast<BitmapWrapper*>(srcHandle)->getSkBitmap(&src);
sergeyv05126d12016-12-15 19:50:15 -0800379 if (dstConfigHandle == GraphicsJNI::hardwareLegacyBitmapConfig()) {
380 sk_sp<Bitmap> bitmap(Bitmap::allocateHardwareBitmap(src));
381 if (!bitmap.get()) {
382 return NULL;
383 }
sergeyv656117b2017-02-28 15:25:10 -0800384 return createBitmap(env, bitmap.release(), getPremulBitmapCreateFlags(isMutable));
sergeyv05126d12016-12-15 19:50:15 -0800385 }
386
Mike Reed1103b322014-07-08 12:36:44 -0400387 SkColorType dstCT = GraphicsJNI::legacyBitmapConfigToColorType(dstConfigHandle);
sergeyv45082182016-09-29 18:25:40 -0700388 SkBitmap result;
389 HeapAllocator allocator;
Chris Craik32054b02014-05-09 13:58:56 -0700390
Matt Sarett5320a722017-03-20 13:51:29 -0400391 if (!bitmapCopyTo(&result, dstCT, src, &allocator)) {
Chris Craik32054b02014-05-09 13:58:56 -0700392 return NULL;
393 }
sergeyvc1c54062016-10-19 18:47:26 -0700394 auto bitmap = allocator.getStorageObjAndReset();
395 return createBitmap(env, bitmap, getPremulBitmapCreateFlags(isMutable));
Chris Craik32054b02014-05-09 13:58:56 -0700396}
397
sergeyvc1c54062016-10-19 18:47:26 -0700398static Bitmap* Bitmap_copyAshmemImpl(JNIEnv* env, SkBitmap& src, SkColorType& dstCT) {
Riley Andrews721ae5f2015-05-11 16:08:22 -0700399 SkBitmap result;
400
401 AshmemPixelAllocator allocator(env);
Matt Sarett5320a722017-03-20 13:51:29 -0400402 if (!bitmapCopyTo(&result, dstCT, src, &allocator)) {
Riley Andrews721ae5f2015-05-11 16:08:22 -0700403 return NULL;
404 }
sergeyvc1c54062016-10-19 18:47:26 -0700405 auto bitmap = allocator.getStorageObjAndReset();
406 bitmap->setImmutable();
407 return bitmap;
Winsona5fdde92016-04-14 15:27:15 -0700408}
409
410static jobject Bitmap_copyAshmem(JNIEnv* env, jobject, jlong srcHandle) {
411 SkBitmap src;
sergeyvc1c54062016-10-19 18:47:26 -0700412 reinterpret_cast<BitmapWrapper*>(srcHandle)->getSkBitmap(&src);
Winsona5fdde92016-04-14 15:27:15 -0700413 SkColorType dstCT = src.colorType();
sergeyvc1c54062016-10-19 18:47:26 -0700414 auto bitmap = Bitmap_copyAshmemImpl(env, src, dstCT);
415 jobject ret = createBitmap(env, bitmap, getPremulBitmapCreateFlags(false));
Winsona5fdde92016-04-14 15:27:15 -0700416 return ret;
417}
418
419static jobject Bitmap_copyAshmemConfig(JNIEnv* env, jobject, jlong srcHandle, jint dstConfigHandle) {
420 SkBitmap src;
sergeyvc1c54062016-10-19 18:47:26 -0700421 reinterpret_cast<BitmapWrapper*>(srcHandle)->getSkBitmap(&src);
Winsona5fdde92016-04-14 15:27:15 -0700422 SkColorType dstCT = GraphicsJNI::legacyBitmapConfigToColorType(dstConfigHandle);
sergeyvc1c54062016-10-19 18:47:26 -0700423 auto bitmap = Bitmap_copyAshmemImpl(env, src, dstCT);
424 jobject ret = createBitmap(env, bitmap, getPremulBitmapCreateFlags(false));
Riley Andrews721ae5f2015-05-11 16:08:22 -0700425 return ret;
426}
427
Derek Sollenberger3a269b02022-12-12 15:22:07 -0500428static jint Bitmap_getAshmemFd(JNIEnv* env, jobject, jlong bitmapHandle) {
429 LocalScopedBitmap bitmap(bitmapHandle);
430 return (bitmap.valid()) ? bitmap->bitmap().getAshmemFd() : -1;
431}
432
sergeyvc1c54062016-10-19 18:47:26 -0700433static void Bitmap_destruct(BitmapWrapper* bitmap) {
sergeyvc69853c2016-10-07 14:14:09 -0700434 delete bitmap;
Chris Craik32054b02014-05-09 13:58:56 -0700435}
436
Richard Uhler775873a2015-12-29 12:37:39 -0800437static jlong Bitmap_getNativeFinalizer(JNIEnv*, jobject) {
438 return static_cast<jlong>(reinterpret_cast<uintptr_t>(&Bitmap_destruct));
439}
440
Leon Scroggins IIIf8adae12018-05-24 15:25:08 -0400441static void Bitmap_recycle(JNIEnv* env, jobject, jlong bitmapHandle) {
John Reckf29ed282015-04-07 07:32:03 -0700442 LocalScopedBitmap bitmap(bitmapHandle);
443 bitmap->freePixels();
Chris Craik32054b02014-05-09 13:58:56 -0700444}
445
446static void Bitmap_reconfigure(JNIEnv* env, jobject clazz, jlong bitmapHandle,
sergeyv45082182016-09-29 18:25:40 -0700447 jint width, jint height, jint configHandle, jboolean requestPremul) {
John Reckf29ed282015-04-07 07:32:03 -0700448 LocalScopedBitmap bitmap(bitmapHandle);
sergeyvc69853c2016-10-07 14:14:09 -0700449 bitmap->assertValid();
Mike Reed1103b322014-07-08 12:36:44 -0400450 SkColorType colorType = GraphicsJNI::legacyBitmapConfigToColorType(configHandle);
Leon Scroggins III17a8bfc2014-06-03 16:15:15 -0400451
452 // ARGB_4444 is a deprecated format, convert automatically to 8888
453 if (colorType == kARGB_4444_SkColorType) {
454 colorType = kN32_SkColorType;
455 }
sergeyv45082182016-09-29 18:25:40 -0700456 size_t requestedSize = width * height * SkColorTypeBytesPerPixel(colorType);
457 if (requestedSize > bitmap->getAllocationByteCount()) {
Chris Craik32054b02014-05-09 13:58:56 -0700458 // done in native as there's no way to get BytesPerPixel in Java
459 doThrowIAE(env, "Bitmap not large enough to support new configuration");
460 return;
461 }
Leon Scroggins III17a8bfc2014-06-03 16:15:15 -0400462 SkAlphaType alphaType;
John Reckf29ed282015-04-07 07:32:03 -0700463 if (bitmap->info().colorType() != kRGB_565_SkColorType
464 && bitmap->info().alphaType() == kOpaque_SkAlphaType) {
Leon Scroggins III17a8bfc2014-06-03 16:15:15 -0400465 // If the original bitmap was set to opaque, keep that setting, unless it
466 // was 565, which is required to be opaque.
467 alphaType = kOpaque_SkAlphaType;
468 } else {
469 // Otherwise respect the premultiplied request.
470 alphaType = requestPremul ? kPremul_SkAlphaType : kUnpremul_SkAlphaType;
471 }
sergeyvaed7f582016-10-14 16:30:21 -0700472 bitmap->bitmap().reconfigure(SkImageInfo::Make(width, height, colorType, alphaType,
sergeyv7d5219f2016-11-03 16:18:16 -0700473 sk_ref_sp(bitmap->info().colorSpace())));
Chris Craik32054b02014-05-09 13:58:56 -0700474}
475
Chris Craik32054b02014-05-09 13:58:56 -0700476static jboolean Bitmap_compress(JNIEnv* env, jobject clazz, jlong bitmapHandle,
477 jint format, jint quality,
478 jobject jstream, jbyteArray jstorage) {
Hal Canary10219fb2016-11-23 20:41:22 -0500479 LocalScopedBitmap bitmap(bitmapHandle);
John Reckf29ed282015-04-07 07:32:03 -0700480 if (!bitmap.valid()) {
481 return JNI_FALSE;
482 }
483
John Reckf29ed282015-04-07 07:32:03 -0700484 std::unique_ptr<SkWStream> strm(CreateJavaOutputStreamAdaptor(env, jstream, jstorage));
485 if (!strm.get()) {
486 return JNI_FALSE;
487 }
Chris Craik32054b02014-05-09 13:58:56 -0700488
Leon Scroggins III9010e8b2019-08-20 11:27:17 -0400489 auto fm = static_cast<Bitmap::JavaCompressFormat>(format);
Leon Scroggins III949c6002020-01-23 16:20:39 -0500490 return bitmap->bitmap().compress(fm, quality, strm.get()) ? JNI_TRUE : JNI_FALSE;
Chris Craik32054b02014-05-09 13:58:56 -0700491}
492
Leon Scroggins III4c4259b2018-12-17 10:40:07 -0500493static inline void bitmapErase(SkBitmap bitmap, const SkColor4f& color,
494 const sk_sp<SkColorSpace>& colorSpace) {
495 SkPaint p;
496 p.setColor4f(color, colorSpace.get());
497 p.setBlendMode(SkBlendMode::kSrc);
498 SkCanvas canvas(bitmap);
499 canvas.drawPaint(p);
500}
501
Chris Craik32054b02014-05-09 13:58:56 -0700502static void Bitmap_erase(JNIEnv* env, jobject, jlong bitmapHandle, jint color) {
John Reckf29ed282015-04-07 07:32:03 -0700503 LocalScopedBitmap bitmap(bitmapHandle);
504 SkBitmap skBitmap;
505 bitmap->getSkBitmap(&skBitmap);
Leon Scroggins III4c4259b2018-12-17 10:40:07 -0500506 bitmapErase(skBitmap, SkColor4f::FromColor(color), SkColorSpace::MakeSRGB());
507}
508
Leon Scroggins III94ba1002019-01-17 13:34:51 -0500509static void Bitmap_eraseLong(JNIEnv* env, jobject, jlong bitmapHandle,
510 jlong colorSpaceHandle, jlong colorLong) {
Leon Scroggins III4c4259b2018-12-17 10:40:07 -0500511 LocalScopedBitmap bitmap(bitmapHandle);
512 SkBitmap skBitmap;
513 bitmap->getSkBitmap(&skBitmap);
Leon Scroggins III0e443d12018-12-19 11:38:35 -0500514
Leon Scroggins III94ba1002019-01-17 13:34:51 -0500515 SkColor4f color = GraphicsJNI::convertColorLong(colorLong);
Leon Scroggins III0e443d12018-12-19 11:38:35 -0500516 sk_sp<SkColorSpace> cs = GraphicsJNI::getNativeColorSpace(colorSpaceHandle);
Leon Scroggins III4c4259b2018-12-17 10:40:07 -0500517 bitmapErase(skBitmap, color, cs);
Chris Craik32054b02014-05-09 13:58:56 -0700518}
519
520static jint Bitmap_rowBytes(JNIEnv* env, jobject, jlong bitmapHandle) {
John Reckf29ed282015-04-07 07:32:03 -0700521 LocalScopedBitmap bitmap(bitmapHandle);
Chris Craik32054b02014-05-09 13:58:56 -0700522 return static_cast<jint>(bitmap->rowBytes());
523}
524
525static jint Bitmap_config(JNIEnv* env, jobject, jlong bitmapHandle) {
John Reckf29ed282015-04-07 07:32:03 -0700526 LocalScopedBitmap bitmap(bitmapHandle);
sergeyv15a10852016-12-27 14:32:03 -0800527 if (bitmap->isHardware()) {
sergeyv19b4b012016-12-13 16:06:00 -0800528 return GraphicsJNI::hardwareLegacyBitmapConfig();
529 }
John Reckf29ed282015-04-07 07:32:03 -0700530 return GraphicsJNI::colorTypeToLegacyBitmapConfig(bitmap->info().colorType());
Chris Craik32054b02014-05-09 13:58:56 -0700531}
532
533static jint Bitmap_getGenerationId(JNIEnv* env, jobject, jlong bitmapHandle) {
John Reckf29ed282015-04-07 07:32:03 -0700534 LocalScopedBitmap bitmap(bitmapHandle);
sergeyvc69853c2016-10-07 14:14:09 -0700535 return static_cast<jint>(bitmap->getGenerationID());
Chris Craik32054b02014-05-09 13:58:56 -0700536}
537
Leon Scroggins III57ee6202014-06-04 18:51:07 -0400538static jboolean Bitmap_isPremultiplied(JNIEnv* env, jobject, jlong bitmapHandle) {
John Reckf29ed282015-04-07 07:32:03 -0700539 LocalScopedBitmap bitmap(bitmapHandle);
540 if (bitmap->info().alphaType() == kPremul_SkAlphaType) {
Leon Scroggins III57ee6202014-06-04 18:51:07 -0400541 return JNI_TRUE;
542 }
543 return JNI_FALSE;
544}
545
Chris Craik32054b02014-05-09 13:58:56 -0700546static jboolean Bitmap_hasAlpha(JNIEnv* env, jobject, jlong bitmapHandle) {
John Reckf29ed282015-04-07 07:32:03 -0700547 LocalScopedBitmap bitmap(bitmapHandle);
548 return !bitmap->info().isOpaque() ? JNI_TRUE : JNI_FALSE;
Chris Craik32054b02014-05-09 13:58:56 -0700549}
550
Leon Scroggins III57ee6202014-06-04 18:51:07 -0400551static void Bitmap_setHasAlpha(JNIEnv* env, jobject, jlong bitmapHandle,
552 jboolean hasAlpha, jboolean requestPremul) {
John Reckf29ed282015-04-07 07:32:03 -0700553 LocalScopedBitmap bitmap(bitmapHandle);
Leon Scroggins III57ee6202014-06-04 18:51:07 -0400554 if (hasAlpha) {
John Reck0781a2f2015-05-27 16:29:17 -0700555 bitmap->setAlphaType(
John Reckf29ed282015-04-07 07:32:03 -0700556 requestPremul ? kPremul_SkAlphaType : kUnpremul_SkAlphaType);
Chris Craik32054b02014-05-09 13:58:56 -0700557 } else {
John Reck0781a2f2015-05-27 16:29:17 -0700558 bitmap->setAlphaType(kOpaque_SkAlphaType);
Leon Scroggins III57ee6202014-06-04 18:51:07 -0400559 }
560}
561
562static void Bitmap_setPremultiplied(JNIEnv* env, jobject, jlong bitmapHandle,
563 jboolean isPremul) {
John Reckf29ed282015-04-07 07:32:03 -0700564 LocalScopedBitmap bitmap(bitmapHandle);
565 if (!bitmap->info().isOpaque()) {
Leon Scroggins III57ee6202014-06-04 18:51:07 -0400566 if (isPremul) {
John Reck0781a2f2015-05-27 16:29:17 -0700567 bitmap->setAlphaType(kPremul_SkAlphaType);
Leon Scroggins III57ee6202014-06-04 18:51:07 -0400568 } else {
John Reck0781a2f2015-05-27 16:29:17 -0700569 bitmap->setAlphaType(kUnpremul_SkAlphaType);
Leon Scroggins III57ee6202014-06-04 18:51:07 -0400570 }
Chris Craik32054b02014-05-09 13:58:56 -0700571 }
572}
573
574static jboolean Bitmap_hasMipMap(JNIEnv* env, jobject, jlong bitmapHandle) {
John Reckf29ed282015-04-07 07:32:03 -0700575 LocalScopedBitmap bitmap(bitmapHandle);
Chris Craik32054b02014-05-09 13:58:56 -0700576 return bitmap->hasHardwareMipMap() ? JNI_TRUE : JNI_FALSE;
577}
578
579static void Bitmap_setHasMipMap(JNIEnv* env, jobject, jlong bitmapHandle,
580 jboolean hasMipMap) {
John Reckf29ed282015-04-07 07:32:03 -0700581 LocalScopedBitmap bitmap(bitmapHandle);
Chris Craik32054b02014-05-09 13:58:56 -0700582 bitmap->setHasHardwareMipMap(hasMipMap);
583}
584
585///////////////////////////////////////////////////////////////////////////////
586
John Recka18d7c82020-03-02 09:41:33 -0800587// TODO: Move somewhere else
Derek Sollenberger42c50042020-02-18 14:51:17 -0500588#ifdef __ANDROID__ // Layoutlib does not support parcel
Derek Sollenberger42c50042020-02-18 14:51:17 -0500589
John Recka18d7c82020-03-02 09:41:33 -0800590class ScopedParcel {
591public:
592 explicit ScopedParcel(JNIEnv* env, jobject parcel) {
593 mParcel = AParcel_fromJavaParcel(env, parcel);
Derek Sollenberger42c50042020-02-18 14:51:17 -0500594 }
John Recka18d7c82020-03-02 09:41:33 -0800595
596 ~ScopedParcel() { AParcel_delete(mParcel); }
597
598 int32_t readInt32() {
599 int32_t temp = 0;
600 // TODO: This behavior-matches what android::Parcel does
601 // but this should probably be better
602 if (AParcel_readInt32(mParcel, &temp) != STATUS_OK) {
603 temp = 0;
604 }
605 return temp;
606 }
607
608 uint32_t readUint32() {
609 uint32_t temp = 0;
610 // TODO: This behavior-matches what android::Parcel does
611 // but this should probably be better
612 if (AParcel_readUint32(mParcel, &temp) != STATUS_OK) {
613 temp = 0;
614 }
615 return temp;
616 }
617
618 void writeInt32(int32_t value) { AParcel_writeInt32(mParcel, value); }
619
620 void writeUint32(uint32_t value) { AParcel_writeUint32(mParcel, value); }
621
622 bool allowFds() const { return AParcel_getAllowFds(mParcel); }
623
624 std::optional<sk_sp<SkData>> readData() {
625 struct Data {
626 void* ptr = nullptr;
627 size_t size = 0;
628 } data;
629 auto error = AParcel_readByteArray(mParcel, &data,
630 [](void* arrayData, int32_t length,
631 int8_t** outBuffer) -> bool {
632 Data* data = reinterpret_cast<Data*>(arrayData);
633 if (length > 0) {
634 data->ptr = sk_malloc_canfail(length);
635 if (!data->ptr) {
636 return false;
637 }
638 *outBuffer =
639 reinterpret_cast<int8_t*>(data->ptr);
640 data->size = length;
641 }
642 return true;
643 });
644 if (error != STATUS_OK || data.size <= 0) {
645 sk_free(data.ptr);
646 return std::nullopt;
647 } else {
648 return SkData::MakeFromMalloc(data.ptr, data.size);
649 }
650 }
651
652 void writeData(const std::optional<sk_sp<SkData>>& optData) {
653 if (optData) {
654 const auto& data = *optData;
655 AParcel_writeByteArray(mParcel, reinterpret_cast<const int8_t*>(data->data()),
656 data->size());
657 } else {
658 AParcel_writeByteArray(mParcel, nullptr, -1);
659 }
660 }
661
662 AParcel* get() { return mParcel; }
663
664private:
665 AParcel* mParcel;
666};
667
668enum class BlobType : int32_t {
669 IN_PLACE,
670 ASHMEM,
671};
672
673#define ON_ERROR_RETURN(X) \
674 if ((error = (X)) != STATUS_OK) return error
675
676template <typename T, typename U>
677static binder_status_t readBlob(AParcel* parcel, T inPlaceCallback, U ashmemCallback) {
678 binder_status_t error = STATUS_OK;
679 BlobType type;
680 static_assert(sizeof(BlobType) == sizeof(int32_t));
681 ON_ERROR_RETURN(AParcel_readInt32(parcel, (int32_t*)&type));
682 if (type == BlobType::IN_PLACE) {
683 struct Data {
684 std::unique_ptr<int8_t[]> ptr = nullptr;
685 int32_t size = 0;
686 } data;
687 ON_ERROR_RETURN(
688 AParcel_readByteArray(parcel, &data,
689 [](void* arrayData, int32_t length, int8_t** outBuffer) {
690 Data* data = reinterpret_cast<Data*>(arrayData);
691 if (length > 0) {
692 data->ptr = std::make_unique<int8_t[]>(length);
693 data->size = length;
694 *outBuffer = data->ptr.get();
695 }
696 return data->ptr != nullptr;
697 }));
John Reckaca134f2022-01-18 13:23:00 -0500698 return inPlaceCallback(std::move(data.ptr), data.size);
John Recka18d7c82020-03-02 09:41:33 -0800699 } else if (type == BlobType::ASHMEM) {
700 int rawFd = -1;
701 int32_t size = 0;
702 ON_ERROR_RETURN(AParcel_readInt32(parcel, &size));
703 ON_ERROR_RETURN(AParcel_readParcelFileDescriptor(parcel, &rawFd));
704 android::base::unique_fd fd(rawFd);
John Reckaca134f2022-01-18 13:23:00 -0500705 return ashmemCallback(std::move(fd), size);
John Recka18d7c82020-03-02 09:41:33 -0800706 } else {
707 // Although the above if/else was "exhaustive" guard against unknown types
708 return STATUS_UNKNOWN_ERROR;
709 }
Derek Sollenberger42c50042020-02-18 14:51:17 -0500710}
John Recka18d7c82020-03-02 09:41:33 -0800711
712static constexpr size_t BLOB_INPLACE_LIMIT = 12 * 1024;
713// Fail fast if we can't use ashmem and the size exceeds this limit - the binder transaction
714// wouldn't go through, anyway
715// TODO: Can we get this from somewhere?
716static constexpr size_t BLOB_MAX_INPLACE_LIMIT = 1 * 1024 * 1024;
717static constexpr bool shouldUseAshmem(AParcel* parcel, int32_t size) {
718 return size > BLOB_INPLACE_LIMIT && AParcel_getAllowFds(parcel);
719}
720
721static binder_status_t writeBlobFromFd(AParcel* parcel, int32_t size, int fd) {
722 binder_status_t error = STATUS_OK;
723 ON_ERROR_RETURN(AParcel_writeInt32(parcel, static_cast<int32_t>(BlobType::ASHMEM)));
724 ON_ERROR_RETURN(AParcel_writeInt32(parcel, size));
725 ON_ERROR_RETURN(AParcel_writeParcelFileDescriptor(parcel, fd));
726 return STATUS_OK;
727}
728
John Reck6a93b4f2020-04-10 17:12:00 -0700729static binder_status_t writeBlob(AParcel* parcel, const int32_t size, const void* data, bool immutable) {
John Recka18d7c82020-03-02 09:41:33 -0800730 if (size <= 0 || data == nullptr) {
731 return STATUS_NOT_ENOUGH_DATA;
732 }
733 binder_status_t error = STATUS_OK;
734 if (shouldUseAshmem(parcel, size)) {
735 // Create new ashmem region with read/write priv
736 base::unique_fd fd(ashmem_create_region("bitmap", size));
737 if (fd.get() < 0) {
738 return STATUS_NO_MEMORY;
739 }
740
741 {
742 void* dest = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd.get(), 0);
743 if (dest == MAP_FAILED) {
744 return STATUS_NO_MEMORY;
745 }
746 memcpy(dest, data, size);
747 munmap(dest, size);
748 }
749
John Reck6a93b4f2020-04-10 17:12:00 -0700750 if (immutable && ashmem_set_prot_region(fd.get(), PROT_READ) < 0) {
John Recka18d7c82020-03-02 09:41:33 -0800751 return STATUS_UNKNOWN_ERROR;
752 }
753 // Workaround b/149851140 in AParcel_writeParcelFileDescriptor
754 int rawFd = fd.release();
755 error = writeBlobFromFd(parcel, size, rawFd);
756 close(rawFd);
757 return error;
758 } else {
759 if (size > BLOB_MAX_INPLACE_LIMIT) {
760 return STATUS_FAILED_TRANSACTION;
761 }
762 ON_ERROR_RETURN(AParcel_writeInt32(parcel, static_cast<int32_t>(BlobType::IN_PLACE)));
763 ON_ERROR_RETURN(AParcel_writeByteArray(parcel, static_cast<const int8_t*>(data), size));
764 return STATUS_OK;
765 }
766}
767
768#undef ON_ERROR_RETURN
769
770#endif // __ANDROID__ // Layoutlib does not support parcel
Derek Sollenberger42c50042020-02-18 14:51:17 -0500771
Matt Sarett3ca39752017-05-26 10:55:38 -0400772// This is the maximum possible size because the SkColorSpace must be
773// representable (and therefore serializable) using a matrix and numerical
774// transfer function. If we allow more color space representations in the
775// framework, we may need to update this maximum size.
John Recka18d7c82020-03-02 09:41:33 -0800776static constexpr size_t kMaxColorSpaceSerializedBytes = 80;
777
John Reckaca134f2022-01-18 13:23:00 -0500778static constexpr auto BadParcelableException = "android/os/BadParcelableException";
John Recka18d7c82020-03-02 09:41:33 -0800779
780static bool validateImageInfo(const SkImageInfo& info, int32_t rowBytes) {
781 // TODO: Can we avoid making a SkBitmap for this?
782 return SkBitmap().setInfo(info, rowBytes);
783}
Matt Sarett3ca39752017-05-26 10:55:38 -0400784
Chris Craik32054b02014-05-09 13:58:56 -0700785static jobject Bitmap_createFromParcel(JNIEnv* env, jobject, jobject parcel) {
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +0100786#ifdef __ANDROID__ // Layoutlib does not support parcel
Chris Craik32054b02014-05-09 13:58:56 -0700787 if (parcel == NULL) {
John Recka18d7c82020-03-02 09:41:33 -0800788 jniThrowNullPointerException(env, "parcel cannot be null");
Chris Craik32054b02014-05-09 13:58:56 -0700789 return NULL;
790 }
791
John Recka18d7c82020-03-02 09:41:33 -0800792 ScopedParcel p(env, parcel);
Chris Craik32054b02014-05-09 13:58:56 -0700793
John Reck6a93b4f2020-04-10 17:12:00 -0700794 const bool isMutable = p.readInt32();
John Recka18d7c82020-03-02 09:41:33 -0800795 const SkColorType colorType = static_cast<SkColorType>(p.readInt32());
796 const SkAlphaType alphaType = static_cast<SkAlphaType>(p.readInt32());
Romain Guy5acc4762017-03-07 15:29:27 -0800797 sk_sp<SkColorSpace> colorSpace;
John Recka18d7c82020-03-02 09:41:33 -0800798 const auto optColorSpaceData = p.readData();
799 if (optColorSpaceData) {
800 const auto& colorSpaceData = *optColorSpaceData;
801 if (colorSpaceData->size() > kMaxColorSpaceSerializedBytes) {
Matt Sarett3ca39752017-05-26 10:55:38 -0400802 ALOGD("Bitmap_createFromParcel: Serialized SkColorSpace is larger than expected: "
John Recka18d7c82020-03-02 09:41:33 -0800803 "%zu bytes (max: %zu)\n",
804 colorSpaceData->size(), kMaxColorSpaceSerializedBytes);
Matt Sarett3ca39752017-05-26 10:55:38 -0400805 }
806
John Recka18d7c82020-03-02 09:41:33 -0800807 colorSpace = SkColorSpace::Deserialize(colorSpaceData->data(), colorSpaceData->size());
Romain Guy5acc4762017-03-07 15:29:27 -0800808 }
John Recka18d7c82020-03-02 09:41:33 -0800809 const int32_t width = p.readInt32();
810 const int32_t height = p.readInt32();
811 const int32_t rowBytes = p.readInt32();
812 const int32_t density = p.readInt32();
Chris Craik32054b02014-05-09 13:58:56 -0700813
Mike Reedb9330552014-06-16 17:31:48 -0400814 if (kN32_SkColorType != colorType &&
Romain Guy9505a652016-12-14 09:43:50 -0800815 kRGBA_F16_SkColorType != colorType &&
Mike Reedb9330552014-06-16 17:31:48 -0400816 kRGB_565_SkColorType != colorType &&
817 kARGB_4444_SkColorType != colorType &&
Mike Reedb9330552014-06-16 17:31:48 -0400818 kAlpha_8_SkColorType != colorType) {
John Reckaca134f2022-01-18 13:23:00 -0500819 jniThrowExceptionFmt(env, BadParcelableException,
John Recka18d7c82020-03-02 09:41:33 -0800820 "Bitmap_createFromParcel unknown colortype: %d\n", colorType);
Chris Craik32054b02014-05-09 13:58:56 -0700821 return NULL;
822 }
823
John Recka18d7c82020-03-02 09:41:33 -0800824 auto imageInfo = SkImageInfo::Make(width, height, colorType, alphaType, colorSpace);
825 size_t allocationSize = 0;
826 if (!validateImageInfo(imageInfo, rowBytes)) {
827 jniThrowRuntimeException(env, "Received bad SkImageInfo");
Leon Scroggins IIIec419e02015-03-11 13:12:06 -0400828 return NULL;
829 }
John Recka18d7c82020-03-02 09:41:33 -0800830 if (!Bitmap::computeAllocationSize(rowBytes, height, &allocationSize)) {
John Reckaca134f2022-01-18 13:23:00 -0500831 jniThrowExceptionFmt(env, BadParcelableException,
John Recka18d7c82020-03-02 09:41:33 -0800832 "Received bad bitmap size: width=%d, height=%d, rowBytes=%d", width,
833 height, rowBytes);
Chris Craik32054b02014-05-09 13:58:56 -0700834 return NULL;
835 }
sergeyvc1c54062016-10-19 18:47:26 -0700836 sk_sp<Bitmap> nativeBitmap;
John Recka18d7c82020-03-02 09:41:33 -0800837 binder_status_t error = readBlob(
838 p.get(),
839 // In place callback
840 [&](std::unique_ptr<int8_t[]> buffer, int32_t size) {
John Reckaca134f2022-01-18 13:23:00 -0500841 if (allocationSize > size) {
842 android_errorWriteLog(0x534e4554, "213169612");
843 return STATUS_BAD_VALUE;
844 }
John Recka18d7c82020-03-02 09:41:33 -0800845 nativeBitmap = Bitmap::allocateHeapBitmap(allocationSize, imageInfo, rowBytes);
846 if (nativeBitmap) {
John Reckaca134f2022-01-18 13:23:00 -0500847 memcpy(nativeBitmap->pixels(), buffer.get(), allocationSize);
848 return STATUS_OK;
John Recka18d7c82020-03-02 09:41:33 -0800849 }
John Reckaca134f2022-01-18 13:23:00 -0500850 return STATUS_NO_MEMORY;
John Recka18d7c82020-03-02 09:41:33 -0800851 },
852 // Ashmem callback
853 [&](android::base::unique_fd fd, int32_t size) {
John Reckaca134f2022-01-18 13:23:00 -0500854 if (allocationSize > size) {
855 android_errorWriteLog(0x534e4554, "213169612");
856 return STATUS_BAD_VALUE;
857 }
John Reck6a93b4f2020-04-10 17:12:00 -0700858 int flags = PROT_READ;
859 if (isMutable) {
860 flags |= PROT_WRITE;
861 }
862 void* addr = mmap(nullptr, size, flags, MAP_SHARED, fd.get(), 0);
John Recka18d7c82020-03-02 09:41:33 -0800863 if (addr == MAP_FAILED) {
John Reck6a93b4f2020-04-10 17:12:00 -0700864 const int err = errno;
865 ALOGW("mmap failed, error %d (%s)", err, strerror(err));
John Reckaca134f2022-01-18 13:23:00 -0500866 return STATUS_NO_MEMORY;
John Recka18d7c82020-03-02 09:41:33 -0800867 }
868 nativeBitmap =
John Reck6a93b4f2020-04-10 17:12:00 -0700869 Bitmap::createFrom(imageInfo, rowBytes, fd.release(), addr, size, !isMutable);
John Reckaca134f2022-01-18 13:23:00 -0500870 return STATUS_OK;
John Recka18d7c82020-03-02 09:41:33 -0800871 });
John Reckaca134f2022-01-18 13:23:00 -0500872
873 if (error != STATUS_OK && error != STATUS_NO_MEMORY) {
John Recka18d7c82020-03-02 09:41:33 -0800874 // TODO: Stringify the error, see signalExceptionForError in android_util_Binder.cpp
John Reckaca134f2022-01-18 13:23:00 -0500875 jniThrowExceptionFmt(env, BadParcelableException, "Failed to read from Parcel, error=%d",
876 error);
John Recka18d7c82020-03-02 09:41:33 -0800877 return nullptr;
878 }
John Reckaca134f2022-01-18 13:23:00 -0500879 if (error == STATUS_NO_MEMORY || !nativeBitmap) {
880 jniThrowRuntimeException(env, "Could not allocate bitmap data.");
John Recka18d7c82020-03-02 09:41:33 -0800881 return nullptr;
Chris Craik32054b02014-05-09 13:58:56 -0700882 }
Chris Craik32054b02014-05-09 13:58:56 -0700883
John Reck6a93b4f2020-04-10 17:12:00 -0700884 return createBitmap(env, nativeBitmap.release(), getPremulBitmapCreateFlags(isMutable), nullptr,
John Recka18d7c82020-03-02 09:41:33 -0800885 nullptr, density);
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +0100886#else
John Recka18d7c82020-03-02 09:41:33 -0800887 jniThrowRuntimeException(env, "Cannot use parcels outside of Android");
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +0100888 return NULL;
889#endif
Chris Craik32054b02014-05-09 13:58:56 -0700890}
891
892static jboolean Bitmap_writeToParcel(JNIEnv* env, jobject,
John Reckefac0522020-01-24 16:04:26 -0800893 jlong bitmapHandle, jint density, jobject parcel) {
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +0100894#ifdef __ANDROID__ // Layoutlib does not support parcel
Chris Craik32054b02014-05-09 13:58:56 -0700895 if (parcel == NULL) {
Sally Qi7e3f93b2021-07-15 00:00:54 +0000896 ALOGD("------- writeToParcel null parcel\n");
Chris Craik32054b02014-05-09 13:58:56 -0700897 return JNI_FALSE;
898 }
899
John Recka18d7c82020-03-02 09:41:33 -0800900 ScopedParcel p(env, parcel);
John Reckf29ed282015-04-07 07:32:03 -0700901 SkBitmap bitmap;
Riley Andrews39d7f302014-11-13 17:43:25 -0800902
sergeyvc1c54062016-10-19 18:47:26 -0700903 auto bitmapWrapper = reinterpret_cast<BitmapWrapper*>(bitmapHandle);
904 bitmapWrapper->getSkBitmap(&bitmap);
Chris Craik32054b02014-05-09 13:58:56 -0700905
John Reck6a93b4f2020-04-10 17:12:00 -0700906 p.writeInt32(!bitmap.isImmutable());
John Recka18d7c82020-03-02 09:41:33 -0800907 p.writeInt32(bitmap.colorType());
908 p.writeInt32(bitmap.alphaType());
Romain Guy5acc4762017-03-07 15:29:27 -0800909 SkColorSpace* colorSpace = bitmap.colorSpace();
Derek Sollenbergerbf3e4642019-01-30 11:28:27 -0500910 if (colorSpace != nullptr) {
John Recka18d7c82020-03-02 09:41:33 -0800911 p.writeData(colorSpace->serialize());
Romain Guy5acc4762017-03-07 15:29:27 -0800912 } else {
John Recka18d7c82020-03-02 09:41:33 -0800913 p.writeData(std::nullopt);
Romain Guy5acc4762017-03-07 15:29:27 -0800914 }
John Recka18d7c82020-03-02 09:41:33 -0800915 p.writeInt32(bitmap.width());
916 p.writeInt32(bitmap.height());
917 p.writeInt32(bitmap.rowBytes());
918 p.writeInt32(density);
Chris Craik32054b02014-05-09 13:58:56 -0700919
Jeff Browna316c5d2015-06-05 15:14:06 -0700920 // Transfer the underlying ashmem region if we have one and it's immutable.
John Recka18d7c82020-03-02 09:41:33 -0800921 binder_status_t status;
sergeyvaed7f582016-10-14 16:30:21 -0700922 int fd = bitmapWrapper->bitmap().getAshmemFd();
John Reck6a93b4f2020-04-10 17:12:00 -0700923 if (fd >= 0 && p.allowFds() && bitmap.isImmutable()) {
Jeff Browna316c5d2015-06-05 15:14:06 -0700924#if DEBUG_PARCEL
925 ALOGD("Bitmap.writeToParcel: transferring immutable bitmap's ashmem fd as "
John Recka18d7c82020-03-02 09:41:33 -0800926 "immutable blob (fds %s)",
927 p.allowFds() ? "allowed" : "forbidden");
Jeff Browna316c5d2015-06-05 15:14:06 -0700928#endif
929
John Recka18d7c82020-03-02 09:41:33 -0800930 status = writeBlobFromFd(p.get(), bitmapWrapper->bitmap().getAllocationByteCount(), fd);
931 if (status != STATUS_OK) {
Jeff Browna316c5d2015-06-05 15:14:06 -0700932 doThrowRE(env, "Could not write bitmap blob file descriptor.");
Riley Andrews39d7f302014-11-13 17:43:25 -0800933 return JNI_FALSE;
934 }
Jeff Browna316c5d2015-06-05 15:14:06 -0700935 return JNI_TRUE;
Riley Andrews39d7f302014-11-13 17:43:25 -0800936 }
Jeff Browna316c5d2015-06-05 15:14:06 -0700937
938 // Copy the bitmap to a new blob.
Jeff Browna316c5d2015-06-05 15:14:06 -0700939#if DEBUG_PARCEL
John Reckefac0522020-01-24 16:04:26 -0800940 ALOGD("Bitmap.writeToParcel: copying bitmap into new blob (fds %s)",
John Recka18d7c82020-03-02 09:41:33 -0800941 p.allowFds() ? "allowed" : "forbidden");
Jeff Browna316c5d2015-06-05 15:14:06 -0700942#endif
943
Mike Reed7569de02017-10-06 16:25:49 -0400944 size_t size = bitmap.computeByteSize();
John Reck6a93b4f2020-04-10 17:12:00 -0700945 status = writeBlob(p.get(), size, bitmap.getPixels(), bitmap.isImmutable());
Jeff Browna316c5d2015-06-05 15:14:06 -0700946 if (status) {
947 doThrowRE(env, "Could not copy bitmap to parcel blob.");
948 return JNI_FALSE;
949 }
Chris Craik32054b02014-05-09 13:58:56 -0700950 return JNI_TRUE;
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +0100951#else
952 doThrowRE(env, "Cannot use parcels outside of Android");
953 return JNI_FALSE;
954#endif
Chris Craik32054b02014-05-09 13:58:56 -0700955}
956
957static jobject Bitmap_extractAlpha(JNIEnv* env, jobject clazz,
958 jlong srcHandle, jlong paintHandle,
959 jintArray offsetXY) {
John Reckf29ed282015-04-07 07:32:03 -0700960 SkBitmap src;
sergeyvc1c54062016-10-19 18:47:26 -0700961 reinterpret_cast<BitmapWrapper*>(srcHandle)->getSkBitmap(&src);
Behdad Esfahbod6ba30b82014-07-15 16:22:32 -0400962 const android::Paint* paint = reinterpret_cast<android::Paint*>(paintHandle);
Chris Craik32054b02014-05-09 13:58:56 -0700963 SkIPoint offset;
John Reckf29ed282015-04-07 07:32:03 -0700964 SkBitmap dst;
sergeyv45082182016-09-29 18:25:40 -0700965 HeapAllocator allocator;
Chris Craik32054b02014-05-09 13:58:56 -0700966
John Reckf29ed282015-04-07 07:32:03 -0700967 src.extractAlpha(&dst, paint, &allocator, &offset);
Chris Craik32054b02014-05-09 13:58:56 -0700968 // If Skia can't allocate pixels for destination bitmap, it resets
969 // it, that is set its pixels buffer to NULL, and zero width and height.
John Reckf29ed282015-04-07 07:32:03 -0700970 if (dst.getPixels() == NULL && src.getPixels() != NULL) {
Chris Craik32054b02014-05-09 13:58:56 -0700971 doThrowOOME(env, "failed to allocate pixels for alpha");
972 return NULL;
973 }
974 if (offsetXY != 0 && env->GetArrayLength(offsetXY) >= 2) {
975 int* array = env->GetIntArrayElements(offsetXY, NULL);
976 array[0] = offset.fX;
977 array[1] = offset.fY;
978 env->ReleaseIntArrayElements(offsetXY, array, 0);
979 }
980
sergeyvc69853c2016-10-07 14:14:09 -0700981 return createBitmap(env, allocator.getStorageObjAndReset(),
John Reckf29ed282015-04-07 07:32:03 -0700982 getPremulBitmapCreateFlags(true));
Chris Craik32054b02014-05-09 13:58:56 -0700983}
984
985///////////////////////////////////////////////////////////////////////////////
986
Romain Guyefb4b062017-02-27 11:00:04 -0800987static jboolean Bitmap_isSRGB(JNIEnv* env, jobject, jlong bitmapHandle) {
988 LocalScopedBitmap bitmapHolder(bitmapHandle);
989 if (!bitmapHolder.valid()) return JNI_TRUE;
990
991 SkColorSpace* colorSpace = bitmapHolder->info().colorSpace();
Brian Osman91c9c282018-08-17 16:57:15 -0400992 return colorSpace == nullptr || colorSpace->isSRGB();
Romain Guyefb4b062017-02-27 11:00:04 -0800993}
994
Leon Scroggins IIIce89a6e2018-03-13 15:39:39 -0400995static jboolean Bitmap_isSRGBLinear(JNIEnv* env, jobject, jlong bitmapHandle) {
996 LocalScopedBitmap bitmapHolder(bitmapHandle);
997 if (!bitmapHolder.valid()) return JNI_FALSE;
998
999 SkColorSpace* colorSpace = bitmapHolder->info().colorSpace();
1000 sk_sp<SkColorSpace> srgbLinear = SkColorSpace::MakeSRGBLinear();
1001 return colorSpace == srgbLinear.get() ? JNI_TRUE : JNI_FALSE;
1002}
1003
Derek Sollenbergerbf3e4642019-01-30 11:28:27 -05001004static jobject Bitmap_computeColorSpace(JNIEnv* env, jobject, jlong bitmapHandle) {
Romain Guyefb4b062017-02-27 11:00:04 -08001005 LocalScopedBitmap bitmapHolder(bitmapHandle);
Derek Sollenbergerbf3e4642019-01-30 11:28:27 -05001006 if (!bitmapHolder.valid()) return nullptr;
Romain Guyefb4b062017-02-27 11:00:04 -08001007
1008 SkColorSpace* colorSpace = bitmapHolder->info().colorSpace();
Derek Sollenbergerbf3e4642019-01-30 11:28:27 -05001009 if (colorSpace == nullptr) return nullptr;
Romain Guyefb4b062017-02-27 11:00:04 -08001010
Derek Sollenbergerbf3e4642019-01-30 11:28:27 -05001011 return GraphicsJNI::getColorSpace(env, colorSpace, bitmapHolder->info().colorType());
Romain Guyefb4b062017-02-27 11:00:04 -08001012}
1013
Derek Sollenberger202084c2019-01-14 13:55:08 -05001014static void Bitmap_setColorSpace(JNIEnv* env, jobject, jlong bitmapHandle, jlong colorSpacePtr) {
1015 LocalScopedBitmap bitmapHolder(bitmapHandle);
1016 sk_sp<SkColorSpace> cs = GraphicsJNI::getNativeColorSpace(colorSpacePtr);
1017 bitmapHolder->setColorSpace(cs);
1018}
1019
Romain Guyefb4b062017-02-27 11:00:04 -08001020///////////////////////////////////////////////////////////////////////////////
1021
Chris Craik32054b02014-05-09 13:58:56 -07001022static jint Bitmap_getPixel(JNIEnv* env, jobject, jlong bitmapHandle,
Leon Scroggins III57ee6202014-06-04 18:51:07 -04001023 jint x, jint y) {
John Reckf29ed282015-04-07 07:32:03 -07001024 SkBitmap bitmap;
sergeyvc1c54062016-10-19 18:47:26 -07001025 reinterpret_cast<BitmapWrapper*>(bitmapHandle)->getSkBitmap(&bitmap);
Chris Craik32054b02014-05-09 13:58:56 -07001026
Brian Osman91c9c282018-08-17 16:57:15 -04001027 auto sRGB = SkColorSpace::MakeSRGB();
1028 SkImageInfo dstInfo = SkImageInfo::Make(
1029 1, 1, kBGRA_8888_SkColorType, kUnpremul_SkAlphaType, sRGB);
Chris Craik32054b02014-05-09 13:58:56 -07001030
Brian Osman91c9c282018-08-17 16:57:15 -04001031 SkColor dst;
1032 bitmap.readPixels(dstInfo, &dst, dstInfo.minRowBytes(), x, y);
1033 return static_cast<jint>(dst);
Chris Craik32054b02014-05-09 13:58:56 -07001034}
1035
Leon Scroggins III870053d2019-01-24 08:37:27 -05001036static jlong Bitmap_getColor(JNIEnv* env, jobject, jlong bitmapHandle,
1037 jint x, jint y) {
1038 SkBitmap bitmap;
1039 reinterpret_cast<BitmapWrapper*>(bitmapHandle)->getSkBitmap(&bitmap);
1040
1041 SkImageInfo dstInfo = SkImageInfo::Make(
1042 1, 1, kRGBA_F16_SkColorType, kUnpremul_SkAlphaType, bitmap.refColorSpace());
1043
1044 uint64_t dst;
1045 bitmap.readPixels(dstInfo, &dst, dstInfo.minRowBytes(), x, y);
1046 return static_cast<jlong>(dst);
1047}
1048
Chris Craik32054b02014-05-09 13:58:56 -07001049static void Bitmap_getPixels(JNIEnv* env, jobject, jlong bitmapHandle,
1050 jintArray pixelArray, jint offset, jint stride,
Leon Scroggins III57ee6202014-06-04 18:51:07 -04001051 jint x, jint y, jint width, jint height) {
John Reckf29ed282015-04-07 07:32:03 -07001052 SkBitmap bitmap;
sergeyvc1c54062016-10-19 18:47:26 -07001053 reinterpret_cast<BitmapWrapper*>(bitmapHandle)->getSkBitmap(&bitmap);
Chris Craik32054b02014-05-09 13:58:56 -07001054
Brian Osman91c9c282018-08-17 16:57:15 -04001055 auto sRGB = SkColorSpace::MakeSRGB();
1056 SkImageInfo dstInfo = SkImageInfo::Make(
1057 width, height, kBGRA_8888_SkColorType, kUnpremul_SkAlphaType, sRGB);
Chris Craik32054b02014-05-09 13:58:56 -07001058
Chris Craik32054b02014-05-09 13:58:56 -07001059 jint* dst = env->GetIntArrayElements(pixelArray, NULL);
Brian Osman91c9c282018-08-17 16:57:15 -04001060 bitmap.readPixels(dstInfo, dst + offset, stride * 4, x, y);
Chris Craik32054b02014-05-09 13:58:56 -07001061 env->ReleaseIntArrayElements(pixelArray, dst, 0);
1062}
1063
1064///////////////////////////////////////////////////////////////////////////////
1065
1066static void Bitmap_setPixel(JNIEnv* env, jobject, jlong bitmapHandle,
Leon Scroggins III57ee6202014-06-04 18:51:07 -04001067 jint x, jint y, jint colorHandle) {
John Reckf29ed282015-04-07 07:32:03 -07001068 SkBitmap bitmap;
sergeyvc1c54062016-10-19 18:47:26 -07001069 reinterpret_cast<BitmapWrapper*>(bitmapHandle)->getSkBitmap(&bitmap);
Chris Craik32054b02014-05-09 13:58:56 -07001070 SkColor color = static_cast<SkColor>(colorHandle);
Chris Craik32054b02014-05-09 13:58:56 -07001071
Brian Osman91c9c282018-08-17 16:57:15 -04001072 auto sRGB = SkColorSpace::MakeSRGB();
1073 SkImageInfo srcInfo = SkImageInfo::Make(
1074 1, 1, kBGRA_8888_SkColorType, kUnpremul_SkAlphaType, sRGB);
1075 SkPixmap srcPM(srcInfo, &color, srcInfo.minRowBytes());
Chris Craik32054b02014-05-09 13:58:56 -07001076
Brian Osman91c9c282018-08-17 16:57:15 -04001077 bitmap.writePixels(srcPM, x, y);
Chris Craik32054b02014-05-09 13:58:56 -07001078}
1079
1080static void Bitmap_setPixels(JNIEnv* env, jobject, jlong bitmapHandle,
1081 jintArray pixelArray, jint offset, jint stride,
Leon Scroggins III57ee6202014-06-04 18:51:07 -04001082 jint x, jint y, jint width, jint height) {
John Reckf29ed282015-04-07 07:32:03 -07001083 SkBitmap bitmap;
sergeyvc1c54062016-10-19 18:47:26 -07001084 reinterpret_cast<BitmapWrapper*>(bitmapHandle)->getSkBitmap(&bitmap);
Chris Craik32054b02014-05-09 13:58:56 -07001085 GraphicsJNI::SetPixels(env, pixelArray, offset, stride,
Brian Osman91c9c282018-08-17 16:57:15 -04001086 x, y, width, height, &bitmap);
Chris Craik32054b02014-05-09 13:58:56 -07001087}
1088
1089static void Bitmap_copyPixelsToBuffer(JNIEnv* env, jobject,
1090 jlong bitmapHandle, jobject jbuffer) {
John Reckf29ed282015-04-07 07:32:03 -07001091 SkBitmap bitmap;
sergeyvc1c54062016-10-19 18:47:26 -07001092 reinterpret_cast<BitmapWrapper*>(bitmapHandle)->getSkBitmap(&bitmap);
John Reckf29ed282015-04-07 07:32:03 -07001093 const void* src = bitmap.getPixels();
Chris Craik32054b02014-05-09 13:58:56 -07001094
1095 if (NULL != src) {
1096 android::AutoBufferPointer abp(env, jbuffer, JNI_TRUE);
1097
1098 // the java side has already checked that buffer is large enough
Mike Reed7569de02017-10-06 16:25:49 -04001099 memcpy(abp.pointer(), src, bitmap.computeByteSize());
Chris Craik32054b02014-05-09 13:58:56 -07001100 }
1101}
1102
1103static void Bitmap_copyPixelsFromBuffer(JNIEnv* env, jobject,
1104 jlong bitmapHandle, jobject jbuffer) {
John Reckf29ed282015-04-07 07:32:03 -07001105 SkBitmap bitmap;
sergeyvc1c54062016-10-19 18:47:26 -07001106 reinterpret_cast<BitmapWrapper*>(bitmapHandle)->getSkBitmap(&bitmap);
John Reckf29ed282015-04-07 07:32:03 -07001107 void* dst = bitmap.getPixels();
Chris Craik32054b02014-05-09 13:58:56 -07001108
1109 if (NULL != dst) {
1110 android::AutoBufferPointer abp(env, jbuffer, JNI_FALSE);
1111 // the java side has already checked that buffer is large enough
Mike Reed7569de02017-10-06 16:25:49 -04001112 memcpy(dst, abp.pointer(), bitmap.computeByteSize());
John Reckf29ed282015-04-07 07:32:03 -07001113 bitmap.notifyPixelsChanged();
Chris Craik32054b02014-05-09 13:58:56 -07001114 }
1115}
1116
Chris Craik795bd0f2016-12-16 15:22:31 -08001117static jboolean Bitmap_sameAs(JNIEnv* env, jobject, jlong bm0Handle, jlong bm1Handle) {
John Reckf29ed282015-04-07 07:32:03 -07001118 SkBitmap bm0;
1119 SkBitmap bm1;
sergeyv1eabed32016-12-14 14:19:47 -08001120
1121 LocalScopedBitmap bitmap0(bm0Handle);
1122 LocalScopedBitmap bitmap1(bm1Handle);
1123
1124 // Paying the price for making Hardware Bitmap as Config:
1125 // later check for colorType will pass successfully,
1126 // because Hardware Config internally may be RGBA8888 or smth like that.
sergeyv15a10852016-12-27 14:32:03 -08001127 if (bitmap0->isHardware() != bitmap1->isHardware()) {
sergeyv1eabed32016-12-14 14:19:47 -08001128 return JNI_FALSE;
1129 }
1130
1131 bitmap0->bitmap().getSkBitmap(&bm0);
1132 bitmap1->bitmap().getSkBitmap(&bm1);
Chris Craik795bd0f2016-12-16 15:22:31 -08001133 if (bm0.width() != bm1.width()
1134 || bm0.height() != bm1.height()
1135 || bm0.colorType() != bm1.colorType()
1136 || bm0.alphaType() != bm1.alphaType()
1137 || !SkColorSpace::Equals(bm0.colorSpace(), bm1.colorSpace())) {
Chris Craik32054b02014-05-09 13:58:56 -07001138 return JNI_FALSE;
1139 }
1140
Chris Craik32054b02014-05-09 13:58:56 -07001141 // if we can't load the pixels, return false
John Reckf29ed282015-04-07 07:32:03 -07001142 if (NULL == bm0.getPixels() || NULL == bm1.getPixels()) {
Chris Craik32054b02014-05-09 13:58:56 -07001143 return JNI_FALSE;
1144 }
1145
Chris Craik32054b02014-05-09 13:58:56 -07001146 // now compare each scanline. We can't do the entire buffer at once,
1147 // since we don't care about the pixel values that might extend beyond
1148 // the width (since the scanline might be larger than the logical width)
John Reckf29ed282015-04-07 07:32:03 -07001149 const int h = bm0.height();
1150 const size_t size = bm0.width() * bm0.bytesPerPixel();
Chris Craik32054b02014-05-09 13:58:56 -07001151 for (int y = 0; y < h; y++) {
henry.uh_chen53001ca2014-07-03 20:40:22 +08001152 // SkBitmap::getAddr(int, int) may return NULL due to unrecognized config
1153 // (ex: kRLE_Index8_Config). This will cause memcmp method to crash. Since bm0
1154 // and bm1 both have pixel data() (have passed NULL == getPixels() check),
1155 // those 2 bitmaps should be valid (only unrecognized), we return JNI_FALSE
1156 // to warn user those 2 unrecognized config bitmaps may be different.
John Reckf29ed282015-04-07 07:32:03 -07001157 void *bm0Addr = bm0.getAddr(0, y);
1158 void *bm1Addr = bm1.getAddr(0, y);
henry.uh_chen53001ca2014-07-03 20:40:22 +08001159
1160 if(bm0Addr == NULL || bm1Addr == NULL) {
1161 return JNI_FALSE;
1162 }
1163
1164 if (memcmp(bm0Addr, bm1Addr, size) != 0) {
Chris Craik32054b02014-05-09 13:58:56 -07001165 return JNI_FALSE;
1166 }
1167 }
1168 return JNI_TRUE;
1169}
1170
John Reck43871902016-08-01 14:39:24 -07001171static void Bitmap_prepareToDraw(JNIEnv* env, jobject, jlong bitmapPtr) {
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +01001172#ifdef __ANDROID__ // Layoutlib does not support render thread
John Reck43871902016-08-01 14:39:24 -07001173 LocalScopedBitmap bitmapHandle(bitmapPtr);
1174 if (!bitmapHandle.valid()) return;
sergeyvec4a4b12016-10-20 18:39:04 -07001175 android::uirenderer::renderthread::RenderProxy::prepareToDraw(bitmapHandle->bitmap());
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +01001176#endif
John Reck43871902016-08-01 14:39:24 -07001177}
1178
sergeyv45082182016-09-29 18:25:40 -07001179static jint Bitmap_getAllocationByteCount(JNIEnv* env, jobject, jlong bitmapPtr) {
1180 LocalScopedBitmap bitmapHandle(bitmapPtr);
1181 return static_cast<jint>(bitmapHandle->getAllocationByteCount());
1182}
1183
sergeyv6e3658a2017-01-04 16:57:51 -08001184static jobject Bitmap_copyPreserveInternalConfig(JNIEnv* env, jobject, jlong bitmapPtr) {
sergeyv81f97ee2016-12-27 18:08:01 -08001185 LocalScopedBitmap bitmapHandle(bitmapPtr);
1186 LOG_ALWAYS_FATAL_IF(!bitmapHandle->isHardware(),
1187 "Hardware config is only supported config in Bitmap_nativeCopyPreserveInternalConfig");
1188 Bitmap& hwuiBitmap = bitmapHandle->bitmap();
1189 SkBitmap src;
1190 hwuiBitmap.getSkBitmap(&src);
1191
Derek Sollenbergere2169482018-11-20 10:57:20 -05001192 if (src.pixelRef() == nullptr) {
sergeyv81f97ee2016-12-27 18:08:01 -08001193 doThrowRE(env, "Could not copy a hardware bitmap.");
1194 return NULL;
1195 }
Derek Sollenbergere2169482018-11-20 10:57:20 -05001196
1197 sk_sp<Bitmap> bitmap = Bitmap::createFrom(src.info(), *src.pixelRef());
1198 return createBitmap(env, bitmap.release(), getPremulBitmapCreateFlags(false));
sergeyv81f97ee2016-12-27 18:08:01 -08001199}
1200
rennb2e9f522018-09-26 10:49:00 -07001201static jobject Bitmap_wrapHardwareBufferBitmap(JNIEnv* env, jobject, jobject hardwareBuffer,
Leon Scroggins III0e443d12018-12-19 11:38:35 -05001202 jlong colorSpacePtr) {
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +01001203#ifdef __ANDROID__ // Layoutlib does not support graphic buffer
Nader Jawad7612c612022-11-15 10:55:54 -08001204 AHardwareBuffer* buffer = uirenderer::HardwareBufferHelpers::AHardwareBuffer_fromHardwareBuffer(
1205 env, hardwareBuffer);
Derek Sollenbergere78f7c92019-07-31 15:18:47 -04001206 sk_sp<Bitmap> bitmap = Bitmap::createFrom(buffer,
1207 GraphicsJNI::getNativeColorSpace(colorSpacePtr));
rennb2e9f522018-09-26 10:49:00 -07001208 if (!bitmap.get()) {
1209 ALOGW("failed to create hardware bitmap from hardware buffer");
1210 return NULL;
1211 }
1212 return bitmap::createBitmap(env, bitmap.release(), getPremulBitmapCreateFlags(false));
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +01001213#else
1214 return NULL;
1215#endif
rennb2e9f522018-09-26 10:49:00 -07001216}
1217
Leon Scroggins III5a190b12020-02-18 13:52:18 -05001218static jobject Bitmap_getHardwareBuffer(JNIEnv* env, jobject, jlong bitmapPtr) {
1219#ifdef __ANDROID__ // Layoutlib does not support graphic buffer
1220 LocalScopedBitmap bitmapHandle(bitmapPtr);
Leon Scroggins IIIa72a7ff2020-02-28 15:41:56 -05001221 if (!bitmapHandle->isHardware()) {
1222 jniThrowException(env, "java/lang/IllegalStateException",
Leon Scroggins III5a190b12020-02-18 13:52:18 -05001223 "Hardware config is only supported config in Bitmap_getHardwareBuffer");
Leon Scroggins IIIa72a7ff2020-02-28 15:41:56 -05001224 return nullptr;
1225 }
Leon Scroggins III5a190b12020-02-18 13:52:18 -05001226
1227 Bitmap& bitmap = bitmapHandle->bitmap();
Nader Jawad7612c612022-11-15 10:55:54 -08001228 return uirenderer::HardwareBufferHelpers::AHardwareBuffer_toHardwareBuffer(
1229 env, bitmap.hardwareBuffer());
Leon Scroggins III5a190b12020-02-18 13:52:18 -05001230#else
Leon Scroggins IIIa72a7ff2020-02-28 15:41:56 -05001231 return nullptr;
Leon Scroggins III5a190b12020-02-18 13:52:18 -05001232#endif
1233}
1234
Jerome Gaillard21e7e2d2019-05-14 14:34:46 +01001235static jboolean Bitmap_isImmutable(CRITICAL_JNI_PARAMS_COMMA jlong bitmapHandle) {
Nader Jawade7b51292018-04-12 17:55:31 -07001236 LocalScopedBitmap bitmapHolder(bitmapHandle);
1237 if (!bitmapHolder.valid()) return JNI_FALSE;
1238
1239 return bitmapHolder->bitmap().isImmutable() ? JNI_TRUE : JNI_FALSE;
1240}
1241
Leon Scroggins III3eb98432020-03-11 15:38:12 -04001242static jboolean Bitmap_isBackedByAshmem(CRITICAL_JNI_PARAMS_COMMA jlong bitmapHandle) {
1243 LocalScopedBitmap bitmapHolder(bitmapHandle);
1244 if (!bitmapHolder.valid()) return JNI_FALSE;
1245
1246 return bitmapHolder->bitmap().pixelStorageType() == PixelStorageType::Ashmem ? JNI_TRUE
1247 : JNI_FALSE;
1248}
1249
Nader Jawade7b51292018-04-12 17:55:31 -07001250static void Bitmap_setImmutable(JNIEnv* env, jobject, jlong bitmapHandle) {
1251 LocalScopedBitmap bitmapHolder(bitmapHandle);
1252 if (!bitmapHolder.valid()) return;
1253
1254 return bitmapHolder->bitmap().setImmutable();
1255}
1256
John Reck5bd537e2023-01-24 20:13:45 -05001257static jboolean Bitmap_hasGainmap(CRITICAL_JNI_PARAMS_COMMA jlong bitmapHandle) {
1258 LocalScopedBitmap bitmapHolder(bitmapHandle);
1259 if (!bitmapHolder.valid()) return false;
1260
1261 return bitmapHolder->bitmap().hasGainmap();
1262}
1263
1264static jobject Bitmap_extractGainmap(JNIEnv* env, jobject, jlong bitmapHandle) {
1265 LocalScopedBitmap bitmapHolder(bitmapHandle);
1266 if (!bitmapHolder.valid()) return nullptr;
1267 if (!bitmapHolder->bitmap().hasGainmap()) return nullptr;
1268
1269 return Gainmap_extractFromBitmap(env, bitmapHolder->bitmap());
1270}
1271
Chris Craik32054b02014-05-09 13:58:56 -07001272///////////////////////////////////////////////////////////////////////////////
1273
Daniel Micay76f6a862015-09-19 17:31:01 -04001274static const JNINativeMethod gBitmapMethods[] = {
John Reck5bd537e2023-01-24 20:13:45 -05001275 {"nativeCreate", "([IIIIIIZJ)Landroid/graphics/Bitmap;", (void*)Bitmap_creator},
1276 {"nativeCopy", "(JIZ)Landroid/graphics/Bitmap;", (void*)Bitmap_copy},
1277 {"nativeCopyAshmem", "(J)Landroid/graphics/Bitmap;", (void*)Bitmap_copyAshmem},
1278 {"nativeCopyAshmemConfig", "(JI)Landroid/graphics/Bitmap;", (void*)Bitmap_copyAshmemConfig},
1279 {"nativeGetAshmemFD", "(J)I", (void*)Bitmap_getAshmemFd},
1280 {"nativeGetNativeFinalizer", "()J", (void*)Bitmap_getNativeFinalizer},
1281 {"nativeRecycle", "(J)V", (void*)Bitmap_recycle},
1282 {"nativeReconfigure", "(JIIIZ)V", (void*)Bitmap_reconfigure},
1283 {"nativeCompress", "(JIILjava/io/OutputStream;[B)Z", (void*)Bitmap_compress},
1284 {"nativeErase", "(JI)V", (void*)Bitmap_erase},
1285 {"nativeErase", "(JJJ)V", (void*)Bitmap_eraseLong},
1286 {"nativeRowBytes", "(J)I", (void*)Bitmap_rowBytes},
1287 {"nativeConfig", "(J)I", (void*)Bitmap_config},
1288 {"nativeHasAlpha", "(J)Z", (void*)Bitmap_hasAlpha},
1289 {"nativeIsPremultiplied", "(J)Z", (void*)Bitmap_isPremultiplied},
1290 {"nativeSetHasAlpha", "(JZZ)V", (void*)Bitmap_setHasAlpha},
1291 {"nativeSetPremultiplied", "(JZ)V", (void*)Bitmap_setPremultiplied},
1292 {"nativeHasMipMap", "(J)Z", (void*)Bitmap_hasMipMap},
1293 {"nativeSetHasMipMap", "(JZ)V", (void*)Bitmap_setHasMipMap},
1294 {"nativeCreateFromParcel", "(Landroid/os/Parcel;)Landroid/graphics/Bitmap;",
1295 (void*)Bitmap_createFromParcel},
1296 {"nativeWriteToParcel", "(JILandroid/os/Parcel;)Z", (void*)Bitmap_writeToParcel},
1297 {"nativeExtractAlpha", "(JJ[I)Landroid/graphics/Bitmap;", (void*)Bitmap_extractAlpha},
1298 {"nativeGenerationId", "(J)I", (void*)Bitmap_getGenerationId},
1299 {"nativeGetPixel", "(JII)I", (void*)Bitmap_getPixel},
1300 {"nativeGetColor", "(JII)J", (void*)Bitmap_getColor},
1301 {"nativeGetPixels", "(J[IIIIIII)V", (void*)Bitmap_getPixels},
1302 {"nativeSetPixel", "(JIII)V", (void*)Bitmap_setPixel},
1303 {"nativeSetPixels", "(J[IIIIIII)V", (void*)Bitmap_setPixels},
1304 {"nativeCopyPixelsToBuffer", "(JLjava/nio/Buffer;)V", (void*)Bitmap_copyPixelsToBuffer},
1305 {"nativeCopyPixelsFromBuffer", "(JLjava/nio/Buffer;)V", (void*)Bitmap_copyPixelsFromBuffer},
1306 {"nativeSameAs", "(JJ)Z", (void*)Bitmap_sameAs},
1307 {"nativePrepareToDraw", "(J)V", (void*)Bitmap_prepareToDraw},
1308 {"nativeGetAllocationByteCount", "(J)I", (void*)Bitmap_getAllocationByteCount},
1309 {"nativeCopyPreserveInternalConfig", "(J)Landroid/graphics/Bitmap;",
1310 (void*)Bitmap_copyPreserveInternalConfig},
1311 {"nativeWrapHardwareBufferBitmap",
1312 "(Landroid/hardware/HardwareBuffer;J)Landroid/graphics/Bitmap;",
1313 (void*)Bitmap_wrapHardwareBufferBitmap},
1314 {"nativeGetHardwareBuffer", "(J)Landroid/hardware/HardwareBuffer;",
1315 (void*)Bitmap_getHardwareBuffer},
1316 {"nativeComputeColorSpace", "(J)Landroid/graphics/ColorSpace;",
1317 (void*)Bitmap_computeColorSpace},
1318 {"nativeSetColorSpace", "(JJ)V", (void*)Bitmap_setColorSpace},
1319 {"nativeIsSRGB", "(J)Z", (void*)Bitmap_isSRGB},
1320 {"nativeIsSRGBLinear", "(J)Z", (void*)Bitmap_isSRGBLinear},
1321 {"nativeSetImmutable", "(J)V", (void*)Bitmap_setImmutable},
1322 {"nativeExtractGainmap", "(J)Landroid/graphics/Gainmap;", (void*)Bitmap_extractGainmap},
Nader Jawade7b51292018-04-12 17:55:31 -07001323
John Reck5bd537e2023-01-24 20:13:45 -05001324 // ------------ @CriticalNative ----------------
1325 {"nativeIsImmutable", "(J)Z", (void*)Bitmap_isImmutable},
1326 {"nativeIsBackedByAshmem", "(J)Z", (void*)Bitmap_isBackedByAshmem},
1327 {"nativeHasGainmap", "(J)Z", (void*)Bitmap_hasGainmap},
Nader Jawade7b51292018-04-12 17:55:31 -07001328
Chris Craik32054b02014-05-09 13:58:56 -07001329};
1330
Chris Craik32054b02014-05-09 13:58:56 -07001331int register_android_graphics_Bitmap(JNIEnv* env)
1332{
Romain Guy95648b82017-04-13 18:43:42 -07001333 gBitmap_class = MakeGlobalRefOrDie(env, FindClassOrDie(env, "android/graphics/Bitmap"));
1334 gBitmap_nativePtr = GetFieldIDOrDie(env, gBitmap_class, "mNativePtr", "J");
Leon Scroggins IIIbbdb7312019-01-31 14:35:54 -05001335 gBitmap_constructorMethodID = GetMethodIDOrDie(env, gBitmap_class, "<init>", "(JIIIZ[BLandroid/graphics/NinePatch$InsetStruct;Z)V");
Romain Guy95648b82017-04-13 18:43:42 -07001336 gBitmap_reinitMethodID = GetMethodIDOrDie(env, gBitmap_class, "reinit", "(IIZ)V");
Nader Jawad7612c612022-11-15 10:55:54 -08001337 uirenderer::HardwareBufferHelpers::init();
Andreas Gampeed6b9df2014-11-20 22:02:20 -08001338 return android::RegisterMethodsOrDie(env, "android/graphics/Bitmap", gBitmapMethods,
1339 NELEM(gBitmapMethods));
John Reck9192d5e2016-10-31 10:32:09 -07001340}