@TargetApi(10)
  private Bitmap decodeRegionCrop(Bitmap croppedImage, Rect rect) {
    // Release memory now
    clearImageView();

    InputStream is = null;
    try {
      is = getContentResolver().openInputStream(sourceUri);
      BitmapRegionDecoder decoder = BitmapRegionDecoder.newInstance(is, false);
      final int width = decoder.getWidth();
      final int height = decoder.getHeight();

      if (exifRotation != 0) {
        // Adjust crop area to account for image rotation
        Matrix matrix = new Matrix();
        matrix.setRotate(-exifRotation);

        RectF adjusted = new RectF();
        matrix.mapRect(adjusted, new RectF(rect));

        // Adjust to account for origin at 0,0
        adjusted.offset(adjusted.left < 0 ? width : 0, adjusted.top < 0 ? height : 0);
        rect =
            new Rect(
                (int) adjusted.left,
                (int) adjusted.top,
                (int) adjusted.right,
                (int) adjusted.bottom);
      }

      try {
        croppedImage = decoder.decodeRegion(rect, new BitmapFactory.Options());

      } catch (IllegalArgumentException e) {
        // Rethrow with some extra information
        throw new IllegalArgumentException(
            "Rectangle "
                + rect
                + " is outside of the image ("
                + width
                + ","
                + height
                + ","
                + exifRotation
                + ")",
            e);
      }

    } catch (IOException e) {
      Log.e("Error cropping image: " + e.getMessage(), e);
      finish();
    } catch (OutOfMemoryError e) {
      Log.e("OOM cropping image: " + e.getMessage(), e);
      setResultException(e);
    } finally {
      CropUtil.closeSilently(is);
    }
    return croppedImage;
  }
 @Override
 public BitmapRegionDecoder run(JobContext jc) {
   if (!prepareInputFile(jc)) return null;
   BitmapRegionDecoder decoder =
       DecodeUtils.createBitmapRegionDecoder(jc, mFileDescriptor.getFileDescriptor(), false);
   mWidth = decoder.getWidth();
   mHeight = decoder.getHeight();
   return decoder;
 }
Exemple #3
0
  private static Bitmap regionDecode(
      byte[] data, int reqWidth, int reqHeight, int outWidth, int outHeight) throws IOException {
    BitmapRegionDecoder regionDecoder = BitmapRegionDecoder.newInstance(data, 0, data.length, true);
    if (reqWidth > outWidth) {
      reqWidth = outWidth;
    }
    if (reqHeight > outHeight) {
      reqHeight = outHeight;
    }

    return regionDecoder.decodeRegion(new Rect(0, 0, reqWidth, reqHeight), null);
  }
 private void updateTileProvider(ImageEntry entry) {
   Bitmap screenNail = entry.screenNail;
   BitmapRegionDecoder fullImage = entry.fullImage;
   if (screenNail != null) {
     if (fullImage != null) {
       mTileProvider.setBackupImage(screenNail, fullImage.getWidth(), fullImage.getHeight());
       mTileProvider.setRegionDecoder(fullImage);
     } else {
       int width = screenNail.getWidth();
       int height = screenNail.getHeight();
       mTileProvider.setBackupImage(screenNail, width, height);
     }
   } else {
     mTileProvider.clear();
     if (entry.failToLoad) mTileProvider.setFailedToLoad();
   }
 }
 public static BitmapRegionDecoder createBitmapRegionDecoder(
     JobContext jc, FileDescriptor fd, boolean shareable) {
   try {
     return BitmapRegionDecoder.newInstance(fd, shareable);
   } catch (Throwable t) {
     Log.w(TAG, t);
     return null;
   }
 }
 public static BitmapRegionDecoder createBitmapRegionDecoder(
     JobContext jc, String filePath, boolean shareable) {
   try {
     return BitmapRegionDecoder.newInstance(filePath, shareable);
   } catch (Throwable t) {
     Log.w(TAG, t);
     return null;
   }
 }
 public static BitmapRegionDecoder createBitmapRegionDecoder(
     JobContext jc, InputStream is, boolean shareable) {
   try {
     return BitmapRegionDecoder.newInstance(is, shareable);
   } catch (Throwable t) {
     // We often cancel the creating of bitmap region decoder,
     // so just log one line.
     Log.w(TAG, "requestCreateBitmapRegionDecoder: " + t);
     return null;
   }
 }
  private void updateFullImage(long version, Future<BitmapRegionDecoder> future) {
    ImageEntry entry = mImageCache.get(version);
    if (entry == null || entry.fullImageTask != future) {
      BitmapRegionDecoder fullImage = future.get();
      if (fullImage != null) fullImage.recycle();
      return;
    }

    entry.fullImageTask = null;
    entry.fullImage = future.get();
    if (entry.fullImage != null) {
      if (mDataListener != null) {
        mDataListener.onPhotoAvailable(version, true);
      }
      if (version == getVersion(mCurrentIndex)) {
        updateTileProvider(entry);
        mPhotoView.notifyImageInvalidated(0);
      }
    }
    updateImageRequests();
  }
 @TargetApi(Build.VERSION_CODES.GINGERBREAD_MR1)
 @Override
 protected BitmapRegionDecoder createBitmapRegionDecoder() {
   try {
     InputStream in = openInputStream();
     if (in == null) {
       return null;
     }
     return BitmapRegionDecoder.newInstance(in, false);
   } catch (IOException e) {
     return null;
   }
 }
  public static BitmapRegionDecoder createBitmapRegionDecoder(
      JobContext jc, byte[] bytes, int offset, int length, boolean shareable) {
    if (offset < 0 || length <= 0 || offset + length > bytes.length) {
      throw new IllegalArgumentException(
          String.format("offset = %s, length = %s, bytes = %s", offset, length, bytes.length));
    }

    try {
      return BitmapRegionDecoder.newInstance(bytes, offset, length, shareable);
    } catch (Throwable t) {
      Log.w(TAG, t);
      return null;
    }
  }
