drgreen/android_frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "Do not merge." into gingerbread

Browse Source
This commit is contained in:
Wei-Ta Chen
2011-01-13 12:02:32 -08:00
committed by Android (Google) Code Review
parent 4330b1464d 25bce3a673
commit 61d9ffbfd8
10 changed files with 789 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files

152
api/current.xml
View File

@ -59890,6 +59890,16 @@
visibility="public"
>
</field>
<field name="inPreferQualityOverSpeed"
type="boolean"
transient="false"
volatile="false"
static="false"
final="false"
deprecated="not deprecated"
visibility="public"
>
</field>
<field name="inPreferredConfig"
type="android.graphics.Bitmap.Config"
transient="false"
@ -60002,6 +60012,146 @@
>
</field>
</class>
<class name="BitmapRegionDecoder"
extends="java.lang.Object"
abstract="false"
static="false"
final="true"
deprecated="not deprecated"
visibility="public"
>
<method name="decodeRegion"
return="android.graphics.Bitmap"
abstract="false"
native="false"
synchronized="false"
static="false"
final="false"
deprecated="not deprecated"
visibility="public"
>
<parameter name="rect" type="android.graphics.Rect">
</parameter>
<parameter name="options" type="android.graphics.BitmapFactory.Options">
</parameter>
</method>
<method name="getHeight"
return="int"
abstract="false"
native="false"
synchronized="false"
static="false"
final="false"
deprecated="not deprecated"
visibility="public"
>
</method>
<method name="getWidth"
return="int"
abstract="false"
native="false"
synchronized="false"
static="false"
final="false"
deprecated="not deprecated"
visibility="public"
>
</method>
<method name="isRecycled"
return="boolean"
abstract="false"
native="false"
synchronized="false"
static="false"
final="true"
deprecated="not deprecated"
visibility="public"
>
</method>
<method name="newInstance"
return="android.graphics.BitmapRegionDecoder"
abstract="false"
native="false"
synchronized="false"
static="true"
final="false"
deprecated="not deprecated"
visibility="public"
>
<parameter name="data" type="byte[]">
</parameter>
<parameter name="offset" type="int">
</parameter>
<parameter name="length" type="int">
</parameter>
<parameter name="isShareable" type="boolean">
</parameter>
<exception name="IOException" type="java.io.IOException">
</exception>
</method>
<method name="newInstance"
return="android.graphics.BitmapRegionDecoder"
abstract="false"
native="false"
synchronized="false"
static="true"
final="false"
deprecated="not deprecated"
visibility="public"
>
<parameter name="fd" type="java.io.FileDescriptor">
</parameter>
<parameter name="isShareable" type="boolean">
</parameter>
<exception name="IOException" type="java.io.IOException">
</exception>
</method>
<method name="newInstance"
return="android.graphics.BitmapRegionDecoder"
abstract="false"
native="false"
synchronized="false"
static="true"
final="false"
deprecated="not deprecated"
visibility="public"
>
<parameter name="is" type="java.io.InputStream">
</parameter>
<parameter name="isShareable" type="boolean">
</parameter>
<exception name="IOException" type="java.io.IOException">
</exception>
</method>
<method name="newInstance"
return="android.graphics.BitmapRegionDecoder"
abstract="false"
native="false"
synchronized="false"
static="true"
final="false"
deprecated="not deprecated"
visibility="public"
>
<parameter name="pathName" type="java.lang.String">
</parameter>
<parameter name="isShareable" type="boolean">
</parameter>
<exception name="IOException" type="java.io.IOException">
</exception>
</method>
<method name="recycle"
return="void"
abstract="false"
native="false"
synchronized="false"
static="false"
final="false"
deprecated="not deprecated"
visibility="public"
>
</method>
</class>
<class name="BitmapShader"
extends="android.graphics.Shader"
abstract="false"
@ -226236,7 +226386,7 @@
deprecated="not deprecated"
visibility="public"
>
<parameter name="arg0" type="T">
<parameter name="t" type="T">
</parameter>
</method>
</interface>

1
core/jni/Android.mk
View File

