| /* |
| * Copyright (C) 2017 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include "Bitmap.h" |
| #include "BitmapFactory.h" |
| #include "ByteBufferStreamAdaptor.h" |
| #include "CreateJavaOutputStreamAdaptor.h" |
| #include "GraphicsJNI.h" |
| #include "ImageDecoder.h" |
| #include "Utils.h" |
| #include "core_jni_helpers.h" |
| |
| #include <hwui/Bitmap.h> |
| |
| #include <SkAndroidCodec.h> |
| #include <SkEncodedImageFormat.h> |
| #include <SkFrontBufferedStream.h> |
| #include <SkStream.h> |
| |
| #include <androidfw/Asset.h> |
| #include <jni.h> |
| #include <sys/stat.h> |
| |
| using namespace android; |
| |
| static jclass gImageDecoder_class; |
| static jclass gSize_class; |
| static jclass gIncomplete_class; |
| static jclass gCanvas_class; |
| static jmethodID gImageDecoder_constructorMethodID; |
| static jmethodID gImageDecoder_postProcessMethodID; |
| static jmethodID gSize_constructorMethodID; |
| static jmethodID gIncomplete_constructorMethodID; |
| static jmethodID gCallback_onPartialImageMethodID; |
| static jmethodID gCanvas_constructorMethodID; |
| static jmethodID gCanvas_releaseMethodID; |
| |
| static jobject native_create(JNIEnv* env, std::unique_ptr<SkStream> stream) { |
| if (!stream.get()) { |
| doThrowIOE(env, "Failed to create a stream"); |
| return nullptr; |
| } |
| std::unique_ptr<ImageDecoder> decoder(new ImageDecoder); |
| SkCodec::Result result; |
| auto codec = SkCodec::MakeFromStream(std::move(stream), &result, decoder->mPeeker.get()); |
| if (!codec) { |
| switch (result) { |
| case SkCodec::kIncompleteInput: |
| env->ThrowNew(gIncomplete_class, "Incomplete input"); |
| break; |
| default: |
| SkString msg; |
| msg.printf("Failed to create image decoder with message '%s'", |
| SkCodec::ResultToString(result)); |
| doThrowIOE(env, msg.c_str()); |
| break; |
| |
| } |
| return nullptr; |
| } |
| |
| // FIXME: Avoid parsing the whole image? |
| const bool animated = codec->getFrameCount() > 1; |
| decoder->mCodec = SkAndroidCodec::MakeFromCodec(std::move(codec), |
| SkAndroidCodec::ExifOrientationBehavior::kRespect); |
| if (!decoder->mCodec.get()) { |
| doThrowIOE(env, "Could not create AndroidCodec"); |
| return nullptr; |
| } |
| const auto& info = decoder->mCodec->getInfo(); |
| const int width = info.width(); |
| const int height = info.height(); |
| return env->NewObject(gImageDecoder_class, gImageDecoder_constructorMethodID, |
| reinterpret_cast<jlong>(decoder.release()), width, height, |
| animated); |
| } |
| |
| static jobject ImageDecoder_nCreateFd(JNIEnv* env, jobject /*clazz*/, |
| jobject fileDescriptor) { |
| int descriptor = jniGetFDFromFileDescriptor(env, fileDescriptor); |
| |
| struct stat fdStat; |
| if (fstat(descriptor, &fdStat) == -1) { |
| doThrowIOE(env, "broken file descriptor; fstat returned -1"); |
| return nullptr; |
| } |
| |
| int dupDescriptor = dup(descriptor); |
| FILE* file = fdopen(dupDescriptor, "r"); |
| if (file == NULL) { |
| close(dupDescriptor); |
| doThrowIOE(env, "Could not open file"); |
| return nullptr; |
| } |
| std::unique_ptr<SkFILEStream> fileStream(new SkFILEStream(file)); |
| |
| if (::lseek(descriptor, 0, SEEK_CUR) == 0) { |
| return native_create(env, std::move(fileStream)); |
| } |
| |
| // FIXME: This allows us to pretend the current location is the beginning, |
| // but it would be better if SkFILEStream allowed treating its starting |
| // point as the beginning. |
| std::unique_ptr<SkStream> stream(SkFrontBufferedStream::Make(std::move(fileStream), |
| SkCodec::MinBufferedBytesNeeded())); |
| return native_create(env, std::move(stream)); |
| } |
| |
| static jobject ImageDecoder_nCreateInputStream(JNIEnv* env, jobject /*clazz*/, |
| jobject is, jbyteArray storage) { |
| std::unique_ptr<SkStream> stream(CreateJavaInputStreamAdaptor(env, is, storage, false)); |
| |
| if (!stream.get()) { |
| doThrowIOE(env, "Failed to create stream!"); |
| return nullptr; |
| } |
| std::unique_ptr<SkStream> bufferedStream( |
| SkFrontBufferedStream::Make(std::move(stream), |
| SkCodec::MinBufferedBytesNeeded())); |
| return native_create(env, std::move(bufferedStream)); |
| } |
| |
| static jobject ImageDecoder_nCreateAsset(JNIEnv* env, jobject /*clazz*/, jlong assetPtr) { |
| Asset* asset = reinterpret_cast<Asset*>(assetPtr); |
| std::unique_ptr<SkStream> stream(new AssetStreamAdaptor(asset)); |
| return native_create(env, std::move(stream)); |
| } |
| |
| static jobject ImageDecoder_nCreateByteBuffer(JNIEnv* env, jobject /*clazz*/, jobject jbyteBuffer, |
| jint initialPosition, jint limit) { |
| std::unique_ptr<SkStream> stream = CreateByteBufferStreamAdaptor(env, jbyteBuffer, |
| initialPosition, limit); |
| if (!stream) { |
| doThrowIOE(env, "Failed to read ByteBuffer"); |
| return nullptr; |
| } |
| return native_create(env, std::move(stream)); |
| } |
| |
| static jobject ImageDecoder_nCreateByteArray(JNIEnv* env, jobject /*clazz*/, jbyteArray byteArray, |
| jint offset, jint length) { |
| std::unique_ptr<SkStream> stream(CreateByteArrayStreamAdaptor(env, byteArray, offset, length)); |
| return native_create(env, std::move(stream)); |
| } |
| |
| jint postProcessAndRelease(JNIEnv* env, jobject jimageDecoder, std::unique_ptr<Canvas> canvas) { |
| jobject jcanvas = env->NewObject(gCanvas_class, gCanvas_constructorMethodID, |
| reinterpret_cast<jlong>(canvas.get())); |
| if (!jcanvas) { |
| doThrowOOME(env, "Failed to create Java Canvas for PostProcess!"); |
| return ImageDecoder::kUnknown; |
| } |
| |
| // jcanvas now owns canvas. |
| canvas.release(); |
| |
| return env->CallIntMethod(jimageDecoder, gImageDecoder_postProcessMethodID, jcanvas); |
| } |
| |
| // Note: jpostProcess points to an ImageDecoder object if it has a PostProcess object, and nullptr |
| // otherwise. |
| static jobject ImageDecoder_nDecodeBitmap(JNIEnv* env, jobject /*clazz*/, jlong nativePtr, |
| jobject jcallback, jobject jpostProcess, |
| jint desiredWidth, jint desiredHeight, jobject jsubset, |
| jboolean requireMutable, jint allocator, |
| jboolean requireUnpremul, jboolean preferRamOverQuality, |
| jboolean asAlphaMask) { |
| auto* decoder = reinterpret_cast<ImageDecoder*>(nativePtr); |
| SkAndroidCodec* codec = decoder->mCodec.get(); |
| const SkISize desiredSize = SkISize::Make(desiredWidth, desiredHeight); |
| SkISize decodeSize = desiredSize; |
| const int sampleSize = codec->computeSampleSize(&decodeSize); |
| const bool scale = desiredSize != decodeSize; |
| SkImageInfo decodeInfo = codec->getInfo().makeWH(decodeSize.width(), decodeSize.height()); |
| if (scale && requireUnpremul && kOpaque_SkAlphaType != decodeInfo.alphaType()) { |
| doThrowISE(env, "Cannot scale unpremultiplied pixels!"); |
| return nullptr; |
| } |
| |
| switch (decodeInfo.alphaType()) { |
| case kUnpremul_SkAlphaType: |
| if (!requireUnpremul) { |
| decodeInfo = decodeInfo.makeAlphaType(kPremul_SkAlphaType); |
| } |
| break; |
| case kPremul_SkAlphaType: |
| if (requireUnpremul) { |
| decodeInfo = decodeInfo.makeAlphaType(kUnpremul_SkAlphaType); |
| } |
| break; |
| case kOpaque_SkAlphaType: |
| break; |
| case kUnknown_SkAlphaType: |
| doThrowIOE(env, "Unknown alpha type"); |
| return nullptr; |
| } |
| |
| SkColorType colorType = kN32_SkColorType; |
| if (asAlphaMask && decodeInfo.colorType() == kGray_8_SkColorType) { |
| // We have to trick Skia to decode this to a single channel. |
| colorType = kGray_8_SkColorType; |
| } else if (preferRamOverQuality) { |
| // FIXME: The post-process might add alpha, which would make a 565 |
| // result incorrect. If we call the postProcess before now and record |
| // to a picture, we can know whether alpha was added, and if not, we |
| // can still use 565. |
| if (decodeInfo.alphaType() == kOpaque_SkAlphaType && !jpostProcess) { |
| // If the final result will be hardware, decoding to 565 and then |
| // uploading to the gpu as 8888 will not save memory. This still |
| // may save us from using F16, but do not go down to 565. |
| if (allocator != ImageDecoder::kHardware_Allocator && |
| (allocator != ImageDecoder::kDefault_Allocator || requireMutable)) { |
| colorType = kRGB_565_SkColorType; |
| } |
| } |
| // Otherwise, stick with N32 |
| } else { |
| // This is currently the only way to know that we should decode to F16. |
| colorType = codec->computeOutputColorType(colorType); |
| } |
| sk_sp<SkColorSpace> colorSpace = codec->computeOutputColorSpace(colorType); |
| decodeInfo = decodeInfo.makeColorType(colorType).makeColorSpace(colorSpace); |
| |
| SkBitmap bm; |
| auto bitmapInfo = decodeInfo; |
| if (asAlphaMask && colorType == kGray_8_SkColorType) { |
| bitmapInfo = bitmapInfo.makeColorType(kAlpha_8_SkColorType); |
| } |
| if (!bm.setInfo(bitmapInfo)) { |
| doThrowIOE(env, "Failed to setInfo properly"); |
| return nullptr; |
| } |
| |
| sk_sp<Bitmap> nativeBitmap; |
| // If we are going to scale or subset, we will create a new bitmap later on, |
| // so use the heap for the temporary. |
| // FIXME: Use scanline decoding on only a couple lines to save memory. b/70709380. |
| if (allocator == ImageDecoder::kSharedMemory_Allocator && !scale && !jsubset) { |
| nativeBitmap = Bitmap::allocateAshmemBitmap(&bm); |
| } else { |
| nativeBitmap = Bitmap::allocateHeapBitmap(&bm); |
| } |
| if (!nativeBitmap) { |
| SkString msg; |
| msg.printf("OOM allocating Bitmap with dimensions %i x %i", |
| decodeInfo.width(), decodeInfo.height()); |
| doThrowOOME(env, msg.c_str()); |
| return nullptr; |
| } |
| |
| SkAndroidCodec::AndroidOptions options; |
| options.fSampleSize = sampleSize; |
| auto result = codec->getAndroidPixels(decodeInfo, bm.getPixels(), bm.rowBytes(), &options); |
| jthrowable jexception = env->ExceptionOccurred(); |
| if (jexception) { |
| env->ExceptionClear(); |
| } |
| int onPartialImageError = jexception ? 1 // ImageDecoder.java's ERROR_SOURCE_EXCEPTION |
| : 0; // No error. |
| switch (result) { |
| case SkCodec::kSuccess: |
| // Ignore the exception, since the decode was successful anyway. |
| jexception = nullptr; |
| onPartialImageError = 0; |
| break; |
| case SkCodec::kIncompleteInput: |
| if (!jexception) { |
| onPartialImageError = 2; // ImageDecoder.java's ERROR_SOURCE_EXCEPTION |
| } |
| break; |
| case SkCodec::kErrorInInput: |
| if (!jexception) { |
| onPartialImageError = 3; // ImageDecoder.java's ERROR_SOURCE_ERROR |
| } |
| break; |
| default: |
| SkString msg; |
| msg.printf("getPixels failed with error %s", SkCodec::ResultToString(result)); |
| doThrowIOE(env, msg.c_str()); |
| return nullptr; |
| } |
| |
| if (jexception || onPartialImageError) { |
| bool throwException = !jcallback || |
| !env->CallBooleanMethod(jcallback, gCallback_onPartialImageMethodID, |
| onPartialImageError); |
| if (env->ExceptionCheck()) { |
| return nullptr; |
| } |
| |
| if (throwException) { |
| if (jexception) { |
| env->Throw(jexception); |
| } else if (onPartialImageError == 2) { |
| env->ThrowNew(gIncomplete_class, "Incomplete input"); |
| } else { |
| doThrowIOE(env, "image has an error!"); |
| } |
| return nullptr; |
| } |
| } |
| |
| float scaleX = 1.0f; |
| float scaleY = 1.0f; |
| if (scale) { |
| scaleX = (float) desiredWidth / decodeInfo.width(); |
| scaleY = (float) desiredHeight / decodeInfo.height(); |
| } |
| |
| jbyteArray ninePatchChunk = nullptr; |
| jobject ninePatchInsets = nullptr; |
| |
| // Ignore ninepatch when post-processing. |
| if (!jpostProcess) { |
| // FIXME: Share more code with BitmapFactory.cpp. |
| if (decoder->mPeeker->mPatch != nullptr) { |
| if (scale) { |
| decoder->mPeeker->scale(scaleX, scaleY, desiredWidth, desiredHeight); |
| } |
| size_t ninePatchArraySize = decoder->mPeeker->mPatch->serializedSize(); |
| ninePatchChunk = env->NewByteArray(ninePatchArraySize); |
| if (ninePatchChunk == nullptr) { |
| doThrowOOME(env, "Failed to allocate nine patch chunk."); |
| return nullptr; |
| } |
| |
| env->SetByteArrayRegion(ninePatchChunk, 0, decoder->mPeeker->mPatchSize, |
| reinterpret_cast<jbyte*>(decoder->mPeeker->mPatch)); |
| } |
| |
| if (decoder->mPeeker->mHasInsets) { |
| ninePatchInsets = decoder->mPeeker->createNinePatchInsets(env, 1.0f); |
| if (ninePatchInsets == nullptr) { |
| doThrowOOME(env, "Failed to allocate nine patch insets."); |
| return nullptr; |
| } |
| } |
| } |
| |
| if (scale || jsubset) { |
| int translateX = 0; |
| int translateY = 0; |
| if (jsubset) { |
| SkIRect subset; |
| GraphicsJNI::jrect_to_irect(env, jsubset, &subset); |
| |
| // FIXME: If there is no scale, should this instead call |
| // SkBitmap::extractSubset? If we could upload a subset |
| // (b/70626068), this would save memory and time. Even for a |
| // software Bitmap, the extra speed might be worth the memory |
| // tradeoff if the subset is large? |
| translateX = -subset.fLeft; |
| translateY = -subset.fTop; |
| desiredWidth = subset.width(); |
| desiredHeight = subset.height(); |
| } |
| SkImageInfo scaledInfo = bitmapInfo.makeWH(desiredWidth, desiredHeight); |
| SkBitmap scaledBm; |
| if (!scaledBm.setInfo(scaledInfo)) { |
| doThrowIOE(env, "Failed scaled setInfo"); |
| return nullptr; |
| } |
| |
| sk_sp<Bitmap> scaledPixelRef; |
| if (allocator == ImageDecoder::kSharedMemory_Allocator) { |
| scaledPixelRef = Bitmap::allocateAshmemBitmap(&scaledBm); |
| } else { |
| scaledPixelRef = Bitmap::allocateHeapBitmap(&scaledBm); |
| } |
| if (!scaledPixelRef) { |
| SkString msg; |
| msg.printf("OOM allocating scaled Bitmap with dimensions %i x %i", |
| desiredWidth, desiredHeight); |
| doThrowOOME(env, msg.c_str()); |
| return nullptr; |
| } |
| |
| SkPaint paint; |
| paint.setBlendMode(SkBlendMode::kSrc); |
| paint.setFilterQuality(kLow_SkFilterQuality); // bilinear filtering |
| |
| SkCanvas canvas(scaledBm, SkCanvas::ColorBehavior::kLegacy); |
| canvas.translate(translateX, translateY); |
| canvas.scale(scaleX, scaleY); |
| canvas.drawBitmap(bm, 0.0f, 0.0f, &paint); |
| |
| bm.swap(scaledBm); |
| nativeBitmap = std::move(scaledPixelRef); |
| } |
| |
| if (jpostProcess) { |
| std::unique_ptr<Canvas> canvas(Canvas::create_canvas(bm)); |
| |
| jint pixelFormat = postProcessAndRelease(env, jpostProcess, std::move(canvas)); |
| if (env->ExceptionCheck()) { |
| return nullptr; |
| } |
| |
| SkAlphaType newAlphaType = bm.alphaType(); |
| switch (pixelFormat) { |
| case ImageDecoder::kUnknown: |
| break; |
| case ImageDecoder::kTranslucent: |
| newAlphaType = kPremul_SkAlphaType; |
| break; |
| case ImageDecoder::kOpaque: |
| newAlphaType = kOpaque_SkAlphaType; |
| break; |
| default: |
| SkString msg; |
| msg.printf("invalid return from postProcess: %i", pixelFormat); |
| doThrowIAE(env, msg.c_str()); |
| return nullptr; |
| } |
| |
| if (newAlphaType != bm.alphaType()) { |
| if (!bm.setAlphaType(newAlphaType)) { |
| SkString msg; |
| msg.printf("incompatible return from postProcess: %i", pixelFormat); |
| doThrowIAE(env, msg.c_str()); |
| return nullptr; |
| } |
| nativeBitmap->setAlphaType(newAlphaType); |
| } |
| } |
| |
| int bitmapCreateFlags = 0x0; |
| if (!requireUnpremul) { |
| // Even if the image is opaque, setting this flag means that |
| // if alpha is added (e.g. by PostProcess), it will be marked as |
| // premultiplied. |
| bitmapCreateFlags |= bitmap::kBitmapCreateFlag_Premultiplied; |
| } |
| |
| if (requireMutable) { |
| bitmapCreateFlags |= bitmap::kBitmapCreateFlag_Mutable; |
| } else { |
| if ((allocator == ImageDecoder::kDefault_Allocator || |
| allocator == ImageDecoder::kHardware_Allocator) |
| && bm.colorType() != kAlpha_8_SkColorType) |
| { |
| sk_sp<Bitmap> hwBitmap = Bitmap::allocateHardwareBitmap(bm); |
| if (hwBitmap) { |
| hwBitmap->setImmutable(); |
| return bitmap::createBitmap(env, hwBitmap.release(), bitmapCreateFlags, |
| ninePatchChunk, ninePatchInsets); |
| } |
| if (allocator == ImageDecoder::kHardware_Allocator) { |
| doThrowOOME(env, "failed to allocate hardware Bitmap!"); |
| return nullptr; |
| } |
| // If we failed to create a hardware bitmap, go ahead and create a |
| // software one. |
| } |
| |
| nativeBitmap->setImmutable(); |
| } |
| return bitmap::createBitmap(env, nativeBitmap.release(), bitmapCreateFlags, ninePatchChunk, |
| ninePatchInsets); |
| } |
| |
| static jobject ImageDecoder_nGetSampledSize(JNIEnv* env, jobject /*clazz*/, jlong nativePtr, |
| jint sampleSize) { |
| auto* decoder = reinterpret_cast<ImageDecoder*>(nativePtr); |
| SkISize size = decoder->mCodec->getSampledDimensions(sampleSize); |
| return env->NewObject(gSize_class, gSize_constructorMethodID, size.width(), size.height()); |
| } |
| |
| static void ImageDecoder_nGetPadding(JNIEnv* env, jobject /*clazz*/, jlong nativePtr, |
| jobject outPadding) { |
| auto* decoder = reinterpret_cast<ImageDecoder*>(nativePtr); |
| decoder->mPeeker->getPadding(env, outPadding); |
| } |
| |
| static void ImageDecoder_nClose(JNIEnv* /*env*/, jobject /*clazz*/, jlong nativePtr) { |
| delete reinterpret_cast<ImageDecoder*>(nativePtr); |
| } |
| |
| static jstring ImageDecoder_nGetMimeType(JNIEnv* env, jobject /*clazz*/, jlong nativePtr) { |
| auto* decoder = reinterpret_cast<ImageDecoder*>(nativePtr); |
| return encodedFormatToString(env, decoder->mCodec->getEncodedFormat()); |
| } |
| |
| static const JNINativeMethod gImageDecoderMethods[] = { |
| { "nCreate", "(J)Landroid/graphics/ImageDecoder;", (void*) ImageDecoder_nCreateAsset }, |
| { "nCreate", "(Ljava/nio/ByteBuffer;II)Landroid/graphics/ImageDecoder;", (void*) ImageDecoder_nCreateByteBuffer }, |
| { "nCreate", "([BII)Landroid/graphics/ImageDecoder;", (void*) ImageDecoder_nCreateByteArray }, |
| { "nCreate", "(Ljava/io/InputStream;[B)Landroid/graphics/ImageDecoder;", (void*) ImageDecoder_nCreateInputStream }, |
| { "nCreate", "(Ljava/io/FileDescriptor;)Landroid/graphics/ImageDecoder;", (void*) ImageDecoder_nCreateFd }, |
| { "nDecodeBitmap", "(JLandroid/graphics/ImageDecoder;Landroid/graphics/ImageDecoder;IILandroid/graphics/Rect;ZIZZZ)Landroid/graphics/Bitmap;", |
| (void*) ImageDecoder_nDecodeBitmap }, |
| { "nGetSampledSize","(JI)Landroid/util/Size;", (void*) ImageDecoder_nGetSampledSize }, |
| { "nGetPadding", "(JLandroid/graphics/Rect;)V", (void*) ImageDecoder_nGetPadding }, |
| { "nClose", "(J)V", (void*) ImageDecoder_nClose}, |
| { "nGetMimeType", "(J)Ljava/lang/String;", (void*) ImageDecoder_nGetMimeType }, |
| }; |
| |
| int register_android_graphics_ImageDecoder(JNIEnv* env) { |
| gImageDecoder_class = MakeGlobalRefOrDie(env, FindClassOrDie(env, "android/graphics/ImageDecoder")); |
| gImageDecoder_constructorMethodID = GetMethodIDOrDie(env, gImageDecoder_class, "<init>", "(JIIZ)V"); |
| gImageDecoder_postProcessMethodID = GetMethodIDOrDie(env, gImageDecoder_class, "postProcessAndRelease", "(Landroid/graphics/Canvas;)I"); |
| |
| gSize_class = MakeGlobalRefOrDie(env, FindClassOrDie(env, "android/util/Size")); |
| gSize_constructorMethodID = GetMethodIDOrDie(env, gSize_class, "<init>", "(II)V"); |
| |
| gIncomplete_class = MakeGlobalRefOrDie(env, FindClassOrDie(env, "android/graphics/ImageDecoder$IncompleteException")); |
| gIncomplete_constructorMethodID = GetMethodIDOrDie(env, gIncomplete_class, "<init>", "()V"); |
| |
| gCallback_onPartialImageMethodID = GetMethodIDOrDie(env, gImageDecoder_class, "onPartialImage", "(I)Z"); |
| |
| gCanvas_class = MakeGlobalRefOrDie(env, FindClassOrDie(env, "android/graphics/Canvas")); |
| gCanvas_constructorMethodID = GetMethodIDOrDie(env, gCanvas_class, "<init>", "(J)V"); |
| gCanvas_releaseMethodID = GetMethodIDOrDie(env, gCanvas_class, "release", "()V"); |
| |
| return android::RegisterMethodsOrDie(env, "android/graphics/ImageDecoder", gImageDecoderMethods, |
| NELEM(gImageDecoderMethods)); |
| } |