Bitmap-Out-Of-Memory-Probleme

Mein Problem

Ich ein Bild mit meinem android-Gerät. Ich habe dann decodieren, Bild aus Datei.

        Bitmap photo = BitmapFactory.decodeFile(EXTERNAL_IMAGE_PATH+File.separator+this._currentPhotoName+JPEG_FILE_SUFFIX);
        if (photo == null && data != null) 
            photo = (Bitmap) data.getExtras().get("data");
        else if (data == null && photo == null)
            Log.e("CCPhotoManager","Can't find image from file or from intent data.");

Ich dann überprüfen, dass Bild und sehen, ob es gedreht werden muss, um die richtige Orientierung.

             try {
                ExifInterface exif = new ExifInterface(EXTERNAL_IMAGE_PATH+File.separator+this._currentPhotoName+JPEG_FILE_SUFFIX);
                int rotation = CCDataUtils.exifToDegrees(exif.getAttributeInt(ExifInterface.TAG_ORIENTATION,ExifInterface.ORIENTATION_NORMAL));
                Log.v("CCPhotoManager", "Rotation:"+rotation);
                if (rotation > 0) {
                    photo = this.convertSavedImageToCorrectOrientation(EXTERNAL_IMAGE_PATH+File.separator+this._currentPhotoName+JPEG_FILE_SUFFIX, photo, rotation);
                }
            } catch (IOException e1) {
                //TODO Auto-generated catch block
                e1.printStackTrace();
            }

Wenn Sie es brauchen, das rotierende nenne ich diese Methode.

public Bitmap convertSavedImageToCorrectOrientation(String filePath,Bitmap photo,int rotation) {
        Log.d("CCPhotoManager", "Changing Orientation of photo located at: "+filePath+" Rotating by:"+rotation);
        int width = photo.getWidth();
        int height = photo.getHeight();


        Matrix matrix = new Matrix();
        matrix.preRotate(rotation);

        Bitmap adjusted = Bitmap.createBitmap(photo, 0, 0, width, height, matrix, true);

        try {
               FileOutputStream out = new FileOutputStream(filePath);
               adjusted.compress(Bitmap.CompressFormat.JPEG, 100, out);
        } catch (Exception e) {
               e.printStackTrace();
        }

        return adjusted;
    }

Ich bin immer Out of Memory Beschwerden, wenn die convertSavedImageToCorrectOrientation heißt auf der Linie Bitmap adjusted = Bitmap.createBitmap(photo,0,0,width,height,matrix,true);

Dies ist nur der Fall auf der Samsung Galaxy S3. Es funktioniert gut auf den Samsung Galaxy Ace, HTC Hero und die Sony Xperia U.

Hier ist der Fehler.

10-17 14:33:33.950: E/AndroidRuntime(12556): java.lang.OutOfMemoryError
10-17 14:33:33.950: E/AndroidRuntime(12556):    at android.graphics.Bitmap.nativeCreate(Native Method)
10-17 14:33:33.950: E/AndroidRuntime(12556):    at android.graphics.Bitmap.createBitmap(Bitmap.java:605)
10-17 14:33:33.950: E/AndroidRuntime(12556):    at android.graphics.Bitmap.createBitmap(Bitmap.java:551)

Es ist eine riesige Menge an Speicher zu.

10-17 14:33:33.945: E/dalvikvm-heap(12556): Out of memory on a 31961104-byte allocation.

Ich denke, Ihr etwas zu tun mit der Menge an Bitmaps Rum, aber ich bin mir nicht sicher, wie Sie Sie zu stoppen, dieser Fehler passiert.

Ich weiß, Sie können rufen Sie .recycle(); auf Sie, aber es scheint nicht zu funktionieren.

Meine Frage

Wie kann ich richtig mit meinem Bitmaps, damit ich nicht über das OOM-problem?

Vielen Dank im Voraus

Dies ist eine ziemlich Häufig gestellte Frage mit vielen Duplikate. Die meisten von Ihnen sind spezifisch für jede situation die Entwickler sich in die enge getrieben, aber die Chancen sind, konnte man irgendwo Lesen, was Techniken wurden vorgeschlagen, um Sie in Ordnung zu halten bitmap-Größe nach unten.
Sie benötigen zum Lesen, ändern und speichern das gesamte Bild? Keine sample-size? Vielleicht passiert auf dem S3 weil es hat eine bessere Kamera, und deshalb laden Sie ein größeres Bild auf den Speicher.
Muss ich drehen das gesamte Bild in die korrekte Ausrichtung, und speichern Sie es wieder, weil die Kamera speichert immer es in Ihre Standard-Orientierung, ist nicht immer richtig. Ich bin mir ziemlich sicher, die Größe des Bildes aufgrund der besseren Kamera ist der Grund, wie Sie sagte
ok, die Kamera speichert das so vereinbart, aber dann, wenn Sie verwenden müssen, dass das Bild auf einer app haben Sie immer die EXIF-Daten richtig angezeigt auf Ihrem app... kleiner natürlich.
Das ist ein guter Vorschlag und eine gute alternative. Das Problem habe ich mit dieser Methode ist es, wenn ich die eigentliche Datei in der richtigen Ausrichtung, dh. Anhängen an eine E-Mail?

InformationsquelleAutor StuStirling | 2012-10-17

android android-camera

Für die out-of-memory-Problem

//decodiert Bild und skaliert es auf der Speicherverbrauch