Exemple #11
0
  public static HashMap<Character, Bitmap> getImages() {
    BitmapRegionDecoder decoder = null;

    if (sImages != null) return sImages;

    InputStream is = sContext.getResources().openRawResource(EN);

    try {
      decoder = BitmapRegionDecoder.newInstance(is, false);
    } catch (IOException ex) {
    }

    int h = decoder.getHeight();
    sImages = new HashMap<Character, Bitmap>();
    Rect r = new Rect(0, 0, h, h);
    for (char c = ABC.first(); c != CharacterIterator.DONE; c = ABC.next(), r.offset(h, 0)) {
      Bitmap bmp = decoder.decodeRegion(r, null);
      sImages.put(c, bmp);
    }

    Log.d("getImages", "float=" + sContext.getResources().getDisplayMetrics().density);
    return sImages;
  }
  public void setInputStream(InputStream is) {
    try {
      mDecoder = BitmapRegionDecoder.newInstance(is, false);
      BitmapFactory.Options tmpOptions = new BitmapFactory.Options();
      // Grab the bounds for the scene dimensions
      tmpOptions.inJustDecodeBounds = true;
      BitmapFactory.decodeStream(is, null, tmpOptions);
      mImageWidth = tmpOptions.outWidth;
      mImageHeight = tmpOptions.outHeight;

      requestLayout();
      invalidate();
    } catch (IOException e) {
      e.printStackTrace();
    } finally {

      try {
        if (is != null) is.close();
      } catch (Exception e) {
      }
    }
  }
