// region Public methods public Bitmap getBitmap(File file, int type) { BitmapFactory.Options options = new BitmapFactory.Options(); switch (type) { case BACKGROUND: options.inBitmap = background; break; case SUBJECT: options.inBitmap = subject; break; case RAW: options.inBitmap = raw; break; } return BitmapFactory.decodeFile(file.getAbsolutePath(), options); }
public DessertCaseView(Context context, AttributeSet attrs, int defStyle) { super(context, attrs, defStyle); final Resources res = getResources(); mStarted = false; mCellSize = res.getDimensionPixelSize(R.dimen.dessert_case_cell_size); final BitmapFactory.Options opts = new BitmapFactory.Options(); if (mCellSize < 512) { // assuming 512x512 images opts.inSampleSize = 2; } opts.inMutable = true; Bitmap loaded = null; for (int[] list : new int[][] {PASTRIES, RARE_PASTRIES, XRARE_PASTRIES, XXRARE_PASTRIES}) { for (int resid : list) { opts.inBitmap = loaded; loaded = BitmapFactory.decodeResource(res, resid, opts); final BitmapDrawable d = new BitmapDrawable(res, convertToAlphaMask(loaded)); d.setColorFilter(new ColorMatrixColorFilter(ALPHA_MASK)); d.setBounds(0, 0, mCellSize, mCellSize); mDrawables.append(resid, d); } } loaded = null; if (DEBUG) setWillNotDraw(false); }
private CloseableReference<Bitmap> decodeStaticImageFromStream( InputStream inputStream, BitmapFactory.Options options) { Preconditions.checkNotNull(inputStream); int sizeInBytes = BitmapUtil.getSizeInByteForBitmap( options.outWidth, options.outHeight, options.inPreferredConfig); final Bitmap bitmapToReuse = mBitmapPool.get(sizeInBytes); if (bitmapToReuse == null) { throw new NullPointerException("BitmapPool.get returned null"); } options.inBitmap = bitmapToReuse; Bitmap decodedBitmap; ByteBuffer byteBuffer = mDecodeBuffers.acquire(); if (byteBuffer == null) { byteBuffer = ByteBuffer.allocate(DECODE_BUFFER_SIZE); } try { options.inTempStorage = byteBuffer.array(); decodedBitmap = BitmapFactory.decodeStream(inputStream, null, options); } catch (RuntimeException re) { mBitmapPool.release(bitmapToReuse); throw re; } finally { mDecodeBuffers.release(byteBuffer); } if (bitmapToReuse != decodedBitmap) { mBitmapPool.release(bitmapToReuse); decodedBitmap.recycle(); throw new IllegalStateException(); } return CloseableReference.of(decodedBitmap, mBitmapPool); }
private Bitmap readFromDb(String name, Bitmap b) { if (mCachedSelectQuery == null) { mCachedSelectQuery = CacheDb.COLUMN_NAME + " = ? AND " + CacheDb.COLUMN_SIZE + " = ?"; } SQLiteDatabase db = mDb.getReadableDatabase(); Cursor result = db.query( CacheDb.TABLE_NAME, new String[] {CacheDb.COLUMN_PREVIEW_BITMAP}, // cols to return mCachedSelectQuery, // select query new String[] {name, mSize}, // args to select query null, null, null, null); if (result.getCount() > 0) { result.moveToFirst(); byte[] blob = result.getBlob(0); result.close(); final BitmapFactory.Options opts = mCachedBitmapFactoryOptions.get(); opts.inBitmap = b; opts.inSampleSize = 1; try { return BitmapFactory.decodeByteArray(blob, 0, blob.length, opts); } catch (IllegalArgumentException e) { removeItemFromDb(mDb, name); return null; } } else { result.close(); return null; } }
/** * ponerOpcionInBitmap: Checa si es posible reutilizar un bitmap desechado de acuerdo a los * requerimientos de esta imagen en particular, de ser asi activa la opcion inBitmap. * * @param opciones BitmapFactory.Options de la imagen nueva. */ private void ponerOpcionInBitmap(BitmapFactory.Options opciones) { // Tiene que ser mutable opciones.inMutable = true; Bitmap bitmap_reutilizable = obtenerBitmapDesechado(opciones); // Activa inBitmap en las opciones con el bitmap encontrado if (bitmap_reutilizable != null) { opciones.inBitmap = bitmap_reutilizable; } }
public GLPicture(BitmapRegionLoader bitmapRegionLoader, int maxHeight) { if (bitmapRegionLoader == null || maxHeight == 0) { return; } mHasContent = true; mVertexBuffer = GLUtil.newFloatBuffer(mVertices.length); mTextureCoordsBuffer = GLUtil.asFloatBuffer(SQUARE_TEXTURE_VERTICES); int originalWidth = bitmapRegionLoader.getWidth(); int originalHeight = bitmapRegionLoader.getHeight(); int sampleSize = 1; while (originalHeight / (sampleSize << 1) > maxHeight) { sampleSize <<= 1; } mWidth = originalWidth / sampleSize; mHeight = originalHeight / sampleSize; mTileSize = Math.min(512, sMaxTextureSize); int unsampledTileSize = mTileSize * sampleSize; int leftoverHeight = originalHeight % unsampledTileSize; // Load m x n textures mCols = mWidth / (mTileSize + 1) + 1; mRows = mHeight / (mTileSize + 1) + 1; mTextureHandles = new int[mCols * mRows]; Bitmap tileBitmap = Bitmap.createBitmap(mTileSize, mTileSize, Bitmap.Config.ARGB_8888); Rect rect = new Rect(); BitmapFactory.Options options = new BitmapFactory.Options(); options.inSampleSize = sampleSize; options.inBitmap = tileBitmap; for (int y = 0; y < mRows; y++) { for (int x = 0; x < mCols; x++) { rect.set( x * unsampledTileSize, (mRows - y - 1) * unsampledTileSize, (x + 1) * unsampledTileSize, (mRows - y) * unsampledTileSize); // The bottom tiles must be full tiles for drawing, so only allow edge tiles // at the top if (leftoverHeight > 0) { rect.offset(0, -unsampledTileSize + leftoverHeight); } rect.intersect(0, 0, originalWidth, originalHeight); Bitmap useBitmap = bitmapRegionLoader.decodeRegion(rect, options); mTextureHandles[y * mCols + x] = GLUtil.loadTexture(useBitmap); if (useBitmap != tileBitmap) { useBitmap.recycle(); } } } }
@TargetApi(Build.VERSION_CODES.HONEYCOMB) private void addInBitmapOptions(BitmapFactory.Options options, ImageCache cache) { options.inMutable = true; if (cache != null) { Bitmap inBitmap = cache.getBitmapFromReusableSet(options); if (inBitmap != null) { options.inBitmap = inBitmap; } } }
@TargetApi(Build.VERSION_CODES.HONEYCOMB) public static Bitmap decodeUsingPool( JobContext jc, byte[] data, int offset, int length, BitmapFactory.Options options) { if (options == null) options = new BitmapFactory.Options(); if (options.inSampleSize < 1) options.inSampleSize = 1; options.inPreferredConfig = Bitmap.Config.ARGB_8888; options.inBitmap = (options.inSampleSize == 1) ? findCachedBitmap(jc, data, offset, length, options) : null; try { Bitmap bitmap = decode(jc, data, offset, length, options); if (options.inBitmap != null && options.inBitmap != bitmap) { GalleryBitmapPool.getInstance().put(options.inBitmap); options.inBitmap = null; } return bitmap; } catch (IllegalArgumentException e) { if (options.inBitmap == null) throw e; Log.w(TAG, "decode fail with a given bitmap, try decode to a new bitmap"); GalleryBitmapPool.getInstance().put(options.inBitmap); options.inBitmap = null; return decode(jc, data, offset, length, options); } }
private static void addInBitmapOptions( BitmapFactory.Options options, Set<SoftReference<Bitmap>> reuseableBitmaps) { // inBitmap only works with mutable bitmaps, so force the decoder to // return mutable bitmaps. options.inMutable = true; // Try to find a bitmap to use for inBitmap. Bitmap inBitmap = getBitmapFromReusableSet(reuseableBitmaps, options); if (inBitmap != null) { // If a suitable bitmap has been found, set it as the value of // inBitmap. options.inBitmap = inBitmap; } }
@TargetApi(Build.VERSION_CODES.HONEYCOMB) private static void addInBitmapOptions(BitmapFactory.Options options, ImageCache cache) { // BEGIN_INCLUDE(add_bitmap_options) // inBitmap only works with mutable bitmaps so force the decoder to // return mutable bitmaps. options.inMutable = true; if (cache != null) { // Try and find a bitmap to use for inBitmap Bitmap inBitmap = cache.getBitmapFromReusableSet(options); if (inBitmap != null) { options.inBitmap = inBitmap; } } // END_INCLUDE(add_bitmap_options) }
public static Bitmap decodeSampledBitmapFromPath(String path, int reqWidth, int reqHeight) { final BitmapFactory.Options options = new BitmapFactory.Options(); options.inJustDecodeBounds = true; options.inMutable = true; options.inBitmap = BitmapFactory.decodeFile(path, options); options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight); options.inScaled = true; options.inDensity = options.outWidth; options.inTargetDensity = reqWidth * options.inSampleSize; options.inJustDecodeBounds = false; options.inPurgeable = true; options.inInputShareable = true; return BitmapFactory.decodeFile(path, options); }
/** Decode and sample down a bitmap from a byte stream */ public static Bitmap decodeSampledBitmapFromByte(Context context, byte[] bitmapBytes) { Display display = ((WindowManager) context.getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay(); int reqWidth, reqHeight; Point point = new Point(); if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB_MR2) { display.getSize(point); reqWidth = point.x; reqHeight = point.y; } else { reqWidth = display.getWidth(); reqHeight = display.getHeight(); } final BitmapFactory.Options options = new BitmapFactory.Options(); options.inJustDecodeBounds = true; options.inMutable = true; options.inBitmap = BitmapFactory.decodeByteArray(bitmapBytes, 0, bitmapBytes.length, options); // Calculate inSampleSize options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight); // Load & resize the image to be 1/inSampleSize dimensions // Use when you do not want to scale the image with a inSampleSize that is a power of 2 options.inScaled = true; options.inDensity = options.outWidth; options.inTargetDensity = reqWidth * options.inSampleSize; // Decode bitmap with inSampleSize set options.inJustDecodeBounds = false; // If set to true, the decoder will return null (no bitmap), but the out... fields // will still be set, allowing the caller to query the bitmap without having to // allocate the memory for its pixels. options.inPurgeable = true; // Tell to gc that whether it needs free memory, the Bitmap can be cleared options.inInputShareable = true; // Which kind of reference will be used to recover the Bitmap data after being clear, // when it will be used in the future return BitmapFactory.decodeByteArray(bitmapBytes, 0, bitmapBytes.length, options); }
@TargetApi(11) private BitmapFactory.Options createTileBitmapFactoryOptions( int tileSize, boolean isTransparent) { BitmapFactory.Options bitmapFactoryOptions = new BitmapFactory.Options(); if (isTransparent) { bitmapFactoryOptions.inPreferredConfig = AndroidGraphicFactory.TRANSPARENT_BITMAP; } else { bitmapFactoryOptions.inPreferredConfig = AndroidGraphicFactory.NON_TRANSPARENT_BITMAP; } if (org.mapsforge.map.android.util.AndroidUtil.HONEYCOMB_PLUS) { android.graphics.Bitmap reusableBitmap = getTileBitmapFromReusableSet(tileSize, isTransparent); if (reusableBitmap != null) { bitmapFactoryOptions.inMutable = true; bitmapFactoryOptions.inSampleSize = 1; // not really sure why this is required, but otherwise decoding // fails bitmapFactoryOptions.inBitmap = getTileBitmapFromReusableSet(tileSize, isTransparent); } } return bitmapFactoryOptions; }
public Bitmap getRawBitmap(byte[] data) { BitmapFactory.Options options = new BitmapFactory.Options(); options.inMutable = true; options.inBitmap = raw; return BitmapFactory.decodeByteArray(data, 0, data.length, options); }
@TargetApi(11) private static void setInBitmap(BitmapFactory.Options options, Bitmap recycled) { if (Build.VERSION.SDK_INT >= 11) { options.inBitmap = recycled; } }