From 6b849e2123be98eb2a1a25b8abf0b13a279ce952 Mon Sep 17 00:00:00 2001 From: Wei-Ta Chen Date: Tue, 7 Sep 2010 17:32:18 +0800 Subject: Unhide BitmapRegionDecoder. 1. Rename LargeBitmap to BitmapRegionDecoder 2. Move the instantiations of BitmapRegionDecoder out of BitmapFactory. 3. Remove the use of MemoryFile in BitmapRegionDecoder, since MemoryFile's API had been modified in master. Otherwise, the change will break the master build. 4. Move AssetStreamAdaptor, AutoFDSeek and nullObjectReturn to Utils.h because BitmapFactory.cpp and BitmapRegionDecoder.cpp both need to use these utility functions. Most of the modifications, except for (2) and (3), were reviewed in https://android-git.corp.google.com/g/#change,64716 . However, that change broke the master build due to (3) and was reverted eventually. So, instead of withdrawing this change and waiting for that change to be checked in again, I merge the two changes into one. Change-Id: I2202c0fbbbd6d6676bbd9637e690023ea4099c40 --- graphics/java/android/graphics/BitmapFactory.java | 136 ----------- .../java/android/graphics/BitmapRegionDecoder.java | 263 +++++++++++++++++++++ 2 files changed, 263 insertions(+), 136 deletions(-) create mode 100644 graphics/java/android/graphics/BitmapRegionDecoder.java (limited to 'graphics') diff --git a/graphics/java/android/graphics/BitmapFactory.java b/graphics/java/android/graphics/BitmapFactory.java index 6234f2c..7b49bc5 100644 --- a/graphics/java/android/graphics/BitmapFactory.java +++ b/graphics/java/android/graphics/BitmapFactory.java @@ -581,132 +581,6 @@ public class BitmapFactory { nativeSetDefaultConfig(config.nativeInt); } - /** - * Create a LargeBitmap from the specified byte array. - * Currently only the Jpeg format is 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 LargeBitmap may keep a - * shallow reference to the input. If this is false, - * then the LargeBitmap 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 LargeBitmap, or null if the image data could not be decoded. - * @throws IOException if the image format is not supported or can not be decoded. - * @hide - */ - public static LargeBitmap createLargeBitmap(byte[] data, - int offset, int length, boolean isShareable) throws IOException { - if ((offset | length) < 0 || data.length < offset + length) { - throw new ArrayIndexOutOfBoundsException(); - } - return nativeCreateLargeBitmap(data, offset, length, isShareable); - } - - /** - * Create a LargeBitmap 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 format is supported. - * - * @param fd The file descriptor containing the data to decode - * @param isShareable If this is true, then the LargeBitmap may keep a - * shallow reference to the input. If this is false, - * then the LargeBitmap 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 LargeBitmap, or null if the image data could not be decoded. - * @throws IOException if the image format is not supported or can not be decoded. - * @hide - */ - public static LargeBitmap createLargeBitmap( - FileDescriptor fd, boolean isShareable) throws IOException { - return nativeCreateLargeBitmap(fd, isShareable); - } - - /** - * Create a LargeBitmap from an input stream. - * The stream's position will be where ever it was after the encoded data - * was read. - * Currently only the Jpeg format is supported. - * - * @param is The input stream that holds the raw data to be decoded into a - * LargeBitmap. - * @param isShareable If this is true, then the LargeBitmap may keep a - * shallow reference to the input. If this is false, - * then the LargeBitmap 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 LargeBitmap, or null if the image data could not be decoded. - * @throws IOException if the image format is not supported or can not be decoded. - * @hide - */ - public static LargeBitmap createLargeBitmap(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 nativeCreateLargeBitmap( - ((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 nativeCreateLargeBitmap(is, tempStorage, isShareable); - } - } - - /** - * Create a LargeBitmap from a file path. - * Currently only the Jpeg format is supported. - * - * @param pathName complete path name for the file to be decoded. - * @param isShareable If this is true, then the LargeBitmap may keep a - * shallow reference to the input. If this is false, - * then the LargeBitmap 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 LargeBitmap, or null if the image data could not be decoded. - * @throws IOException if the image format is not supported or can not be decoded. - * @hide - */ - public static LargeBitmap createLargeBitmap(String pathName, boolean isShareable) - throws IOException { - LargeBitmap bm = null; - InputStream stream = null; - - try { - stream = new FileInputStream(pathName); - bm = createLargeBitmap(stream, isShareable); - } finally { - if (stream != null) { - try { - stream.close(); - } catch (IOException e) { - // do nothing here - } - } - } - return bm; - } - private static native void nativeSetDefaultConfig(int nativeConfig); private static native Bitmap nativeDecodeStream(InputStream is, byte[] storage, Rect padding, Options opts); @@ -716,14 +590,4 @@ public class BitmapFactory { private static native Bitmap nativeDecodeByteArray(byte[] data, int offset, int length, Options opts); private static native byte[] nativeScaleNinePatch(byte[] chunk, float scale, Rect pad); - - private static native LargeBitmap nativeCreateLargeBitmap( - byte[] data, int offset, int length, boolean isShareable); - private static native LargeBitmap nativeCreateLargeBitmap( - FileDescriptor fd, boolean isShareable); - private static native LargeBitmap nativeCreateLargeBitmap( - InputStream is, byte[] storage, boolean isShareable); - private static native LargeBitmap nativeCreateLargeBitmap( - int asset, boolean isShareable); } - diff --git a/graphics/java/android/graphics/BitmapRegionDecoder.java b/graphics/java/android/graphics/BitmapRegionDecoder.java new file mode 100644 index 0000000..454eb4a --- /dev/null +++ b/graphics/java/android/graphics/BitmapRegionDecoder.java @@ -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. + * + *

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 format is 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 format is 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 format is 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 format is 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. + * + *

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); +} -- cgit v1.1