private Bitmap decodeFile(File f){

try {
    //Decode image size
    BitmapFactory.Options o = new BitmapFactory.Options();
    o.inJustDecodeBounds = true;
    BitmapFactory.decodeStream(new FileInputStream(f),null,o);

    //The new size we want to scale to
    final int REQUIRED_SIZE=70;

    //Find the correct scale value. It should be the power of 2.
    int scale=1;
    while(o.outWidth/scale/2>=REQUIRED_SIZE && o.outHeight/scale/2>=REQUIRED_SIZE)
        scale*=2;

    //Decode with inSampleSize
    BitmapFactory.Options o2 = new BitmapFactory.Options();
    o2.inSampleSize=scale;
    return BitmapFactory.decodeStream(new FileInputStream(f), null, o2);
} catch (FileNotFoundException e) {}
return null;
}

Wenn ich das Bild skalieren und dann speichern Sie es wieder sein wird, die kleiner als das original?
es könnte es etwas Unschärfe , so dass u können überprüfen Sie Ihre Größe viel höher sind, dann gelten diese und den Benutzer Benachrichtigen
Was ist die Größe variable hier? Ist, dass 70% der originalen Größe?
So seiner der Anteil des orginals Größe? Ich bin versucht zu implementieren, dies im moment
REQUIRED_SIZE ist die neue Größe, die Sie skalieren möchten.

InformationsquelleAutor Amit Hooda

Hier ist ein vollständigeres Beispiel, wie man die Größe/drehen, Teils aus dem Android Developers guide (ändern REQ_WIDTH und REQ_HEIGHT):

private static final int REQ_WIDTH = 450;
private static final int REQ_HEIGHT = 450;

/**
 * Resize, crop, rotate and Inserts the picture on the layout.
 * 
 * @param mImageView to insert the bitmap.
 * @param imageURI from wich to obtain the bitmap.
 * 
 */
private void setPic(ImageView mImageView, String imageURI) {
    //Get the original bitmap dimensions
    BitmapFactory.Options options = new BitmapFactory.Options();
    options.inJustDecodeBounds = true;
    BitmapFactory.decodeFile(imageURI, options);

    //Calculate inSampleSize
    options.inSampleSize = calculateInSampleSize(options, REQ_HEIGHT, REQ_WIDTH);

    //Decode bitmap with inSampleSize set
    options.inJustDecodeBounds = false;
    Bitmap bitmap = BitmapFactory.decodeFile(imageURI, options);

    //need rotation?
    float rotation = rotationForImage(getActivity(), Uri.fromFile(new File(imageURI)));

    if (rotation != 0) {
        //rotate
        Matrix matrix = new Matrix();
        matrix.preRotate(rotation);
        mImageView.setImageBitmap(Bitmap.createBitmap(bitmap, 0, 0, REQ_HEIGHT, REQ_WIDTH, matrix, true));
    } else {
        //use the original
        mImageView.setImageBitmap(BitmapFactory.decodeFile(imageURI, options));
    }
}

public static int calculateInSampleSize(BitmapFactory.Options options, int reqWidth, int reqHeight) {
    //Raw height and width of image
    final int height = options.outHeight;
    final int width = options.outWidth;
    int inSampleSize = 1;

    if (height > reqHeight || width > reqWidth) {
        if (width > height) {
            inSampleSize = Math.round((float) height / (float) reqHeight);
        } else {
            inSampleSize = Math.round((float) width / (float) reqWidth);
        }
    }
    return inSampleSize;
}

public static float rotationForImage(Context context, Uri uri) {
    try {
        if (uri.getScheme().equals("content")) {
            String[] projection = { Images.ImageColumns.ORIENTATION };
            Cursor c = context.getContentResolver().query(uri, projection, null, null, null);
            if (c.moveToFirst()) {
                return c.getInt(0);
            }
        } else if (uri.getScheme().equals("file")) {
            ExifInterface exif = new ExifInterface(uri.getPath());
            int rotation = (int) exifOrientationToDegrees(exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL));
            return rotation;
        }
        return 0;

    } catch (IOException e) {
        Log.e(TAG, "Error checking exif", e);
        return 0;
    }
}

private static float exifOrientationToDegrees(int exifOrientation) {
    if (exifOrientation == ExifInterface.ORIENTATION_ROTATE_90) {
        return 90;
    } else if (exifOrientation == ExifInterface.ORIENTATION_ROTATE_180) {
        return 180;
    } else if (exifOrientation == ExifInterface.ORIENTATION_ROTATE_270) {
        return 270;
    }
    return 0;
}

Beste verfügbare Antwort mehr, SO für den Fall.

InformationsquelleAutor nsemeniuk

3

Ich hatte das exakt gleiche Problem, genau das gleiche auf dem exakt gleichen Gerät! Leider in meinem Fall ist das Bild benötigt, um eingereicht werden, um einen webservice, mit der vollen grösse, original. Was für mich gearbeitet war, sich auf largeHeap im application-element des manifests.

Wird dies nicht lösen das Problem permanent - ist es möglich, dass ein Gerät kommen wird, zusammen mit einer noch größeren Kamera und die Bilder werden nicht in den Speicher passt sogar mit largeHeap aktiviert. Fangen diese extreme edge case lege ich auch ein try catch um den code, dreht sich das Bild, und nur angezeigt, eine nette Fehlermeldung an den Benutzer ausgegeben.

Eine umfassendere Lösung wäre zu schreiben Sie Ihre eigenen jpeg-manipulation-code, drehen Sie ein jpeg mit einem stream-basierten Ansatz, so dass das Bild nie in den Arbeitsspeicher geladen werden.

InformationsquelleAutor Luke Sleeman

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.