Rounding discrepancies in the image codec infrastructure was allowing gainmaps to be decoded with a 1px border on the edge, which introduces visible seams when zooming into large images. Fix this by adjusting how computing the desired gainmap subregion size, by pretending we downsample first, then compute the subregion size based on that. Add a long paragraph explaining why we have to do this with an example, because it's not entirely intuitive. Also adjust how we poke at the gainmap resampling flag, since some CTS tests run before RenderThread starts up and intializes the properties. Bug: 371123308 Flag: com.android.graphics.hwui.flags.resample_gainmap_regions Test: Decoding in Photos and Files Test: GainmapTest Change-Id: Id608c5838f7890d0304b040e13d7281aa879a75c
517 lines
22 KiB
C++
517 lines
22 KiB
C++
/*
|
|
* Copyright (C) 2010 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 "BitmapRegionDecoder.h"
|
|
|
|
#include <HardwareBitmapUploader.h>
|
|
#include <androidfw/Asset.h>
|
|
#include <sys/stat.h>
|
|
#include <utils/StatsUtils.h>
|
|
|
|
#include <memory>
|
|
|
|
#include "BitmapFactory.h"
|
|
#include "CreateJavaOutputStreamAdaptor.h"
|
|
#include "Gainmap.h"
|
|
#include "GraphicsJNI.h"
|
|
#include "SkBitmap.h"
|
|
#include "SkCodec.h"
|
|
#include "SkColorSpace.h"
|
|
#include "SkData.h"
|
|
#include "SkGainmapInfo.h"
|
|
#include "SkStream.h"
|
|
#include "SkStreamPriv.h"
|
|
#include "Utils.h"
|
|
|
|
using namespace android;
|
|
|
|
namespace android {
|
|
class BitmapRegionDecoderWrapper {
|
|
public:
|
|
static std::unique_ptr<BitmapRegionDecoderWrapper> Make(sk_sp<SkData> data) {
|
|
std::unique_ptr<skia::BitmapRegionDecoder> mainImageBRD =
|
|
skia::BitmapRegionDecoder::Make(std::move(data));
|
|
if (!mainImageBRD) {
|
|
return nullptr;
|
|
}
|
|
|
|
SkGainmapInfo gainmapInfo;
|
|
std::unique_ptr<SkAndroidCodec> gainmapCodec;
|
|
std::unique_ptr<skia::BitmapRegionDecoder> gainmapBRD = nullptr;
|
|
if (!mainImageBRD->getGainmapBitmapRegionDecoder(&gainmapInfo, &gainmapBRD)) {
|
|
gainmapBRD = nullptr;
|
|
}
|
|
|
|
return std::unique_ptr<BitmapRegionDecoderWrapper>(new BitmapRegionDecoderWrapper(
|
|
std::move(mainImageBRD), std::move(gainmapBRD), gainmapInfo));
|
|
}
|
|
|
|
SkEncodedImageFormat getEncodedFormat() { return mMainImageBRD->getEncodedFormat(); }
|
|
|
|
SkColorType computeOutputColorType(SkColorType requestedColorType) {
|
|
return mMainImageBRD->computeOutputColorType(requestedColorType);
|
|
}
|
|
|
|
sk_sp<SkColorSpace> computeOutputColorSpace(SkColorType outputColorType,
|
|
sk_sp<SkColorSpace> prefColorSpace = nullptr) {
|
|
return mMainImageBRD->computeOutputColorSpace(outputColorType, prefColorSpace);
|
|
}
|
|
|
|
bool decodeRegion(SkBitmap* bitmap, skia::BRDAllocator* allocator, const SkIRect& desiredSubset,
|
|
int sampleSize, SkColorType colorType, bool requireUnpremul,
|
|
sk_sp<SkColorSpace> prefColorSpace) {
|
|
return mMainImageBRD->decodeRegion(bitmap, allocator, desiredSubset, sampleSize, colorType,
|
|
requireUnpremul, prefColorSpace);
|
|
}
|
|
|
|
// Decodes the gainmap region. If decoding succeeded, returns true and
|
|
// populate outGainmap with the decoded gainmap. Otherwise, returns false.
|
|
//
|
|
// Note that the desiredSubset is the logical region within the source
|
|
// gainmap that we want to decode. This is used for scaling into the final
|
|
// bitmap, since we do not want to include portions of the gainmap outside
|
|
// of this region. desiredSubset is also _not_ guaranteed to be
|
|
// pixel-aligned, so it's not possible to simply resize the resulting
|
|
// bitmap to accomplish this.
|
|
bool decodeGainmapRegion(sp<uirenderer::Gainmap>* outGainmap, SkISize bitmapDimensions,
|
|
const SkRect& desiredSubset, int sampleSize, bool requireUnpremul) {
|
|
SkColorType decodeColorType = mGainmapBRD->computeOutputColorType(kN32_SkColorType);
|
|
sk_sp<SkColorSpace> decodeColorSpace =
|
|
mGainmapBRD->computeOutputColorSpace(decodeColorType, nullptr);
|
|
SkBitmap bm;
|
|
// Because we must match the dimensions of the base bitmap, we always use a
|
|
// recycling allocator even though we are allocating a new bitmap. This is to ensure
|
|
// that if a recycled bitmap was used for the base image that we match the relative
|
|
// dimensions of that base image. The behavior of BRD here is:
|
|
// if inBitmap is specified -> output dimensions are always equal to the inBitmap's
|
|
// if no bitmap is reused -> output dimensions are the intersect of the desiredSubset &
|
|
// the image bounds
|
|
// The handling of the above conditionals are baked into the desiredSubset, so we
|
|
// simply need to ensure that the resulting bitmap is the exact same width/height as
|
|
// the specified desiredSubset regardless of the intersection to the image bounds.
|
|
// kPremul_SkAlphaType is used just as a placeholder as it doesn't change the underlying
|
|
// allocation type. RecyclingClippingPixelAllocator will populate this with the
|
|
// actual alpha type in either allocPixelRef() or copyIfNecessary()
|
|
sk_sp<Bitmap> nativeBitmap = Bitmap::allocateHeapBitmap(SkImageInfo::Make(
|
|
bitmapDimensions, decodeColorType, kPremul_SkAlphaType, decodeColorSpace));
|
|
if (!nativeBitmap) {
|
|
ALOGE("OOM allocating Bitmap for Gainmap");
|
|
return false;
|
|
}
|
|
|
|
sampleSize = std::max(sampleSize, 1);
|
|
|
|
// Map the desired subset to the space of the decoded gainmap. The
|
|
// subset is repositioned relative to the resulting bitmap, and then
|
|
// scaled to respect the sampleSize.
|
|
// This assumes that the subset will not be modified by the decoder, which is true
|
|
// for existing gainmap formats.
|
|
SkRect logicalSubset = desiredSubset.makeOffset(-std::floorf(desiredSubset.left()),
|
|
-std::floorf(desiredSubset.top()));
|
|
logicalSubset = scale(logicalSubset, 1.0f / sampleSize);
|
|
|
|
// Round out the subset so that we decode a slightly larger region, in
|
|
// case the subset has fractional components. When we round, we need to
|
|
// round the downsampled subset to avoid possibly rounding down by accident.
|
|
// Consider this concrete example if we round the desired subset directly:
|
|
//
|
|
// * We are decoding a 18x18 corner of an image
|
|
//
|
|
// * Gainmap is 1/4 resolution, which is logically a 4.5x4.5 gainmap
|
|
// that we would want
|
|
//
|
|
// * The app wants to downsample by a factor of 2x
|
|
//
|
|
// * The desired gainmap dimensions are computed to be 3x3 to fit the
|
|
// downsampled gainmap, since we need to fill a 2.25x2.25 region that's
|
|
// later upscaled to 3x3
|
|
//
|
|
// * But, if we round out the desired gainmap region _first_, then we
|
|
// request to decode a 5x5 region, downsampled by 2, which actually
|
|
// decodes a 2x2 region since skia rounds down internally. But then we transfer
|
|
// the result to a 3x3 bitmap using a clipping allocator, which leaves an inset.
|
|
// Not only did we get a smaller region than we expected (so, our desired subset is
|
|
// not valid), but because the API allows for decoding regions using a recycled
|
|
// bitmap, we can't really safely fill in the inset since then we might
|
|
// extend the gainmap beyond intended the image bounds. Oops.
|
|
//
|
|
// * If we instead round out as if we downsampled, then we downsample
|
|
// the desired region to 2.25x2.25, round out to 3x3, then upsample back
|
|
// into the source gainmap space to get 6x6. Then we decode a 6x6 region
|
|
// downsampled into a 3x3 region, and everything's now correct.
|
|
//
|
|
// Note that we don't always run into this problem, because
|
|
// decoders actually round *up* for subsampling when decoding a subset
|
|
// that matches the dimensions of the image. E.g., if the original image
|
|
// size in the above example was a 20x20 image, so that the gainmap was
|
|
// 5x5, then we still manage to downsample into a 3x3 bitmap even with
|
|
// the "wrong" math. but that's what we wanted!
|
|
//
|
|
// Note also that if we overshoot the gainmap bounds with the requested
|
|
// subset it isn't a problem either, since now the decoded bitmap is too
|
|
// large, rather than too small, so now we can use the desired subset to
|
|
// avoid sampling "invalid" colors.
|
|
SkRect scaledSubset = scale(desiredSubset, 1.0f / sampleSize);
|
|
SkIRect roundedSubset = scale(scaledSubset.roundOut(), static_cast<float>(sampleSize));
|
|
|
|
RecyclingClippingPixelAllocator allocator(nativeBitmap.get(), false, logicalSubset);
|
|
if (!mGainmapBRD->decodeRegion(&bm, &allocator, roundedSubset, sampleSize, decodeColorType,
|
|
requireUnpremul, decodeColorSpace)) {
|
|
ALOGE("Error decoding Gainmap region");
|
|
return false;
|
|
}
|
|
allocator.copyIfNecessary();
|
|
auto gainmap = sp<uirenderer::Gainmap>::make();
|
|
if (!gainmap) {
|
|
ALOGE("OOM allocating Gainmap");
|
|
return false;
|
|
}
|
|
gainmap->info = mGainmapInfo;
|
|
gainmap->bitmap = std::move(nativeBitmap);
|
|
*outGainmap = std::move(gainmap);
|
|
return true;
|
|
}
|
|
|
|
struct Projection {
|
|
SkRect srcRect;
|
|
SkISize destSize;
|
|
};
|
|
Projection calculateGainmapRegion(const SkIRect& mainImageRegion, SkISize dimensions) {
|
|
const float scaleX = ((float)mGainmapBRD->width()) / mMainImageBRD->width();
|
|
const float scaleY = ((float)mGainmapBRD->height()) / mMainImageBRD->height();
|
|
|
|
if (uirenderer::Properties::resampleGainmapRegions()) {
|
|
const auto srcRect = SkRect::MakeLTRB(
|
|
mainImageRegion.left() * scaleX, mainImageRegion.top() * scaleY,
|
|
mainImageRegion.right() * scaleX, mainImageRegion.bottom() * scaleY);
|
|
// Request a slightly larger destination size so that the gainmap
|
|
// subset we want fits entirely in this size.
|
|
const auto destSize = SkISize::Make(std::ceil(dimensions.width() * scaleX),
|
|
std::ceil(dimensions.height() * scaleY));
|
|
return Projection{.srcRect = srcRect, .destSize = destSize};
|
|
} else {
|
|
const auto srcRect = SkRect::Make(SkIRect::MakeLTRB(
|
|
mainImageRegion.left() * scaleX, mainImageRegion.top() * scaleY,
|
|
mainImageRegion.right() * scaleX, mainImageRegion.bottom() * scaleY));
|
|
const auto destSize =
|
|
SkISize::Make(dimensions.width() * scaleX, dimensions.height() * scaleY);
|
|
return Projection{.srcRect = srcRect, .destSize = destSize};
|
|
}
|
|
}
|
|
|
|
bool hasGainmap() { return mGainmapBRD != nullptr; }
|
|
|
|
int width() const { return mMainImageBRD->width(); }
|
|
int height() const { return mMainImageBRD->height(); }
|
|
|
|
private:
|
|
BitmapRegionDecoderWrapper(std::unique_ptr<skia::BitmapRegionDecoder> mainImageBRD,
|
|
std::unique_ptr<skia::BitmapRegionDecoder> gainmapBRD,
|
|
SkGainmapInfo info)
|
|
: mMainImageBRD(std::move(mainImageBRD))
|
|
, mGainmapBRD(std::move(gainmapBRD))
|
|
, mGainmapInfo(info) {}
|
|
|
|
SkRect scale(SkRect rect, float scale) const {
|
|
rect.fLeft *= scale;
|
|
rect.fTop *= scale;
|
|
rect.fRight *= scale;
|
|
rect.fBottom *= scale;
|
|
return rect;
|
|
}
|
|
|
|
SkIRect scale(SkIRect rect, float scale) const {
|
|
rect.fLeft *= scale;
|
|
rect.fTop *= scale;
|
|
rect.fRight *= scale;
|
|
rect.fBottom *= scale;
|
|
return rect;
|
|
}
|
|
|
|
std::unique_ptr<skia::BitmapRegionDecoder> mMainImageBRD;
|
|
std::unique_ptr<skia::BitmapRegionDecoder> mGainmapBRD;
|
|
SkGainmapInfo mGainmapInfo;
|
|
};
|
|
} // namespace android
|
|
|
|
static jobject createBitmapRegionDecoder(JNIEnv* env, sk_sp<SkData> data) {
|
|
auto brd = android::BitmapRegionDecoderWrapper::Make(std::move(data));
|
|
if (!brd) {
|
|
doThrowIOE(env, "Image format not supported");
|
|
return nullObjectReturn("CreateBitmapRegionDecoder returned null");
|
|
}
|
|
|
|
return GraphicsJNI::createBitmapRegionDecoder(env, brd.release());
|
|
}
|
|
|
|
static jobject nativeNewInstanceFromByteArray(JNIEnv* env, jobject, jbyteArray byteArray,
|
|
jint offset, jint length) {
|
|
AutoJavaByteArray ar(env, byteArray);
|
|
return createBitmapRegionDecoder(env, SkData::MakeWithCopy(ar.ptr() + offset, length));
|
|
}
|
|
|
|
static jobject nativeNewInstanceFromFileDescriptor(JNIEnv* env, jobject clazz,
|
|
jobject fileDescriptor) {
|
|
NPE_CHECK_RETURN_ZERO(env, fileDescriptor);
|
|
|
|
jint descriptor = jniGetFDFromFileDescriptor(env, fileDescriptor);
|
|
|
|
struct stat fdStat;
|
|
if (fstat(descriptor, &fdStat) == -1) {
|
|
doThrowIOE(env, "broken file descriptor");
|
|
return nullObjectReturn("fstat return -1");
|
|
}
|
|
|
|
return createBitmapRegionDecoder(env, SkData::MakeFromFD(descriptor));
|
|
}
|
|
|
|
static jobject nativeNewInstanceFromStream(JNIEnv* env, jobject clazz, jobject is, // InputStream
|
|
jbyteArray storage) { // byte[]
|
|
jobject brd = nullptr;
|
|
sk_sp<SkData> data = CopyJavaInputStream(env, is, storage);
|
|
|
|
if (data) {
|
|
brd = createBitmapRegionDecoder(env, std::move(data));
|
|
}
|
|
return brd;
|
|
}
|
|
|
|
static jobject nativeNewInstanceFromAsset(JNIEnv* env, jobject clazz, jlong native_asset) {
|
|
Asset* asset = reinterpret_cast<Asset*>(native_asset);
|
|
sk_sp<SkData> data = CopyAssetToData(asset);
|
|
if (!data) {
|
|
return nullptr;
|
|
}
|
|
|
|
return createBitmapRegionDecoder(env, data);
|
|
}
|
|
|
|
/*
|
|
* nine patch not supported
|
|
* purgeable not supported
|
|
* reportSizeToVM not supported
|
|
*/
|
|
static jobject nativeDecodeRegion(JNIEnv* env, jobject, jlong brdHandle, jint inputX,
|
|
jint inputY, jint inputWidth, jint inputHeight, jobject options, jlong inBitmapHandle,
|
|
jlong colorSpaceHandle) {
|
|
|
|
// Set default options.
|
|
int sampleSize = 1;
|
|
SkColorType colorType = kN32_SkColorType;
|
|
bool requireUnpremul = false;
|
|
jobject javaBitmap = nullptr;
|
|
bool isHardware = false;
|
|
sk_sp<SkColorSpace> colorSpace = GraphicsJNI::getNativeColorSpace(colorSpaceHandle);
|
|
// Update the default options with any options supplied by the client.
|
|
if (NULL != options) {
|
|
sampleSize = env->GetIntField(options, gOptions_sampleSizeFieldID);
|
|
jobject jconfig = env->GetObjectField(options, gOptions_configFieldID);
|
|
colorType = GraphicsJNI::getNativeBitmapColorType(env, jconfig);
|
|
isHardware = GraphicsJNI::isHardwareConfig(env, jconfig);
|
|
requireUnpremul = !env->GetBooleanField(options, gOptions_premultipliedFieldID);
|
|
javaBitmap = env->GetObjectField(options, gOptions_bitmapFieldID);
|
|
// The Java options of ditherMode and preferQualityOverSpeed are deprecated. We will
|
|
// ignore the values of these fields.
|
|
|
|
// Initialize these fields to indicate a failure. If the decode succeeds, we
|
|
// will update them later on.
|
|
env->SetIntField(options, gOptions_widthFieldID, -1);
|
|
env->SetIntField(options, gOptions_heightFieldID, -1);
|
|
env->SetObjectField(options, gOptions_mimeFieldID, 0);
|
|
env->SetObjectField(options, gOptions_outConfigFieldID, 0);
|
|
env->SetObjectField(options, gOptions_outColorSpaceFieldID, 0);
|
|
}
|
|
|
|
// Recycle a bitmap if possible.
|
|
android::Bitmap* recycledBitmap = nullptr;
|
|
if (javaBitmap) {
|
|
recycledBitmap = &bitmap::toBitmap(inBitmapHandle);
|
|
if (recycledBitmap->isImmutable()) {
|
|
ALOGW("Warning: Reusing an immutable bitmap as an image decoder target.");
|
|
}
|
|
}
|
|
|
|
auto* brd = reinterpret_cast<BitmapRegionDecoderWrapper*>(brdHandle);
|
|
SkColorType decodeColorType = brd->computeOutputColorType(colorType);
|
|
|
|
if (isHardware) {
|
|
if (decodeColorType == kRGBA_F16_SkColorType &&
|
|
!uirenderer::HardwareBitmapUploader::hasFP16Support()) {
|
|
decodeColorType = kN32_SkColorType;
|
|
}
|
|
if (decodeColorType == kRGBA_1010102_SkColorType &&
|
|
!uirenderer::HardwareBitmapUploader::has1010102Support()) {
|
|
decodeColorType = kN32_SkColorType;
|
|
}
|
|
}
|
|
|
|
// Set up the pixel allocator
|
|
skia::BRDAllocator* allocator = nullptr;
|
|
RecyclingClippingPixelAllocator recycleAlloc(recycledBitmap);
|
|
HeapAllocator heapAlloc;
|
|
if (javaBitmap) {
|
|
allocator = &recycleAlloc;
|
|
// We are required to match the color type of the recycled bitmap.
|
|
decodeColorType = recycledBitmap->info().colorType();
|
|
} else {
|
|
allocator = &heapAlloc;
|
|
}
|
|
|
|
sk_sp<SkColorSpace> decodeColorSpace = brd->computeOutputColorSpace(
|
|
decodeColorType, colorSpace);
|
|
|
|
// Decode the region.
|
|
const SkIRect subset = SkIRect::MakeXYWH(inputX, inputY, inputWidth, inputHeight);
|
|
SkBitmap bitmap;
|
|
if (!brd->decodeRegion(&bitmap, allocator, subset, sampleSize,
|
|
decodeColorType, requireUnpremul, decodeColorSpace)) {
|
|
return nullObjectReturn("Failed to decode region.");
|
|
}
|
|
|
|
// If the client provided options, indicate that the decode was successful.
|
|
if (NULL != options) {
|
|
env->SetIntField(options, gOptions_widthFieldID, bitmap.width());
|
|
env->SetIntField(options, gOptions_heightFieldID, bitmap.height());
|
|
|
|
env->SetObjectField(options, gOptions_mimeFieldID,
|
|
getMimeTypeAsJavaString(env, brd->getEncodedFormat()));
|
|
if (env->ExceptionCheck()) {
|
|
return nullObjectReturn("OOM in encodedFormatToString()");
|
|
}
|
|
|
|
jint configID = GraphicsJNI::colorTypeToLegacyBitmapConfig(decodeColorType);
|
|
if (isHardware) {
|
|
configID = GraphicsJNI::kHardware_LegacyBitmapConfig;
|
|
}
|
|
jobject config = env->CallStaticObjectMethod(gBitmapConfig_class,
|
|
gBitmapConfig_nativeToConfigMethodID, configID);
|
|
env->SetObjectField(options, gOptions_outConfigFieldID, config);
|
|
|
|
env->SetObjectField(options, gOptions_outColorSpaceFieldID,
|
|
GraphicsJNI::getColorSpace(env, decodeColorSpace.get(), decodeColorType));
|
|
}
|
|
|
|
if (javaBitmap) {
|
|
recycleAlloc.copyIfNecessary();
|
|
}
|
|
|
|
sp<uirenderer::Gainmap> gainmap;
|
|
bool hasGainmap = brd->hasGainmap();
|
|
if (hasGainmap) {
|
|
SkISize gainmapDims = SkISize::Make(bitmap.width(), bitmap.height());
|
|
if (javaBitmap) {
|
|
// If we are recycling we must match the inBitmap's relative dimensions
|
|
gainmapDims.fWidth = recycledBitmap->width();
|
|
gainmapDims.fHeight = recycledBitmap->height();
|
|
}
|
|
BitmapRegionDecoderWrapper::Projection gainmapProjection =
|
|
brd->calculateGainmapRegion(subset, gainmapDims);
|
|
if (!brd->decodeGainmapRegion(&gainmap, gainmapProjection.destSize,
|
|
gainmapProjection.srcRect, sampleSize, requireUnpremul)) {
|
|
// If there is an error decoding Gainmap - we don't fail. We just don't provide Gainmap
|
|
hasGainmap = false;
|
|
}
|
|
}
|
|
|
|
// If we may have reused a bitmap, we need to indicate that the pixels have changed.
|
|
if (javaBitmap) {
|
|
if (hasGainmap) {
|
|
recycledBitmap->setGainmap(std::move(gainmap));
|
|
}
|
|
bitmap::reinitBitmap(env, javaBitmap, recycledBitmap->info(), !requireUnpremul);
|
|
uirenderer::logBitmapDecode(*recycledBitmap);
|
|
return javaBitmap;
|
|
}
|
|
|
|
int bitmapCreateFlags = 0;
|
|
if (!requireUnpremul) {
|
|
bitmapCreateFlags |= android::bitmap::kBitmapCreateFlag_Premultiplied;
|
|
}
|
|
|
|
if (isHardware) {
|
|
sk_sp<Bitmap> hardwareBitmap = Bitmap::allocateHardwareBitmap(bitmap);
|
|
if (hasGainmap) {
|
|
auto gm = uirenderer::Gainmap::allocateHardwareGainmap(gainmap);
|
|
if (gm) {
|
|
hardwareBitmap->setGainmap(std::move(gm));
|
|
}
|
|
}
|
|
uirenderer::logBitmapDecode(*hardwareBitmap);
|
|
return bitmap::createBitmap(env, hardwareBitmap.release(), bitmapCreateFlags);
|
|
}
|
|
Bitmap* heapBitmap = heapAlloc.getStorageObjAndReset();
|
|
if (hasGainmap && heapBitmap != nullptr) {
|
|
heapBitmap->setGainmap(std::move(gainmap));
|
|
}
|
|
uirenderer::logBitmapDecode(*heapBitmap);
|
|
return android::bitmap::createBitmap(env, heapBitmap, bitmapCreateFlags);
|
|
}
|
|
|
|
static jint nativeGetHeight(JNIEnv* env, jobject, jlong brdHandle) {
|
|
auto* brd = reinterpret_cast<BitmapRegionDecoderWrapper*>(brdHandle);
|
|
return static_cast<jint>(brd->height());
|
|
}
|
|
|
|
static jint nativeGetWidth(JNIEnv* env, jobject, jlong brdHandle) {
|
|
auto* brd = reinterpret_cast<BitmapRegionDecoderWrapper*>(brdHandle);
|
|
return static_cast<jint>(brd->width());
|
|
}
|
|
|
|
static void nativeClean(JNIEnv* env, jobject, jlong brdHandle) {
|
|
auto* brd = reinterpret_cast<BitmapRegionDecoderWrapper*>(brdHandle);
|
|
delete brd;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
static const JNINativeMethod gBitmapRegionDecoderMethods[] = {
|
|
{ "nativeDecodeRegion",
|
|
"(JIIIILandroid/graphics/BitmapFactory$Options;JJ)Landroid/graphics/Bitmap;",
|
|
(void*)nativeDecodeRegion},
|
|
|
|
{ "nativeGetHeight", "(J)I", (void*)nativeGetHeight},
|
|
|
|
{ "nativeGetWidth", "(J)I", (void*)nativeGetWidth},
|
|
|
|
{ "nativeClean", "(J)V", (void*)nativeClean},
|
|
|
|
{ "nativeNewInstance",
|
|
"([BII)Landroid/graphics/BitmapRegionDecoder;",
|
|
(void*)nativeNewInstanceFromByteArray
|
|
},
|
|
|
|
{ "nativeNewInstance",
|
|
"(Ljava/io/InputStream;[B)Landroid/graphics/BitmapRegionDecoder;",
|
|
(void*)nativeNewInstanceFromStream
|
|
},
|
|
|
|
{ "nativeNewInstance",
|
|
"(Ljava/io/FileDescriptor;)Landroid/graphics/BitmapRegionDecoder;",
|
|
(void*)nativeNewInstanceFromFileDescriptor
|
|
},
|
|
|
|
{ "nativeNewInstance",
|
|
"(J)Landroid/graphics/BitmapRegionDecoder;",
|
|
(void*)nativeNewInstanceFromAsset
|
|
},
|
|
};
|
|
|
|
int register_android_graphics_BitmapRegionDecoder(JNIEnv* env)
|
|
{
|
|
return android::RegisterMethodsOrDie(env, "android/graphics/BitmapRegionDecoder",
|
|
gBitmapRegionDecoderMethods, NELEM(gBitmapRegionDecoderMethods));
|
|
}
|