@ -103,6 +103,7 @@ LOCAL_SRC_FILES:= \
android_graphics_PixelFormat.cpp \
android/graphics/Picture.cpp \
android/graphics/PorterDuff.cpp \
android/graphics/BitmapRegionDecoder.cpp \
android/graphics/Rasterizer.cpp \
android/graphics/Region.cpp \
android/graphics/Shader.cpp \

2
core/jni/AndroidRuntime.cpp
View File

@ -53,6 +53,7 @@ extern int register_android_os_Binder(JNIEnv* env);
extern int register_android_os_Process(JNIEnv* env);
extern int register_android_graphics_Bitmap(JNIEnv*);
extern int register_android_graphics_BitmapFactory(JNIEnv*);
extern int register_android_graphics_BitmapRegionDecoder(JNIEnv*);
extern int register_android_graphics_Camera(JNIEnv* env);
extern int register_android_graphics_Graphics(JNIEnv* env);
extern int register_android_graphics_Interpolator(JNIEnv* env);
@ -1209,6 +1210,7 @@ static const RegJNIRec gRegJNI[] = {
REG_JNI(register_android_graphics_Bitmap),
REG_JNI(register_android_graphics_BitmapFactory),
REG_JNI(register_android_graphics_BitmapRegionDecoder),
REG_JNI(register_android_graphics_Camera),
REG_JNI(register_android_graphics_Canvas),
REG_JNI(register_android_graphics_ColorFilter),

7
core/jni/android/graphics/BitmapFactory.cpp
View File

@ -27,6 +27,7 @@ jfieldID gOptions_ditherFieldID;
jfieldID gOptions_purgeableFieldID;
jfieldID gOptions_shareableFieldID;
jfieldID gOptions_nativeAllocFieldID;
jfieldID gOptions_preferQualityOverSpeedFieldID;
jfieldID gOptions_widthFieldID;
jfieldID gOptions_heightFieldID;
jfieldID gOptions_mimeFieldID;
@ -180,6 +181,7 @@ static jobject doDecode(JNIEnv* env, SkStream* stream, jobject padding,
bool isPurgeable = forcePurgeable ||
(allowPurgeable && optionsPurgeable(env, options));
bool reportSizeToVM = optionsReportSizeToVM(env, options);
bool preferQualityOverSpeed = false;
if (NULL != options) {
sampleSize = env->GetIntField(options, gOptions_sampleSizeFieldID);
@ -194,6 +196,8 @@ static jobject doDecode(JNIEnv* env, SkStream* stream, jobject padding,
jobject jconfig = env->GetObjectField(options, gOptions_configFieldID);
prefConfig = GraphicsJNI::getNativeBitmapConfig(env, jconfig);
doDither = env->GetBooleanField(options, gOptions_ditherFieldID);
preferQualityOverSpeed = env->GetBooleanField(options,
gOptions_preferQualityOverSpeedFieldID);
}
SkImageDecoder* decoder = SkImageDecoder::Factory(stream);
@ -203,6 +207,7 @@ static jobject doDecode(JNIEnv* env, SkStream* stream, jobject padding,
decoder->setSampleSize(sampleSize);
decoder->setDitherImage(doDither);
decoder->setPreferQualityOverSpeed(preferQualityOverSpeed);
NinePatchPeeker peeker(decoder);
JavaPixelAllocator javaAllocator(env, reportSizeToVM);
@ -551,6 +556,8 @@ int register_android_graphics_BitmapFactory(JNIEnv* env) {
gOptions_purgeableFieldID = getFieldIDCheck(env, gOptions_class, "inPurgeable", "Z");
gOptions_shareableFieldID = getFieldIDCheck(env, gOptions_class, "inInputShareable", "Z");
gOptions_nativeAllocFieldID = getFieldIDCheck(env, gOptions_class, "inNativeAlloc", "Z");
gOptions_preferQualityOverSpeedFieldID = getFieldIDCheck(env, gOptions_class,
"inPreferQualityOverSpeed", "Z");
gOptions_widthFieldID = getFieldIDCheck(env, gOptions_class, "outWidth", "I");
gOptions_heightFieldID = getFieldIDCheck(env, gOptions_class, "outHeight", "I");
gOptions_mimeFieldID = getFieldIDCheck(env, gOptions_class, "outMimeType", "Ljava/lang/String;");

1
core/jni/android/graphics/BitmapFactory.h
View File

@ -11,6 +11,7 @@ extern jfieldID gOptions_ditherFieldID;
extern jfieldID gOptions_purgeableFieldID;
extern jfieldID gOptions_shareableFieldID;
extern jfieldID gOptions_nativeAllocFieldID;
extern jfieldID gOptions_preferQualityOverSpeedFieldID;
extern jfieldID gOptions_widthFieldID;
extern jfieldID gOptions_heightFieldID;
extern jfieldID gOptions_mimeFieldID;

326
core/jni/android/graphics/BitmapRegionDecoder.cpp Normal file
View File

@ -0,0 +1,326 @@
/*
* 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.
*/
#define LOG_TAG "BitmapRegionDecoder"
#include "SkBitmap.h"
#include "SkImageEncoder.h"
#include "GraphicsJNI.h"
#include "SkUtils.h"
#include "SkTemplates.h"
#include "SkPixelRef.h"
#include "SkStream.h"
#include "BitmapFactory.h"
#include "AutoDecodeCancel.h"
#include "SkBitmapRegionDecoder.h"
#include "CreateJavaOutputStreamAdaptor.h"
#include "Utils.h"
#include <android_runtime/AndroidRuntime.h>
#include "android_util_Binder.h"
#include "android_nio_utils.h"
#include "CreateJavaOutputStreamAdaptor.h"
#include <binder/Parcel.h>
#include <jni.h>
#include <utils/Asset.h>
#include <sys/stat.h>
static jclass gFileDescriptor_class;
static jfieldID gFileDescriptor_descriptor;
#if 0
#define TRACE_BITMAP(code) code
#else
#define TRACE_BITMAP(code)
#endif
using namespace android;
static SkMemoryStream* buildSkMemoryStream(SkStream *stream) {
size_t bufferSize = 4096;
size_t streamLen = 0;
size_t len;
char* data = (char*)sk_malloc_throw(bufferSize);
while ((len = stream->read(data + streamLen,
bufferSize - streamLen)) != 0) {
streamLen += len;
if (streamLen == bufferSize) {
bufferSize *= 2;
data = (char*)sk_realloc_throw(data, bufferSize);
}
}
data = (char*)sk_realloc_throw(data, streamLen);
SkMemoryStream* streamMem = new SkMemoryStream();
streamMem->setMemoryOwned(data, streamLen);
return streamMem;
}
static jobject doBuildTileIndex(JNIEnv* env, SkStream* stream) {
SkImageDecoder* decoder = SkImageDecoder::Factory(stream);
int width, height;
if (NULL == decoder) {
doThrowIOE(env, "Image format not supported");
return nullObjectReturn("SkImageDecoder::Factory returned null");
}
JavaPixelAllocator *javaAllocator = new JavaPixelAllocator(env, true);
decoder->setAllocator(javaAllocator);
JavaMemoryUsageReporter *javaMemoryReporter = new JavaMemoryUsageReporter(env);
decoder->setReporter(javaMemoryReporter);
javaAllocator->unref();
javaMemoryReporter->unref();
if (!decoder->buildTileIndex(stream, &width, &height)) {
char msg[100];
snprintf(msg, sizeof(msg), "Image failed to decode using %s decoder",
decoder->getFormatName());
doThrowIOE(env, msg);
return nullObjectReturn("decoder->buildTileIndex returned false");
}
SkBitmapRegionDecoder *bm = new SkBitmapRegionDecoder(decoder, width, height);
return GraphicsJNI::createBitmapRegionDecoder(env, bm);
}
static jobject nativeNewInstanceFromByteArray(JNIEnv* env, jobject, jbyteArray byteArray,
int offset, int length, jboolean isShareable) {
/* If isShareable we could decide to just wrap the java array and
share it, but that means adding a globalref to the java array object
For now we just always copy the array's data if isShareable.
*/
AutoJavaByteArray ar(env, byteArray);
SkStream* stream = new SkMemoryStream(ar.ptr() + offset, length, true);
return doBuildTileIndex(env, stream);
}
static jobject nativeNewInstanceFromFileDescriptor(JNIEnv* env, jobject clazz,
jobject fileDescriptor, jboolean isShareable) {
NPE_CHECK_RETURN_ZERO(env, fileDescriptor);
jint descriptor = env->GetIntField(fileDescriptor,
gFileDescriptor_descriptor);
SkStream *stream = NULL;
struct stat fdStat;
int newFD;
if (fstat(descriptor, &fdStat) == -1) {
doThrowIOE(env, "broken file descriptor");
return nullObjectReturn("fstat return -1");
}
if (isShareable &&
S_ISREG(fdStat.st_mode) &&
(newFD = ::dup(descriptor)) != -1) {
SkFDStream* fdStream = new SkFDStream(newFD, true);
if (!fdStream->isValid()) {
fdStream->unref();
return NULL;
}
stream = fdStream;
} else {
/* Restore our offset when we leave, so we can be called more than once
with the same descriptor. This is only required if we didn't dup the
file descriptor, but it is OK to do it all the time.
*/
AutoFDSeek as(descriptor);
SkFDStream* fdStream = new SkFDStream(descriptor, false);
if (!fdStream->isValid()) {
fdStream->unref();
return NULL;
}
stream = buildSkMemoryStream(fdStream);
fdStream->unref();
}
return doBuildTileIndex(env, stream);
}
static jobject nativeNewInstanceFromStream(JNIEnv* env, jobject clazz,
jobject is, // InputStream
jbyteArray storage, // byte[]
jboolean isShareable) {
jobject largeBitmap = NULL;
SkStream* stream = CreateJavaInputStreamAdaptor(env, is, storage, 1024);
if (stream) {
// for now we don't allow shareable with java inputstreams
SkMemoryStream *mStream = buildSkMemoryStream(stream);
largeBitmap = doBuildTileIndex(env, mStream);
stream->unref();
}
return largeBitmap;
}
static jobject nativeNewInstanceFromAsset(JNIEnv* env, jobject clazz,
jint native_asset, // Asset
jboolean isShareable) {
SkStream* stream, *assStream;
Asset* asset = reinterpret_cast<Asset*>(native_asset);
assStream = new AssetStreamAdaptor(asset);
stream = buildSkMemoryStream(assStream);
assStream->unref();
return doBuildTileIndex(env, stream);
}
/*
* nine patch not supported
*
* purgeable not supported
* reportSizeToVM not supported
*/
static jobject nativeDecodeRegion(JNIEnv* env, jobject, SkBitmapRegionDecoder *brd,
int start_x, int start_y, int width, int height, jobject options) {
SkImageDecoder *decoder = brd->getDecoder();
int sampleSize = 1;
SkBitmap::Config prefConfig = SkBitmap::kNo_Config;
bool doDither = true;
bool preferQualityOverSpeed = false;
if (NULL != options) {
sampleSize = env->GetIntField(options, gOptions_sampleSizeFieldID);
// initialize these, in case we fail later on
env->SetIntField(options, gOptions_widthFieldID, -1);
env->SetIntField(options, gOptions_heightFieldID, -1);
env->SetObjectField(options, gOptions_mimeFieldID, 0);
jobject jconfig = env->GetObjectField(options, gOptions_configFieldID);
prefConfig = GraphicsJNI::getNativeBitmapConfig(env, jconfig);
doDither = env->GetBooleanField(options, gOptions_ditherFieldID);
preferQualityOverSpeed = env->GetBooleanField(options,
gOptions_preferQualityOverSpeedFieldID);
}
decoder->setDitherImage(doDither);
decoder->setPreferQualityOverSpeed(preferQualityOverSpeed);
SkBitmap* bitmap = new SkBitmap;
SkAutoTDelete<SkBitmap> adb(bitmap);
AutoDecoderCancel adc(options, decoder);
// To fix the race condition in case "requestCancelDecode"
// happens earlier than AutoDecoderCancel object is added
// to the gAutoDecoderCancelMutex linked list.
if (NULL != options && env->GetBooleanField(options, gOptions_mCancelID)) {
return nullObjectReturn("gOptions_mCancelID");;
}
SkIRect region;
region.fLeft = start_x;
region.fTop = start_y;
region.fRight = start_x + width;
region.fBottom = start_y + height;
if (!brd->decodeRegion(bitmap, region, prefConfig, sampleSize)) {
return nullObjectReturn("decoder->decodeRegion returned false");
}
// update options (if any)
if (NULL != options) {
env->SetIntField(options, gOptions_widthFieldID, bitmap->width());
env->SetIntField(options, gOptions_heightFieldID, bitmap->height());
// TODO: set the mimeType field with the data from the codec.
// but how to reuse a set of strings, rather than allocating new one
// each time?
env->SetObjectField(options, gOptions_mimeFieldID,
getMimeTypeString(env, decoder->getFormat()));
}
// detach bitmap from its autotdeleter, since we want to own it now
adb.detach();
SkPixelRef* pr;
pr = bitmap->pixelRef();
// promise we will never change our pixels (great for sharing and pictures)
pr->setImmutable();
// now create the java bitmap
return GraphicsJNI::createBitmap(env, bitmap, false, NULL);
}
static int nativeGetHeight(JNIEnv* env, jobject, SkBitmapRegionDecoder *brd) {
return brd->getHeight();
}
static int nativeGetWidth(JNIEnv* env, jobject, SkBitmapRegionDecoder *brd) {
return brd->getWidth();
}
static void nativeClean(JNIEnv* env, jobject, SkBitmapRegionDecoder *brd) {
delete brd;
}
///////////////////////////////////////////////////////////////////////////////
#include <android_runtime/AndroidRuntime.h>
static JNINativeMethod gBitmapRegionDecoderMethods[] = {
{ "nativeDecodeRegion",
"(IIIIILandroid/graphics/BitmapFactory$Options;)Landroid/graphics/Bitmap;",
(void*)nativeDecodeRegion},
{ "nativeGetHeight", "(I)I", (void*)nativeGetHeight},
{ "nativeGetWidth", "(I)I", (void*)nativeGetWidth},
{ "nativeClean", "(I)V", (void*)nativeClean},
{ "nativeNewInstance",
"([BIIZ)Landroid/graphics/BitmapRegionDecoder;",
(void*)nativeNewInstanceFromByteArray
},
{ "nativeNewInstance",
"(Ljava/io/InputStream;[BZ)Landroid/graphics/BitmapRegionDecoder;",
(void*)nativeNewInstanceFromStream
},
{ "nativeNewInstance",
"(Ljava/io/FileDescriptor;Z)Landroid/graphics/BitmapRegionDecoder;",
(void*)nativeNewInstanceFromFileDescriptor
},
{ "nativeNewInstance",
"(IZ)Landroid/graphics/BitmapRegionDecoder;",
(void*)nativeNewInstanceFromAsset
},
};
#define kClassPathName "android/graphics/BitmapRegionDecoder"
static jclass make_globalref(JNIEnv* env, const char classname[]) {
jclass c = env->FindClass(classname);
SkASSERT(c);
return (jclass)env->NewGlobalRef(c);
}
static jfieldID getFieldIDCheck(JNIEnv* env, jclass clazz,
const char fieldname[], const char type[]) {
jfieldID id = env->GetFieldID(clazz, fieldname, type);
SkASSERT(id);
return id;
}
int register_android_graphics_BitmapRegionDecoder(JNIEnv* env);
int register_android_graphics_BitmapRegionDecoder(JNIEnv* env)
{
gFileDescriptor_class = make_globalref(env, "java/io/FileDescriptor");
gFileDescriptor_descriptor = getFieldIDCheck(env, gFileDescriptor_class, "descriptor", "I");
return android::AndroidRuntime::registerNativeMethods(env, kClassPathName,
gBitmapRegionDecoderMethods, SK_ARRAY_COUNT(gBitmapRegionDecoderMethods));
}

26
core/jni/android/graphics/Graphics.cpp
View File

@ -46,7 +46,7 @@ void doThrowOOME(JNIEnv* env, const char* msg) {
}
void doThrowIOE(JNIEnv* env, const char* msg) {
doThrow(env, "java/lang/IOException", msg);
doThrow(env, "java/io/IOException", msg);
}
bool GraphicsJNI::hasException(JNIEnv *env) {
@ -168,6 +168,9 @@ static jmethodID gBitmap_allocBufferMethodID;
static jclass gBitmapConfig_class;
static jfieldID gBitmapConfig_nativeInstanceID;
static jclass gBitmapRegionDecoder_class;
static jmethodID gBitmapRegionDecoder_constructorMethodID;
static jclass gCanvas_class;
static jfieldID gCanvas_nativeInstanceID;
@ -374,6 +377,24 @@ jobject GraphicsJNI::createBitmap(JNIEnv* env, SkBitmap* bitmap, bool isMutable,
return obj;
}
jobject GraphicsJNI::createBitmapRegionDecoder(JNIEnv* env, SkBitmapRegionDecoder* bitmap)
{
SkASSERT(bitmap != NULL);
jobject obj = env->AllocObject(gBitmapRegionDecoder_class);
if (hasException(env)) {
obj = NULL;
return obj;
}
if (obj) {
env->CallVoidMethod(obj, gBitmapRegionDecoder_constructorMethodID, (jint)bitmap);
if (hasException(env)) {
obj = NULL;
}
}
return obj;
}
jobject GraphicsJNI::createRegion(JNIEnv* env, SkRegion* region)
{
SkASSERT(region != NULL);
@ -592,6 +613,9 @@ int register_android_graphics_Graphics(JNIEnv* env)
gBitmap_constructorMethodID = env->GetMethodID(gBitmap_class, "<init>",
"(IZ[BI)V");
gBitmapRegionDecoder_class = make_globalref(env, "android/graphics/BitmapRegionDecoder");
gBitmapRegionDecoder_constructorMethodID = env->GetMethodID(gBitmapRegionDecoder_class, "<init>", "(I)V");
gBitmapConfig_class = make_globalref(env, "android/graphics/Bitmap$Config");
gBitmapConfig_nativeInstanceID = getFieldIDCheck(env, gBitmapConfig_class,
"nativeInt", "I");

3
core/jni/android/graphics/GraphicsJNI.h
View File

@ -4,6 +4,7 @@
#include "SkPoint.h"
#include "SkRect.h"
#include "SkBitmap.h"
#include "../images/SkBitmapRegionDecoder.h"
#include "../images/SkImageDecoder.h"
#include <jni.h>
@ -55,6 +56,8 @@ public:
static jobject createRegion(JNIEnv* env, SkRegion* region);
static jobject createBitmapRegionDecoder(JNIEnv* env, SkBitmapRegionDecoder* bitmap);
/** Set a pixelref for the bitmap (needs setConfig to already be called)
Returns true on success. If it returns false, then it failed, and the
appropriate exception will have been raised.

10
graphics/java/android/graphics/BitmapFactory.java
View File

@ -205,11 +205,21 @@ public class BitmapFactory {
*/
public boolean inNativeAlloc;
/**
* If inPreferQualityOverSpeed is set to true, the decoder will try to
* decode the reconstructed image to a higher quality even at the
* expense of the decoding speed. Currently the field only affects JPEG
* decode, in the case of which a more accurate, but slightly slower,
* IDCT method will be used instead.
*/
public boolean inPreferQualityOverSpeed;
/**
* The resulting width of the bitmap, set independent of the state of
* inJustDecodeBounds. However, if there is an error trying to decode,
* outWidth will be set to -1.
*/
public int outWidth;
/**

263
graphics/java/android/graphics/BitmapRegionDecoder.java Normal file
View File

@ -0,0 +1,263 @@
/* 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.
*/
package android.graphics;
import android.content.res.AssetManager;
import java.io.BufferedInputStream;
import java.io.FileDescriptor;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
/**
* BitmapRegionDecoder can be used to decode a rectangle region from an image.
* BitmapRegionDecoder is particularly useful when an original image is large and
* you only need parts of the image.
*
* <p>To create a BitmapRegionDecoder, call newInstance(...).
* Given a BitmapRegionDecoder, users can call decodeRegion() repeatedly
* to get a decoded Bitmap of the specified region.
*
*/
public final class BitmapRegionDecoder {
private int mNativeBitmapRegionDecoder;
private boolean mRecycled;
/**
* Create a BitmapRegionDecoder from the specified byte array.
* Currently only the JPEG and PNG formats are supported.
*
* @param data byte array of compressed image data.
* @param offset offset into data for where the decoder should begin
* parsing.
* @param length the number of bytes, beginning at offset, to parse
* @param isShareable If this is true, then the BitmapRegionDecoder may keep a
* shallow reference to the input. If this is false,
* then the BitmapRegionDecoder will explicitly make a copy of the
* input data, and keep that. Even if sharing is allowed,
* the implementation may still decide to make a deep
* copy of the input data. If an image is progressively encoded,
* allowing sharing may degrade the decoding speed.
* @return BitmapRegionDecoder, or null if the image data could not be decoded.
* @throws IOException if the image format is not supported or can not be decoded.
*/
public static BitmapRegionDecoder newInstance(byte[] data,
int offset, int length, boolean isShareable) throws IOException {
if ((offset | length) < 0 || data.length < offset + length) {
throw new ArrayIndexOutOfBoundsException();
}
return nativeNewInstance(data, offset, length, isShareable);
}
/**
* Create a BitmapRegionDecoder from the file descriptor.
* The position within the descriptor will not be changed when
* this returns, so the descriptor can be used again as is.
* Currently only the JPEG and PNG formats are supported.
*
* @param fd The file descriptor containing the data to decode
* @param isShareable If this is true, then the BitmapRegionDecoder may keep a
* shallow reference to the input. If this is false,
* then the BitmapRegionDecoder will explicitly make a copy of the
* input data, and keep that. Even if sharing is allowed,
* the implementation may still decide to make a deep
* copy of the input data. If an image is progressively encoded,
* allowing sharing may degrade the decoding speed.
* @return BitmapRegionDecoder, or null if the image data could not be decoded.
* @throws IOException if the image format is not supported or can not be decoded.
*/
public static BitmapRegionDecoder newInstance(
FileDescriptor fd, boolean isShareable) throws IOException {
return nativeNewInstance(fd, isShareable);
}
/**
* Create a BitmapRegionDecoder from an input stream.
* The stream's position will be where ever it was after the encoded data
* was read.
* Currently only the JPEG and PNG formats are supported.
*
* @param is The input stream that holds the raw data to be decoded into a
* BitmapRegionDecoder.
* @param isShareable If this is true, then the BitmapRegionDecoder may keep a
* shallow reference to the input. If this is false,
* then the BitmapRegionDecoder will explicitly make a copy of the
* input data, and keep that. Even if sharing is allowed,
* the implementation may still decide to make a deep
* copy of the input data. If an image is progressively encoded,
* allowing sharing may degrade the decoding speed.
* @return BitmapRegionDecoder, or null if the image data could not be decoded.
* @throws IOException if the image format is not supported or can not be decoded.
*/
public static BitmapRegionDecoder newInstance(InputStream is,
boolean isShareable) throws IOException {
// we need mark/reset to work properly in JNI
if (!is.markSupported()) {
is = new BufferedInputStream(is, 16 * 1024);
}
if (is instanceof AssetManager.AssetInputStream) {
return nativeNewInstance(
((AssetManager.AssetInputStream) is).getAssetInt(),
isShareable);
} else {
// pass some temp storage down to the native code. 1024 is made up,
// but should be large enough to avoid too many small calls back
// into is.read(...).
byte [] tempStorage = new byte[16 * 1024];
return nativeNewInstance(is, tempStorage, isShareable);
}
}
/**
* Create a BitmapRegionDecoder from a file path.
* Currently only the JPEG and PNG formats are supported.
*
* @param pathName complete path name for the file to be decoded.
* @param isShareable If this is true, then the BitmapRegionDecoder may keep a
* shallow reference to the input. If this is false,
* then the BitmapRegionDecoder will explicitly make a copy of the
* input data, and keep that. Even if sharing is allowed,
* the implementation may still decide to make a deep
* copy of the input data. If an image is progressively encoded,
* allowing sharing may degrade the decoding speed.
* @return BitmapRegionDecoder, or null if the image data could not be decoded.
* @throws IOException if the image format is not supported or can not be decoded.
*/
public static BitmapRegionDecoder newInstance(String pathName,
boolean isShareable) throws IOException {
BitmapRegionDecoder decoder = null;
InputStream stream = null;
try {
stream = new FileInputStream(pathName);
decoder = newInstance(stream, isShareable);
} finally {
if (stream != null) {
try {
stream.close();
} catch (IOException e) {
// do nothing here
}
}
}
return decoder;
}
/* Private constructor that must receive an already allocated native
region decoder int (pointer).
This can be called from JNI code.
*/
private BitmapRegionDecoder(int decoder) {
mNativeBitmapRegionDecoder = decoder;
mRecycled = false;
}
/**
* Decodes a rectangle region in the image specified by rect.
*
* @param rect The rectangle that specified the region to be decode.
* @param options null-ok; Options that control downsampling.
* inPurgeable is not supported.
* @return The decoded bitmap, or null if the image data could not be
* decoded.
*/
public Bitmap decodeRegion(Rect rect, BitmapFactory.Options options) {
checkRecycled("decodeRegion called on recycled region decoder");
if (rect.left < 0 || rect.top < 0 || rect.right > getWidth()
|| rect.bottom > getHeight())
throw new IllegalArgumentException("rectangle is not inside the image");
return nativeDecodeRegion(mNativeBitmapRegionDecoder, rect.left, rect.top,
rect.right - rect.left, rect.bottom - rect.top, options);
}
/** Returns the original image's width */
public int getWidth() {
checkRecycled("getWidth called on recycled region decoder");
return nativeGetWidth(mNativeBitmapRegionDecoder);
}
/** Returns the original image's height */
public int getHeight() {
checkRecycled("getHeight called on recycled region decoder");
return nativeGetHeight(mNativeBitmapRegionDecoder);
}
/**
* Frees up the memory associated with this region decoder, and mark the
* region decoder as "dead", meaning it will throw an exception if decodeRegion(),
* getWidth() or getHeight() is called.
*
* <p>This operation cannot be reversed, so it should only be called if you are
* sure there are no further uses for the region decoder. This is an advanced call,
* and normally need not be called, since the normal GC process will free up this
* memory when there are no more references to this region decoder.
*/
public void recycle() {
if (!mRecycled) {
nativeClean(mNativeBitmapRegionDecoder);
mRecycled = true;
}
}
/**
* Returns true if this region decoder has been recycled.
* If so, then it is an error to try use its method.
*
* @return true if the region decoder has been recycled
*/
public final boolean isRecycled() {
return mRecycled;
}
/**
* Called by methods that want to throw an exception if the region decoder
* has already been recycled.
*/
private void checkRecycled(String errorMessage) {
if (mRecycled) {
throw new IllegalStateException(errorMessage);
}
}
@Override
protected void finalize() throws Throwable {
try {
recycle();
} finally {
super.finalize();
}
}
private static native Bitmap nativeDecodeRegion(int lbm,
int start_x, int start_y, int width, int height,
BitmapFactory.Options options);
private static native int nativeGetWidth(int lbm);
private static native int nativeGetHeight(int lbm);
private static native void nativeClean(int lbm);
private static native BitmapRegionDecoder nativeNewInstance(
byte[] data, int offset, int length, boolean isShareable);
private static native BitmapRegionDecoder nativeNewInstance(
FileDescriptor fd, boolean isShareable);
private static native BitmapRegionDecoder nativeNewInstance(
InputStream is, byte[] storage, boolean isShareable);
private static native BitmapRegionDecoder nativeNewInstance(
int asset, boolean isShareable);
}