diff options
Diffstat (limited to 'WallpaperPicker/src/com/android/gallery3d/common')
| -rw-r--r-- | WallpaperPicker/src/com/android/gallery3d/common/BitmapUtils.java | 260 | ||||
| -rw-r--r-- | WallpaperPicker/src/com/android/gallery3d/common/Utils.java | 340 |
2 files changed, 600 insertions, 0 deletions
diff --git a/WallpaperPicker/src/com/android/gallery3d/common/BitmapUtils.java b/WallpaperPicker/src/com/android/gallery3d/common/BitmapUtils.java new file mode 100644 index 000000000..a671ed2b9 --- /dev/null +++ b/WallpaperPicker/src/com/android/gallery3d/common/BitmapUtils.java @@ -0,0 +1,260 @@ +/* + * 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 com.android.gallery3d.common; + +import android.graphics.Bitmap; +import android.graphics.Bitmap.CompressFormat; +import android.graphics.BitmapFactory; +import android.graphics.Canvas; +import android.graphics.Matrix; +import android.graphics.Paint; +import android.os.Build; +import android.util.FloatMath; +import android.util.Log; + +import java.io.ByteArrayOutputStream; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; + +public class BitmapUtils { + private static final String TAG = "BitmapUtils"; + private static final int DEFAULT_JPEG_QUALITY = 90; + public static final int UNCONSTRAINED = -1; + + private BitmapUtils(){} + + /* + * Compute the sample size as a function of minSideLength + * and maxNumOfPixels. + * minSideLength is used to specify that minimal width or height of a + * bitmap. + * maxNumOfPixels is used to specify the maximal size in pixels that is + * tolerable in terms of memory usage. + * + * The function returns a sample size based on the constraints. + * Both size and minSideLength can be passed in as UNCONSTRAINED, + * which indicates no care of the corresponding constraint. + * The functions prefers returning a sample size that + * generates a smaller bitmap, unless minSideLength = UNCONSTRAINED. + * + * Also, the function rounds up the sample size to a power of 2 or multiple + * of 8 because BitmapFactory only honors sample size this way. + * For example, BitmapFactory downsamples an image by 2 even though the + * request is 3. So we round up the sample size to avoid OOM. + */ + public static int computeSampleSize(int width, int height, + int minSideLength, int maxNumOfPixels) { + int initialSize = computeInitialSampleSize( + width, height, minSideLength, maxNumOfPixels); + + return initialSize <= 8 + ? Utils.nextPowerOf2(initialSize) + : (initialSize + 7) / 8 * 8; + } + + private static int computeInitialSampleSize(int w, int h, + int minSideLength, int maxNumOfPixels) { + if (maxNumOfPixels == UNCONSTRAINED + && minSideLength == UNCONSTRAINED) return 1; + + int lowerBound = (maxNumOfPixels == UNCONSTRAINED) ? 1 : + (int) FloatMath.ceil(FloatMath.sqrt((float) (w * h) / maxNumOfPixels)); + + if (minSideLength == UNCONSTRAINED) { + return lowerBound; + } else { + int sampleSize = Math.min(w / minSideLength, h / minSideLength); + return Math.max(sampleSize, lowerBound); + } + } + + // This computes a sample size which makes the longer side at least + // minSideLength long. If that's not possible, return 1. + public static int computeSampleSizeLarger(int w, int h, + int minSideLength) { + int initialSize = Math.max(w / minSideLength, h / minSideLength); + if (initialSize <= 1) return 1; + + return initialSize <= 8 + ? Utils.prevPowerOf2(initialSize) + : initialSize / 8 * 8; + } + + // Find the min x that 1 / x >= scale + public static int computeSampleSizeLarger(float scale) { + int initialSize = (int) FloatMath.floor(1f / scale); + if (initialSize <= 1) return 1; + + return initialSize <= 8 + ? Utils.prevPowerOf2(initialSize) + : initialSize / 8 * 8; + } + + // Find the max x that 1 / x <= scale. + public static int computeSampleSize(float scale) { + Utils.assertTrue(scale > 0); + int initialSize = Math.max(1, (int) FloatMath.ceil(1 / scale)); + return initialSize <= 8 + ? Utils.nextPowerOf2(initialSize) + : (initialSize + 7) / 8 * 8; + } + + public static Bitmap resizeBitmapByScale( + Bitmap bitmap, float scale, boolean recycle) { + int width = Math.round(bitmap.getWidth() * scale); + int height = Math.round(bitmap.getHeight() * scale); + if (width == bitmap.getWidth() + && height == bitmap.getHeight()) return bitmap; + Bitmap target = Bitmap.createBitmap(width, height, getConfig(bitmap)); + Canvas canvas = new Canvas(target); + canvas.scale(scale, scale); + Paint paint = new Paint(Paint.FILTER_BITMAP_FLAG | Paint.DITHER_FLAG); + canvas.drawBitmap(bitmap, 0, 0, paint); + if (recycle) bitmap.recycle(); + return target; + } + + private static Bitmap.Config getConfig(Bitmap bitmap) { + Bitmap.Config config = bitmap.getConfig(); + if (config == null) { + config = Bitmap.Config.ARGB_8888; + } + return config; + } + + public static Bitmap resizeDownBySideLength( + Bitmap bitmap, int maxLength, boolean recycle) { + int srcWidth = bitmap.getWidth(); + int srcHeight = bitmap.getHeight(); + float scale = Math.min( + (float) maxLength / srcWidth, (float) maxLength / srcHeight); + if (scale >= 1.0f) return bitmap; + return resizeBitmapByScale(bitmap, scale, recycle); + } + + public static Bitmap resizeAndCropCenter(Bitmap bitmap, int size, boolean recycle) { + int w = bitmap.getWidth(); + int h = bitmap.getHeight(); + if (w == size && h == size) return bitmap; + + // scale the image so that the shorter side equals to the target; + // the longer side will be center-cropped. + float scale = (float) size / Math.min(w, h); + + Bitmap target = Bitmap.createBitmap(size, size, getConfig(bitmap)); + int width = Math.round(scale * bitmap.getWidth()); + int height = Math.round(scale * bitmap.getHeight()); + Canvas canvas = new Canvas(target); + canvas.translate((size - width) / 2f, (size - height) / 2f); + canvas.scale(scale, scale); + Paint paint = new Paint(Paint.FILTER_BITMAP_FLAG | Paint.DITHER_FLAG); + canvas.drawBitmap(bitmap, 0, 0, paint); + if (recycle) bitmap.recycle(); + return target; + } + + public static void recycleSilently(Bitmap bitmap) { + if (bitmap == null) return; + try { + bitmap.recycle(); + } catch (Throwable t) { + Log.w(TAG, "unable recycle bitmap", t); + } + } + + public static Bitmap rotateBitmap(Bitmap source, int rotation, boolean recycle) { + if (rotation == 0) return source; + int w = source.getWidth(); + int h = source.getHeight(); + Matrix m = new Matrix(); + m.postRotate(rotation); + Bitmap bitmap = Bitmap.createBitmap(source, 0, 0, w, h, m, true); + if (recycle) source.recycle(); + return bitmap; + } + + public static Bitmap createVideoThumbnail(String filePath) { + // MediaMetadataRetriever is available on API Level 8 + // but is hidden until API Level 10 + Class<?> clazz = null; + Object instance = null; + try { + clazz = Class.forName("android.media.MediaMetadataRetriever"); + instance = clazz.newInstance(); + + Method method = clazz.getMethod("setDataSource", String.class); + method.invoke(instance, filePath); + + // The method name changes between API Level 9 and 10. + if (Build.VERSION.SDK_INT <= 9) { + return (Bitmap) clazz.getMethod("captureFrame").invoke(instance); + } else { + byte[] data = (byte[]) clazz.getMethod("getEmbeddedPicture").invoke(instance); + if (data != null) { + Bitmap bitmap = BitmapFactory.decodeByteArray(data, 0, data.length); + if (bitmap != null) return bitmap; + } + return (Bitmap) clazz.getMethod("getFrameAtTime").invoke(instance); + } + } catch (IllegalArgumentException ex) { + // Assume this is a corrupt video file + } catch (RuntimeException ex) { + // Assume this is a corrupt video file. + } catch (InstantiationException e) { + Log.e(TAG, "createVideoThumbnail", e); + } catch (InvocationTargetException e) { + Log.e(TAG, "createVideoThumbnail", e); + } catch (ClassNotFoundException e) { + Log.e(TAG, "createVideoThumbnail", e); + } catch (NoSuchMethodException e) { + Log.e(TAG, "createVideoThumbnail", e); + } catch (IllegalAccessException e) { + Log.e(TAG, "createVideoThumbnail", e); + } finally { + try { + if (instance != null) { + clazz.getMethod("release").invoke(instance); + } + } catch (Exception ignored) { + } + } + return null; + } + + public static byte[] compressToBytes(Bitmap bitmap) { + return compressToBytes(bitmap, DEFAULT_JPEG_QUALITY); + } + + public static byte[] compressToBytes(Bitmap bitmap, int quality) { + ByteArrayOutputStream baos = new ByteArrayOutputStream(65536); + bitmap.compress(CompressFormat.JPEG, quality, baos); + return baos.toByteArray(); + } + + public static boolean isSupportedByRegionDecoder(String mimeType) { + if (mimeType == null) return false; + mimeType = mimeType.toLowerCase(); + return mimeType.startsWith("image/") && + (!mimeType.equals("image/gif") && !mimeType.endsWith("bmp")); + } + + public static boolean isRotationSupported(String mimeType) { + if (mimeType == null) return false; + mimeType = mimeType.toLowerCase(); + return mimeType.equals("image/jpeg"); + } +} diff --git a/WallpaperPicker/src/com/android/gallery3d/common/Utils.java b/WallpaperPicker/src/com/android/gallery3d/common/Utils.java new file mode 100644 index 000000000..614a081c8 --- /dev/null +++ b/WallpaperPicker/src/com/android/gallery3d/common/Utils.java @@ -0,0 +1,340 @@ +/* + * 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 com.android.gallery3d.common; + +import android.content.Context; +import android.content.pm.PackageInfo; +import android.content.pm.PackageManager.NameNotFoundException; +import android.database.Cursor; +import android.os.Build; +import android.os.ParcelFileDescriptor; +import android.text.TextUtils; +import android.util.Log; + +import java.io.Closeable; +import java.io.IOException; +import java.io.InterruptedIOException; + +public class Utils { + private static final String TAG = "Utils"; + private static final String DEBUG_TAG = "GalleryDebug"; + + private static final long POLY64REV = 0x95AC9329AC4BC9B5L; + private static final long INITIALCRC = 0xFFFFFFFFFFFFFFFFL; + + private static long[] sCrcTable = new long[256]; + + private static final boolean IS_DEBUG_BUILD = + Build.TYPE.equals("eng") || Build.TYPE.equals("userdebug"); + + private static final String MASK_STRING = "********************************"; + + // Throws AssertionError if the input is false. + public static void assertTrue(boolean cond) { + if (!cond) { + throw new AssertionError(); + } + } + + // Throws AssertionError with the message. We had a method having the form + // assertTrue(boolean cond, String message, Object ... args); + // However a call to that method will cause memory allocation even if the + // condition is false (due to autoboxing generated by "Object ... args"), + // so we don't use that anymore. + public static void fail(String message, Object ... args) { + throw new AssertionError( + args.length == 0 ? message : String.format(message, args)); + } + + // Throws NullPointerException if the input is null. + public static <T> T checkNotNull(T object) { + if (object == null) throw new NullPointerException(); + return object; + } + + // Returns true if two input Object are both null or equal + // to each other. + public static boolean equals(Object a, Object b) { + return (a == b) || (a == null ? false : a.equals(b)); + } + + // Returns the next power of two. + // Returns the input if it is already power of 2. + // Throws IllegalArgumentException if the input is <= 0 or + // the answer overflows. + public static int nextPowerOf2(int n) { + if (n <= 0 || n > (1 << 30)) throw new IllegalArgumentException("n is invalid: " + n); + n -= 1; + n |= n >> 16; + n |= n >> 8; + n |= n >> 4; + n |= n >> 2; + n |= n >> 1; + return n + 1; + } + + // Returns the previous power of two. + // Returns the input if it is already power of 2. + // Throws IllegalArgumentException if the input is <= 0 + public static int prevPowerOf2(int n) { + if (n <= 0) throw new IllegalArgumentException(); + return Integer.highestOneBit(n); + } + + // Returns the input value x clamped to the range [min, max]. + public static int clamp(int x, int min, int max) { + if (x > max) return max; + if (x < min) return min; + return x; + } + + // Returns the input value x clamped to the range [min, max]. + public static float clamp(float x, float min, float max) { + if (x > max) return max; + if (x < min) return min; + return x; + } + + // Returns the input value x clamped to the range [min, max]. + public static long clamp(long x, long min, long max) { + if (x > max) return max; + if (x < min) return min; + return x; + } + + public static boolean isOpaque(int color) { + return color >>> 24 == 0xFF; + } + + public static void swap(int[] array, int i, int j) { + int temp = array[i]; + array[i] = array[j]; + array[j] = temp; + } + + /** + * A function thats returns a 64-bit crc for string + * + * @param in input string + * @return a 64-bit crc value + */ + public static final long crc64Long(String in) { + if (in == null || in.length() == 0) { + return 0; + } + return crc64Long(getBytes(in)); + } + + static { + // http://bioinf.cs.ucl.ac.uk/downloads/crc64/crc64.c + long part; + for (int i = 0; i < 256; i++) { + part = i; + for (int j = 0; j < 8; j++) { + long x = ((int) part & 1) != 0 ? POLY64REV : 0; + part = (part >> 1) ^ x; + } + sCrcTable[i] = part; + } + } + + public static final long crc64Long(byte[] buffer) { + long crc = INITIALCRC; + for (int k = 0, n = buffer.length; k < n; ++k) { + crc = sCrcTable[(((int) crc) ^ buffer[k]) & 0xff] ^ (crc >> 8); + } + return crc; + } + + public static byte[] getBytes(String in) { + byte[] result = new byte[in.length() * 2]; + int output = 0; + for (char ch : in.toCharArray()) { + result[output++] = (byte) (ch & 0xFF); + result[output++] = (byte) (ch >> 8); + } + return result; + } + + public static void closeSilently(Closeable c) { + if (c == null) return; + try { + c.close(); + } catch (IOException t) { + Log.w(TAG, "close fail ", t); + } + } + + public static int compare(long a, long b) { + return a < b ? -1 : a == b ? 0 : 1; + } + + public static int ceilLog2(float value) { + int i; + for (i = 0; i < 31; i++) { + if ((1 << i) >= value) break; + } + return i; + } + + public static int floorLog2(float value) { + int i; + for (i = 0; i < 31; i++) { + if ((1 << i) > value) break; + } + return i - 1; + } + + public static void closeSilently(ParcelFileDescriptor fd) { + try { + if (fd != null) fd.close(); + } catch (Throwable t) { + Log.w(TAG, "fail to close", t); + } + } + + public static void closeSilently(Cursor cursor) { + try { + if (cursor != null) cursor.close(); + } catch (Throwable t) { + Log.w(TAG, "fail to close", t); + } + } + + public static float interpolateAngle( + float source, float target, float progress) { + // interpolate the angle from source to target + // We make the difference in the range of [-179, 180], this is the + // shortest path to change source to target. + float diff = target - source; + if (diff < 0) diff += 360f; + if (diff > 180) diff -= 360f; + + float result = source + diff * progress; + return result < 0 ? result + 360f : result; + } + + public static float interpolateScale( + float source, float target, float progress) { + return source + progress * (target - source); + } + + public static String ensureNotNull(String value) { + return value == null ? "" : value; + } + + public static float parseFloatSafely(String content, float defaultValue) { + if (content == null) return defaultValue; + try { + return Float.parseFloat(content); + } catch (NumberFormatException e) { + return defaultValue; + } + } + + public static int parseIntSafely(String content, int defaultValue) { + if (content == null) return defaultValue; + try { + return Integer.parseInt(content); + } catch (NumberFormatException e) { + return defaultValue; + } + } + + public static boolean isNullOrEmpty(String exifMake) { + return TextUtils.isEmpty(exifMake); + } + + public static void waitWithoutInterrupt(Object object) { + try { + object.wait(); + } catch (InterruptedException e) { + Log.w(TAG, "unexpected interrupt: " + object); + } + } + + public static boolean handleInterrruptedException(Throwable e) { + // A helper to deal with the interrupt exception + // If an interrupt detected, we will setup the bit again. + if (e instanceof InterruptedIOException + || e instanceof InterruptedException) { + Thread.currentThread().interrupt(); + return true; + } + return false; + } + + /** + * @return String with special XML characters escaped. + */ + public static String escapeXml(String s) { + StringBuilder sb = new StringBuilder(); + for (int i = 0, len = s.length(); i < len; ++i) { + char c = s.charAt(i); + switch (c) { + case '<': sb.append("<"); break; + case '>': sb.append(">"); break; + case '\"': sb.append("""); break; + case '\'': sb.append("'"); break; + case '&': sb.append("&"); break; + default: sb.append(c); + } + } + return sb.toString(); + } + + public static String getUserAgent(Context context) { + PackageInfo packageInfo; + try { + packageInfo = context.getPackageManager().getPackageInfo(context.getPackageName(), 0); + } catch (NameNotFoundException e) { + throw new IllegalStateException("getPackageInfo failed"); + } + return String.format("%s/%s; %s/%s/%s/%s; %s/%s/%s", + packageInfo.packageName, + packageInfo.versionName, + Build.BRAND, + Build.DEVICE, + Build.MODEL, + Build.ID, + Build.VERSION.SDK_INT, + Build.VERSION.RELEASE, + Build.VERSION.INCREMENTAL); + } + + public static String[] copyOf(String[] source, int newSize) { + String[] result = new String[newSize]; + newSize = Math.min(source.length, newSize); + System.arraycopy(source, 0, result, 0, newSize); + return result; + } + + // Mask information for debugging only. It returns <code>info.toString()</code> directly + // for debugging build (i.e., 'eng' and 'userdebug') and returns a mask ("****") + // in release build to protect the information (e.g. for privacy issue). + public static String maskDebugInfo(Object info) { + if (info == null) return null; + String s = info.toString(); + int length = Math.min(s.length(), MASK_STRING.length()); + return IS_DEBUG_BUILD ? s : MASK_STRING.substring(0, length); + } + + // This method should be ONLY used for debugging. + public static void debug(String message, Object ... args) { + Log.v(DEBUG_TAG, String.format(message, args)); + } +} |