1 /*
2 * Copyright (C) 2019 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #undef LOG_TAG
18 #define LOG_TAG "Bitmap"
19 #include <log/log.h>
20
21 #include "android/graphics/bitmap.h"
22 #include "TypeCast.h"
23 #include "GraphicsJNI.h"
24
25 #include <GraphicsJNI.h>
26 #include <hwui/Bitmap.h>
27 #include <utils/Color.h>
28
29 using namespace android;
30
ABitmap_acquireBitmapFromJava(JNIEnv * env,jobject bitmapObj)31 ABitmap* ABitmap_acquireBitmapFromJava(JNIEnv* env, jobject bitmapObj) {
32 Bitmap* bitmap = GraphicsJNI::getNativeBitmap(env, bitmapObj);
33 if (bitmap) {
34 bitmap->ref();
35 return TypeCast::toABitmap(bitmap);
36 }
37 return nullptr;
38 }
39
ABitmap_acquireRef(ABitmap * bitmap)40 void ABitmap_acquireRef(ABitmap* bitmap) {
41 SkSafeRef(TypeCast::toBitmap(bitmap));
42 }
43
ABitmap_releaseRef(ABitmap * bitmap)44 void ABitmap_releaseRef(ABitmap* bitmap) {
45 SkSafeUnref(TypeCast::toBitmap(bitmap));
46 }
47
getFormat(const SkImageInfo & info)48 static AndroidBitmapFormat getFormat(const SkImageInfo& info) {
49 switch (info.colorType()) {
50 case kN32_SkColorType:
51 return ANDROID_BITMAP_FORMAT_RGBA_8888;
52 case kRGB_565_SkColorType:
53 return ANDROID_BITMAP_FORMAT_RGB_565;
54 case kARGB_4444_SkColorType:
55 return ANDROID_BITMAP_FORMAT_RGBA_4444;
56 case kAlpha_8_SkColorType:
57 return ANDROID_BITMAP_FORMAT_A_8;
58 case kRGBA_F16_SkColorType:
59 return ANDROID_BITMAP_FORMAT_RGBA_F16;
60 default:
61 return ANDROID_BITMAP_FORMAT_NONE;
62 }
63 }
64
getColorType(AndroidBitmapFormat format)65 static SkColorType getColorType(AndroidBitmapFormat format) {
66 switch (format) {
67 case ANDROID_BITMAP_FORMAT_RGBA_8888:
68 return kN32_SkColorType;
69 case ANDROID_BITMAP_FORMAT_RGB_565:
70 return kRGB_565_SkColorType;
71 case ANDROID_BITMAP_FORMAT_RGBA_4444:
72 return kARGB_4444_SkColorType;
73 case ANDROID_BITMAP_FORMAT_A_8:
74 return kAlpha_8_SkColorType;
75 case ANDROID_BITMAP_FORMAT_RGBA_F16:
76 return kRGBA_F16_SkColorType;
77 default:
78 return kUnknown_SkColorType;
79 }
80 }
81
getAlphaFlags(const SkImageInfo & info)82 static uint32_t getAlphaFlags(const SkImageInfo& info) {
83 switch (info.alphaType()) {
84 case kUnknown_SkAlphaType:
85 LOG_ALWAYS_FATAL("Bitmap has no alpha type");
86 break;
87 case kOpaque_SkAlphaType:
88 return ANDROID_BITMAP_FLAGS_ALPHA_OPAQUE;
89 case kPremul_SkAlphaType:
90 return ANDROID_BITMAP_FLAGS_ALPHA_PREMUL;
91 case kUnpremul_SkAlphaType:
92 return ANDROID_BITMAP_FLAGS_ALPHA_UNPREMUL;
93 }
94 }
95
getInfoFlags(const SkImageInfo & info,bool isHardware)96 static uint32_t getInfoFlags(const SkImageInfo& info, bool isHardware) {
97 uint32_t flags = getAlphaFlags(info);
98 if (isHardware) {
99 flags |= ANDROID_BITMAP_FLAGS_IS_HARDWARE;
100 }
101 return flags;
102 }
103
ABitmap_copy(ABitmap * srcBitmapHandle,AndroidBitmapFormat dstFormat)104 ABitmap* ABitmap_copy(ABitmap* srcBitmapHandle, AndroidBitmapFormat dstFormat) {
105 SkColorType dstColorType = getColorType(dstFormat);
106 if (srcBitmapHandle && dstColorType != kUnknown_SkColorType) {
107 SkBitmap srcBitmap;
108 TypeCast::toBitmap(srcBitmapHandle)->getSkBitmap(&srcBitmap);
109
110 sk_sp<Bitmap> dstBitmap =
111 Bitmap::allocateHeapBitmap(srcBitmap.info().makeColorType(dstColorType));
112 if (dstBitmap && srcBitmap.readPixels(dstBitmap->info(), dstBitmap->pixels(),
113 dstBitmap->rowBytes(), 0, 0)) {
114 return TypeCast::toABitmap(dstBitmap.release());
115 }
116 }
117 return nullptr;
118 }
119
getInfo(const SkImageInfo & imageInfo,uint32_t rowBytes,bool isHardware)120 static AndroidBitmapInfo getInfo(const SkImageInfo& imageInfo, uint32_t rowBytes, bool isHardware) {
121 AndroidBitmapInfo info;
122 info.width = imageInfo.width();
123 info.height = imageInfo.height();
124 info.stride = rowBytes;
125 info.format = getFormat(imageInfo);
126 info.flags = getInfoFlags(imageInfo, isHardware);
127 return info;
128 }
129
ABitmap_getInfo(ABitmap * bitmapHandle)130 AndroidBitmapInfo ABitmap_getInfo(ABitmap* bitmapHandle) {
131 Bitmap* bitmap = TypeCast::toBitmap(bitmapHandle);
132 return getInfo(bitmap->info(), bitmap->rowBytes(), bitmap->isHardware());
133 }
134
ABitmap_getDataSpace(ABitmap * bitmapHandle)135 ADataSpace ABitmap_getDataSpace(ABitmap* bitmapHandle) {
136 Bitmap* bitmap = TypeCast::toBitmap(bitmapHandle);
137 const SkImageInfo& info = bitmap->info();
138 return (ADataSpace)uirenderer::ColorSpaceToADataSpace(info.colorSpace(), info.colorType());
139 }
140
ABitmap_getInfoFromJava(JNIEnv * env,jobject bitmapObj)141 AndroidBitmapInfo ABitmap_getInfoFromJava(JNIEnv* env, jobject bitmapObj) {
142 uint32_t rowBytes = 0;
143 bool isHardware = false;
144 SkImageInfo imageInfo = GraphicsJNI::getBitmapInfo(env, bitmapObj, &rowBytes, &isHardware);
145 return getInfo(imageInfo, rowBytes, isHardware);
146 }
147
ABitmap_getPixels(ABitmap * bitmapHandle)148 void* ABitmap_getPixels(ABitmap* bitmapHandle) {
149 Bitmap* bitmap = TypeCast::toBitmap(bitmapHandle);
150 if (bitmap->isHardware()) {
151 return nullptr;
152 }
153 return bitmap->pixels();
154 }
155
ABitmapConfig_getFormatFromConfig(JNIEnv * env,jobject bitmapConfigObj)156 AndroidBitmapFormat ABitmapConfig_getFormatFromConfig(JNIEnv* env, jobject bitmapConfigObj) {
157 return GraphicsJNI::getFormatFromConfig(env, bitmapConfigObj);
158 }
159
ABitmapConfig_getConfigFromFormat(JNIEnv * env,AndroidBitmapFormat format)160 jobject ABitmapConfig_getConfigFromFormat(JNIEnv* env, AndroidBitmapFormat format) {
161 return GraphicsJNI::getConfigFromFormat(env, format);
162 }
163
ABitmap_notifyPixelsChanged(ABitmap * bitmapHandle)164 void ABitmap_notifyPixelsChanged(ABitmap* bitmapHandle) {
165 Bitmap* bitmap = TypeCast::toBitmap(bitmapHandle);
166 if (!bitmap->isImmutable()) {
167 bitmap->notifyPixelsChanged();
168 }
169 }
170
171 namespace {
getAlphaType(const AndroidBitmapInfo * info)172 SkAlphaType getAlphaType(const AndroidBitmapInfo* info) {
173 switch (info->flags & ANDROID_BITMAP_FLAGS_ALPHA_MASK) {
174 case ANDROID_BITMAP_FLAGS_ALPHA_OPAQUE:
175 return kOpaque_SkAlphaType;
176 case ANDROID_BITMAP_FLAGS_ALPHA_PREMUL:
177 return kPremul_SkAlphaType;
178 case ANDROID_BITMAP_FLAGS_ALPHA_UNPREMUL:
179 return kUnpremul_SkAlphaType;
180 default:
181 return kUnknown_SkAlphaType;
182 }
183 }
184
185 class CompressWriter : public SkWStream {
186 public:
CompressWriter(void * userContext,AndroidBitmap_CompressWriteFunc fn)187 CompressWriter(void* userContext, AndroidBitmap_CompressWriteFunc fn)
188 : mUserContext(userContext), mFn(fn), mBytesWritten(0) {}
189
write(const void * buffer,size_t size)190 bool write(const void* buffer, size_t size) override {
191 if (mFn(mUserContext, buffer, size)) {
192 mBytesWritten += size;
193 return true;
194 }
195 return false;
196 }
197
bytesWritten() const198 size_t bytesWritten() const override { return mBytesWritten; }
199
200 private:
201 void* mUserContext;
202 AndroidBitmap_CompressWriteFunc mFn;
203 size_t mBytesWritten;
204 };
205
206 } // anonymous namespace
207
ABitmap_compress(const AndroidBitmapInfo * info,ADataSpace dataSpace,const void * pixels,AndroidBitmapCompressFormat inFormat,int32_t quality,void * userContext,AndroidBitmap_CompressWriteFunc fn)208 int ABitmap_compress(const AndroidBitmapInfo* info, ADataSpace dataSpace, const void* pixels,
209 AndroidBitmapCompressFormat inFormat, int32_t quality, void* userContext,
210 AndroidBitmap_CompressWriteFunc fn) {
211 Bitmap::JavaCompressFormat format;
212 switch (inFormat) {
213 case ANDROID_BITMAP_COMPRESS_FORMAT_JPEG:
214 format = Bitmap::JavaCompressFormat::Jpeg;
215 break;
216 case ANDROID_BITMAP_COMPRESS_FORMAT_PNG:
217 format = Bitmap::JavaCompressFormat::Png;
218 break;
219 case ANDROID_BITMAP_COMPRESS_FORMAT_WEBP_LOSSY:
220 format = Bitmap::JavaCompressFormat::WebpLossy;
221 break;
222 case ANDROID_BITMAP_COMPRESS_FORMAT_WEBP_LOSSLESS:
223 format = Bitmap::JavaCompressFormat::WebpLossless;
224 break;
225 default:
226 // kWEBP_JavaEncodeFormat is a valid parameter for Bitmap::compress,
227 // for the deprecated Bitmap.CompressFormat.WEBP, but it should not
228 // be provided via the NDK. Other integers are likewise invalid.
229 return ANDROID_BITMAP_RESULT_BAD_PARAMETER;
230 }
231
232 SkColorType colorType;
233 switch (info->format) {
234 case ANDROID_BITMAP_FORMAT_RGBA_8888:
235 colorType = kN32_SkColorType;
236 break;
237 case ANDROID_BITMAP_FORMAT_RGB_565:
238 colorType = kRGB_565_SkColorType;
239 break;
240 case ANDROID_BITMAP_FORMAT_A_8:
241 // FIXME b/146637821: Should this encode as grayscale? We should
242 // make the same decision as for encoding an android.graphics.Bitmap.
243 // Note that encoding kAlpha_8 as WebP or JPEG will fail. Encoding
244 // it to PNG encodes as GRAY+ALPHA with a secret handshake that we
245 // only care about the alpha. I'm not sure whether Android decoding
246 // APIs respect that handshake.
247 colorType = kAlpha_8_SkColorType;
248 break;
249 case ANDROID_BITMAP_FORMAT_RGBA_F16:
250 colorType = kRGBA_F16_SkColorType;
251 break;
252 default:
253 return ANDROID_BITMAP_RESULT_BAD_PARAMETER;
254 }
255
256 auto alphaType = getAlphaType(info);
257 if (alphaType == kUnknown_SkAlphaType) {
258 return ANDROID_BITMAP_RESULT_BAD_PARAMETER;
259 }
260
261 sk_sp<SkColorSpace> cs;
262 if (info->format == ANDROID_BITMAP_FORMAT_A_8) {
263 // FIXME: A Java Bitmap with ALPHA_8 never has a ColorSpace. So should
264 // we force that here (as I'm doing now) or should we treat anything
265 // besides ADATASPACE_UNKNOWN as an error?
266 cs = nullptr;
267 } else {
268 cs = uirenderer::DataSpaceToColorSpace((android_dataspace) dataSpace);
269 // DataSpaceToColorSpace treats UNKNOWN as SRGB, but compress forces the
270 // client to specify SRGB if that is what they want.
271 if (!cs || dataSpace == ADATASPACE_UNKNOWN) {
272 return ANDROID_BITMAP_RESULT_BAD_PARAMETER;
273 }
274 }
275
276 {
277 size_t size;
278 if (!Bitmap::computeAllocationSize(info->stride, info->height, &size)) {
279 return ANDROID_BITMAP_RESULT_BAD_PARAMETER;
280 }
281 }
282
283 auto imageInfo =
284 SkImageInfo::Make(info->width, info->height, colorType, alphaType, std::move(cs));
285 SkBitmap bitmap;
286 // We are not going to modify the pixels, but installPixels expects them to
287 // not be const, since for all it knows we might want to draw to the SkBitmap.
288 if (!bitmap.installPixels(imageInfo, const_cast<void*>(pixels), info->stride)) {
289 return ANDROID_BITMAP_RESULT_BAD_PARAMETER;
290 }
291
292 CompressWriter stream(userContext, fn);
293 return Bitmap::compress(bitmap, format, quality, &stream) ? ANDROID_BITMAP_RESULT_SUCCESS
294 : ANDROID_BITMAP_RESULT_JNI_EXCEPTION;
295 }
296
ABitmap_getHardwareBuffer(ABitmap * bitmapHandle)297 AHardwareBuffer* ABitmap_getHardwareBuffer(ABitmap* bitmapHandle) {
298 Bitmap* bitmap = TypeCast::toBitmap(bitmapHandle);
299 AHardwareBuffer* buffer = bitmap->hardwareBuffer();
300 if (buffer) {
301 AHardwareBuffer_acquire(buffer);
302 }
303 return buffer;
304 }
305