Exemple #13
0
  public static Bitmap getMiddlePictureInTimeLine(
      String url,
      int reqWidth,
      int reqHeight,
      FileDownloaderHttpHelper.DownloadListener downloadListener) {
    try {

      String filePath = FileManager.getFilePathFromUrl(url, FileLocationMethod.picture_bmiddle);

      File file = new File(filePath);

      if (!file.exists() && !SettingUtility.isEnablePic()) {
        return null;
      }

      if (!file.exists()) {
        getBitmapFromNetWork(url, filePath, downloadListener);
      }

      if (isGif(filePath)) {
        return getMiddlePictureInTimeLineGif(filePath, reqWidth, reqHeight);
      }

      BitmapFactory.Options options = new BitmapFactory.Options();
      options.inJustDecodeBounds = true;
      BitmapFactory.decodeFile(filePath, options);

      int height = options.outHeight;
      int width = options.outWidth;

      int cutHeight = 0;
      int cutWidth = 0;

      if (height >= reqHeight && width >= reqWidth) {
        cutHeight = reqHeight;
        cutWidth = reqWidth;

      } else if (height < reqHeight && width >= reqWidth) {

        cutHeight = height;
        cutWidth = (reqWidth * cutHeight) / reqHeight;

      } else if (height >= reqHeight && width < reqWidth) {

        cutWidth = width;
        cutHeight = (reqHeight * cutWidth) / reqWidth;

      } else if (height < reqHeight && width < reqWidth) {

        float betweenWidth = ((float) reqWidth - (float) width) / (float) width;
        float betweenHeight = ((float) reqHeight - (float) height) / (float) height;

        if (betweenWidth > betweenHeight) {
          cutWidth = width;
          cutHeight = (reqHeight * cutWidth) / reqWidth;

        } else {
          cutHeight = height;
          cutWidth = (reqWidth * cutHeight) / reqHeight;
        }
      }

      if (cutWidth > 0 && cutHeight > 0) {

        int startX = 0;

        if (cutWidth < width) {
          startX = (width - cutWidth) / 2;
        }

        try {
          BitmapRegionDecoder decoder = BitmapRegionDecoder.newInstance(filePath, false);
          if (decoder != null) {
            Bitmap bitmap =
                decoder.decodeRegion(new Rect(startX, 0, startX + cutWidth, cutHeight), null);
            if (bitmap.getHeight() < reqHeight && bitmap.getWidth() < reqWidth) {
              Bitmap scale = Bitmap.createScaledBitmap(bitmap, reqWidth, reqHeight, true);
              if (scale != bitmap) {
                bitmap.recycle();
                bitmap = scale;
              }
            }
            if (bitmap != null) {
              Bitmap roundedCornerBitmap = ImageEdit.getRoundedCornerBitmap(bitmap);
              if (roundedCornerBitmap != bitmap) {
                bitmap.recycle();
                bitmap = roundedCornerBitmap;
              }

              return bitmap;
            }
          }
        } catch (IOException ignored) {

        }
      }

      return null;
    } catch (OutOfMemoryError ignored) {
      ignored.printStackTrace();
      return null;
    }
  }
    public boolean cropBitmap() {
      boolean failure = false;

      WallpaperManager wallpaperManager = null;
      if (mSetWallpaper) {
        wallpaperManager = WallpaperManager.getInstance(mContext.getApplicationContext());
      }

      if (mSetWallpaper && mNoCrop) {
        try {
          InputStream is = regenerateInputStream();
          if (is != null) {
            wallpaperManager.setStream(is);
            Utils.closeSilently(is);
          }
        } catch (IOException e) {
          Log.w(LOGTAG, "cannot write stream to wallpaper", e);
          failure = true;
        }
        return !failure;
      } else {
        // Find crop bounds (scaled to original image size)
        Rect roundedTrueCrop = new Rect();
        Matrix rotateMatrix = new Matrix();
        Matrix inverseRotateMatrix = new Matrix();

        Point bounds = getImageBounds();
        if (mRotation > 0) {
          rotateMatrix.setRotate(mRotation);
          inverseRotateMatrix.setRotate(-mRotation);

          mCropBounds.roundOut(roundedTrueCrop);
          mCropBounds = new RectF(roundedTrueCrop);

          if (bounds == null) {
            Log.w(LOGTAG, "cannot get bounds for image");
            failure = true;
            return false;
          }

          float[] rotatedBounds = new float[] {bounds.x, bounds.y};
          rotateMatrix.mapPoints(rotatedBounds);
          rotatedBounds[0] = Math.abs(rotatedBounds[0]);
          rotatedBounds[1] = Math.abs(rotatedBounds[1]);

          mCropBounds.offset(-rotatedBounds[0] / 2, -rotatedBounds[1] / 2);
          inverseRotateMatrix.mapRect(mCropBounds);
          mCropBounds.offset(bounds.x / 2, bounds.y / 2);
        }

        mCropBounds.roundOut(roundedTrueCrop);

        if (roundedTrueCrop.width() <= 0 || roundedTrueCrop.height() <= 0) {
          Log.w(LOGTAG, "crop has bad values for full size image");
          failure = true;
          return false;
        }

        // See how much we're reducing the size of the image
        int scaleDownSampleSize =
            Math.max(
                1,
                Math.min(
                    roundedTrueCrop.width() / mOutWidth, roundedTrueCrop.height() / mOutHeight));
        // Attempt to open a region decoder
        BitmapRegionDecoder decoder = null;
        InputStream is = null;
        try {
          is = regenerateInputStream();
          if (is == null) {
            Log.w(LOGTAG, "cannot get input stream for uri=" + mInUri.toString());
            failure = true;
            return false;
          }
          decoder = BitmapRegionDecoder.newInstance(is, false);
          Utils.closeSilently(is);
        } catch (IOException e) {
          Log.w(LOGTAG, "cannot open region decoder for file: " + mInUri.toString(), e);
        } finally {
          Utils.closeSilently(is);
          is = null;
        }

        Bitmap crop = null;
        if (decoder != null) {
          // Do region decoding to get crop bitmap
          BitmapFactory.Options options = new BitmapFactory.Options();
          if (scaleDownSampleSize > 1) {
            options.inSampleSize = scaleDownSampleSize;
          }
          crop = decoder.decodeRegion(roundedTrueCrop, options);
          decoder.recycle();
        }

        if (crop == null) {
          // BitmapRegionDecoder has failed, try to crop in-memory
          is = regenerateInputStream();
          Bitmap fullSize = null;
          if (is != null) {
            BitmapFactory.Options options = new BitmapFactory.Options();
            if (scaleDownSampleSize > 1) {
              options.inSampleSize = scaleDownSampleSize;
            }
            fullSize = BitmapFactory.decodeStream(is, null, options);
            Utils.closeSilently(is);
          }
          if (fullSize != null) {
            // Find out the true sample size that was used by the decoder
            scaleDownSampleSize = bounds.x / fullSize.getWidth();
            mCropBounds.left /= scaleDownSampleSize;
            mCropBounds.top /= scaleDownSampleSize;
            mCropBounds.bottom /= scaleDownSampleSize;
            mCropBounds.right /= scaleDownSampleSize;
            mCropBounds.roundOut(roundedTrueCrop);

            // Adjust values to account for issues related to rounding
            if (roundedTrueCrop.width() > fullSize.getWidth()) {
              // Adjust the width
              roundedTrueCrop.right = roundedTrueCrop.left + fullSize.getWidth();
            }
            if (roundedTrueCrop.right > fullSize.getWidth()) {
              // Adjust the left value
              int adjustment =
                  roundedTrueCrop.left
                      - Math.max(0, roundedTrueCrop.right - roundedTrueCrop.width());
              roundedTrueCrop.left -= adjustment;
              roundedTrueCrop.right -= adjustment;
            }
            if (roundedTrueCrop.height() > fullSize.getHeight()) {
              // Adjust the height
              roundedTrueCrop.bottom = roundedTrueCrop.top + fullSize.getHeight();
            }
            if (roundedTrueCrop.bottom > fullSize.getHeight()) {
              // Adjust the top value
              int adjustment =
                  roundedTrueCrop.top
                      - Math.max(0, roundedTrueCrop.bottom - roundedTrueCrop.height());
              roundedTrueCrop.top -= adjustment;
              roundedTrueCrop.bottom -= adjustment;
            }

            crop =
                Bitmap.createBitmap(
                    fullSize,
                    roundedTrueCrop.left,
                    roundedTrueCrop.top,
                    roundedTrueCrop.width(),
                    roundedTrueCrop.height());
          }
        }

        if (crop == null) {
          Log.w(LOGTAG, "cannot decode file: " + mInUri.toString());
          failure = true;
          return false;
        }
        if (mOutWidth > 0 && mOutHeight > 0 || mRotation > 0) {
          float[] dimsAfter = new float[] {crop.getWidth(), crop.getHeight()};
          rotateMatrix.mapPoints(dimsAfter);
          dimsAfter[0] = Math.abs(dimsAfter[0]);
          dimsAfter[1] = Math.abs(dimsAfter[1]);

          if (!(mOutWidth > 0 && mOutHeight > 0)) {
            mOutWidth = Math.round(dimsAfter[0]);
            mOutHeight = Math.round(dimsAfter[1]);
          }

          RectF cropRect = new RectF(0, 0, dimsAfter[0], dimsAfter[1]);
          RectF returnRect = new RectF(0, 0, mOutWidth, mOutHeight);

          Matrix m = new Matrix();
          if (mRotation == 0) {
            m.setRectToRect(cropRect, returnRect, Matrix.ScaleToFit.FILL);
          } else {
            Matrix m1 = new Matrix();
            m1.setTranslate(-crop.getWidth() / 2f, -crop.getHeight() / 2f);
            Matrix m2 = new Matrix();
            m2.setRotate(mRotation);
            Matrix m3 = new Matrix();
            m3.setTranslate(dimsAfter[0] / 2f, dimsAfter[1] / 2f);
            Matrix m4 = new Matrix();
            m4.setRectToRect(cropRect, returnRect, Matrix.ScaleToFit.FILL);

            Matrix c1 = new Matrix();
            c1.setConcat(m2, m1);
            Matrix c2 = new Matrix();
            c2.setConcat(m4, m3);
            m.setConcat(c2, c1);
          }

          Bitmap tmp =
              Bitmap.createBitmap(
                  (int) returnRect.width(), (int) returnRect.height(), Bitmap.Config.ARGB_8888);
          if (tmp != null) {
            Canvas c = new Canvas(tmp);
            Paint p = new Paint();
            p.setFilterBitmap(true);
            c.drawBitmap(crop, m, p);
            crop = tmp;
          }
        }

        if (mSaveCroppedBitmap) {
          mCroppedBitmap = crop;
        }

        // Get output compression format
        CompressFormat cf = convertExtensionToCompressFormat(getFileExtension(mOutputFormat));

        // Compress to byte array
        ByteArrayOutputStream tmpOut = new ByteArrayOutputStream(2048);
        if (crop.compress(cf, DEFAULT_COMPRESS_QUALITY, tmpOut)) {
          // If we need to set to the wallpaper, set it
          if (mSetWallpaper && wallpaperManager != null) {
            try {
              byte[] outByteArray = tmpOut.toByteArray();
              wallpaperManager.setStream(new ByteArrayInputStream(outByteArray));
              if (mOnBitmapCroppedHandler != null) {
                mOnBitmapCroppedHandler.onBitmapCropped(outByteArray);
              }
            } catch (IOException e) {
              Log.w(LOGTAG, "cannot write stream to wallpaper", e);
              failure = true;
            }
          }
        } else {
          Log.w(LOGTAG, "cannot compress bitmap");
          failure = true;
        }
      }
      return !failure; // True if any of the operations failed
    }
 @Override
 protected void onDraw(Canvas canvas) {
   Bitmap bm = mDecoder.decodeRegion(mRect, options);
   canvas.drawBitmap(bm, 0, 0, null);
 }
  boolean decodeJPEGAndAnalyze(Context context, CalibrationEntries calibrationEntries) {
    boolean result = false;
    BitmapFactory.Options opt = new BitmapFactory.Options();
    opt.inPreferQualityOverSpeed = true;
    BitmapRegionDecoder brd;
    byte[] data = mData;
    try {
      brd = BitmapRegionDecoder.newInstance(data, 0, data.length, false);
      Rect rect;
      rect = new Rect(0, 0, brd.getWidth(), brd.getHeight());
      Bitmap bitmap = brd.decodeRegion(rect, opt);
      MatBitmapHolder mRgbaMatHolder = new MatBitmapHolder(bitmap);
      Mat rgbaMat = mRgbaMatHolder.pin();
      Mat grayData = new Mat();
      Imgproc.cvtColor(rgbaMat, grayData, Imgproc.COLOR_RGB2GRAY, 1);
      Mat centersCalibCircles = new Mat();

      Size patternSize = CalibrationEntries.Pattern_ASYMMETRIC_CIRCLES_GRID_SIZE;
      Size imageSize = new Size(grayData.cols(), grayData.rows());
      boolean patternWasFound =
          Calib3d.findCirclesGridDefault(
              grayData, patternSize, centersCalibCircles, Calib3d.CALIB_CB_ASYMMETRIC_GRID);

      if (patternWasFound && this.orientation != null) {
        int addedIdx = calibrationEntries.addEntry(this.orientation, centersCalibCircles);
        if (addedIdx >= 0) {
          Log.d(
              "CALIB",
              String.format(
                  "PictureCapture: Added calibration entry at %d tot: %d",
                  addedIdx, calibrationEntries.getNumEntries()));
          if (calibrationEntries.getNewlyAdded() > 5) {
            List<Mat> imagePoints = calibrationEntries.getPoints();
            List<Mat> objectPoints =
                calibrationEntries.getObjectPointsAsymmentricList(imagePoints.size());
            if (CalibrationEntries.isEnoughCalibrationPoints(imagePoints.size())) {
              calibrationEntries.resetNewlyAdded();
              CameraCalibrationData cameraCalibrationData = new CameraCalibrationData();
              List<Mat> rvecs = new Vector<Mat>(imagePoints.size());
              List<Mat> tvecs = new Vector<Mat>(imagePoints.size());
              int flags = 0;
              flags |= Calib3d.CALIB_FIX_K4 | Calib3d.CALIB_FIX_K5;
              Log.d("CALIB", String.format("PictureCapture: Calling Calib3d.calibrateCamera"));
              Mat K = new Mat();
              Mat kdist = new Mat();
              double rms =
                  Calib3d.calibrateCamera(
                      objectPoints, imagePoints, imageSize, K, kdist, rvecs, tvecs, flags);
              double[] Karray = new double[9];
              double[] distcoeffs_array = new double[5];
              K.get(0, 0, Karray);
              kdist.get(0, 0, distcoeffs_array);
              cameraCalibrationData.setData(
                  grayData.cols(), grayData.rows(), Karray, distcoeffs_array, rms);
              Log.d(
                  "CALIB",
                  String.format(
                      "PictureCapture: Calibration data: %s",
                      cameraCalibrationData.formatCalibrationDataString()));
              calibrationEntries.setCalibrationData(cameraCalibrationData);
              result = true;
            }
          }
        }
      }

      // mRightBitmap = brd.decodeRegion(rect, opt);
      rect = new Rect(brd.getWidth() - brd.getWidth() / 3, 0, brd.getWidth(), brd.getHeight());
      // mLeftBitmap = brd.decodeRegion(rect, opt);

      mRgbaMatHolder.unpin(rgbaMat);

    } catch (IOException e) {
      XLog.e("Region decoder doesn't want to cooperate", e);
    }

    return result;
  }
