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