Exemple #17
0
  public static Bitmap getMiddlePictureInTimeLine(
      String url,
      int reqWidth,
      int reqHeight,
      FileDownloaderHttpHelper.DownloadListener downloadListener) {

    //        int useWidth = 400;
    int useWidth = reqWidth;

    String absoluteFilePath =
        FileManager.getFilePathFromUrl(url, FileLocationMethod.picture_bmiddle);

    File file = new File(absoluteFilePath);

    if (!file.exists() && !SettingUtility.isEnablePic()) {
      return null;
    }

    if (!file.exists()) {
      getBitmapFromNetWork(url, absoluteFilePath, downloadListener);
    }

    if (absoluteFilePath.endsWith(".gif")) {
      return getMiddlePictureInTimeLineGif(absoluteFilePath, reqWidth, reqHeight);
    }

    BitmapFactory.Options options = new BitmapFactory.Options();
    options.inJustDecodeBounds = true;
    BitmapFactory.decodeFile(absoluteFilePath, options);

    int height = options.outHeight;
    int width = options.outWidth;

    int cutHeight = 0;
    int cutWidth = 0;

    if (height >= reqHeight && width >= useWidth) {
      cutHeight = reqHeight;
      cutWidth = useWidth;

    } else if (height < reqHeight && width >= useWidth) {

      cutHeight = height;
      cutWidth = (useWidth * cutHeight) / reqHeight;

    } else if (height >= reqHeight && width < useWidth) {

      cutWidth = width;
      cutHeight = (reqHeight * cutWidth) / useWidth;

    } else if (height < reqHeight && width < useWidth) {

      float betweenWidth = ((float) useWidth - (float) width) / (float) width;
      float betweenHeight = ((float) reqHeight - (float) height) / (float) height;

      if (betweenWidth > betweenHeight) {
        cutWidth = width;
        cutHeight = (reqHeight * cutWidth) / useWidth;

      } else {
        cutHeight = height;
        cutWidth = (useWidth * cutHeight) / reqHeight;
      }
    }

    if (cutWidth > 0 && cutHeight > 0) {

      int startX = 0;

      if (cutWidth < width) {
        startX = (width - cutWidth) / 2;
      }

      try {
        BitmapRegionDecoder decoder = BitmapRegionDecoder.newInstance(absoluteFilePath, false);
        if (decoder != null) {
          Bitmap region =
              decoder.decodeRegion(new Rect(startX, 0, startX + cutWidth, cutHeight), null);
          Bitmap scale = null;
          if (region.getHeight() < reqHeight && region.getWidth() < reqWidth) {
            scale = Bitmap.createScaledBitmap(region, reqWidth, reqHeight, true);
          }
          if (scale == null) {
            Bitmap anotherValue = ImageEdit.getRoundedCornerBitmap(region);
            region.recycle();

            return anotherValue;
            //                        return region;
          } else {
            Bitmap anotherValue = ImageEdit.getRoundedCornerBitmap(scale);
            region.recycle();
            scale.recycle();
            return anotherValue;
            //                        return scale;
          }
        }
      } catch (IOException ignored) {
        // do nothing
      }
    }

    return null;
  }