BitmapFactory.decodeStream out-of-memory-trotz des reduzierten stichprobenumfangs

Ich habe gelesen, dass viele related posts bezüglich Speicherzuordnung Probleme mit der Decodierung von bitmaps, aber bin immer noch nicht finden die Lösung für das folgende problem auch nach der Verwendung der zur Verfügung gestellte code in der offiziellen website.

Hier ist mein code:

public static Bitmap decodeSampledBitmapFromResource(InputStream inputStream, int reqWidth, int reqHeight) {

    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    byte[] buffer = new byte[1024];
    int len;
    try {
        while ((len = inputStream.read(buffer)) > -1) {
        baos.write(buffer, 0, len);
        }
        baos.flush();
        InputStream is1 = new ByteArrayInputStream(baos.toByteArray());
        InputStream is2 = new ByteArrayInputStream(baos.toByteArray());

        final BitmapFactory.Options options = new BitmapFactory.Options();
        options.inJustDecodeBounds = true;
        BitmapFactory.decodeStream(is1, null, options);

        options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight);
        options.inPurgeable = true;
        options.inInputShareable = true;
        options.inJustDecodeBounds = false;
        options.inPreferredConfig = Bitmap.Config.ARGB_8888;
        return BitmapFactory.decodeStream(is2, null, options);

    } catch (Exception e) {
        e.printStackTrace();

        return null;
    }
}

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) {

        //Calculate ratios of height and width to requested height and width
        final int heightRatio = Math.round((float) height / (float) reqHeight);
        final int widthRatio = Math.round((float) width / (float) reqWidth);

        //Choose the smallest ratio as inSampleSize value, this will guarantee
        //a final image with both dimensions larger than or equal to the
        //requested height and width.
        inSampleSize = heightRatio < widthRatio ? heightRatio : widthRatio;
    }


    return inSampleSize;
}

bitmap = decodeSampledBitmapFromResource(inputStream, 600, 600);

Bin ich immer "Out of memory" - Fehlermeldung auf einem 3250016 - byte-Zuordnung" in dieser Zeile:

return BitmapFactory.decodeStream(is2, null, options);

Es scheint mir, dass 3,2 MB ist klein genug, um zugeordnet werden. Wohin gehe ich falsch? Wie kann ich dieses Problem lösen?

BEARBEITEN

Nach einem Blick in diese Lösung HIER von N-Joy, es funktioniert gut mit der Benötigten Größe 300, aber meine gewünschte Größe ist 800, so bin ich noch immer der Fehler.

InformationsquelleAutor der Frage Goofy | 2013-03-06

Die Methode decodeSampledBitmapFromResource ist Erinnerung nicht effizient, denn es werden 3 streams: die ByteArrayOutputStream baos, ByteArrayInputStream is1 und ByteArrayInputStream is2, jedem der Läden die gleiche stream-Daten des Bildes (ein byte array für jedes).

Und wenn ich den test mit meinem Gerät (LG nexus 4) zum Dekodieren von 2560x1600 image auf SDcard Zielgröße 800 dauert es, so etwas wie dieses:

03-13 15:47:52.557: E/DecodeBitmap(11177): dalvikPss (beginning) = 1780
03-13 15:47:53.157: E/DecodeBitmap(11177): dalvikPss (decoding) = 26393
03-13 15:47:53.548: E/DecodeBitmap(11177): dalvikPss (after all) = 30401 time = 999

Können wir sehen: zu viel Speicher alloziert (28.5 MB) einfach zu entschlüsseln 4096000 ein pixel-Bild.

Lösung: wir Lesen den InputStream und speichern Sie die Daten direkt in ein byte-array und verwenden Sie diese byte-array für den rest der Arbeit.

Beispiel-code:

public Bitmap decodeSampledBitmapFromResourceMemOpt(
            InputStream inputStream, int reqWidth, int reqHeight) {

        byte[] byteArr = new byte[0];
        byte[] buffer = new byte[1024];
        int len;
        int count = 0;

        try {
            while ((len = inputStream.read(buffer)) > -1) {
                if (len != 0) {
                    if (count + len > byteArr.length) {
                        byte[] newbuf = new byte[(count + len) * 2];
                        System.arraycopy(byteArr, 0, newbuf, 0, count);
                        byteArr = newbuf;
                    }

                    System.arraycopy(buffer, 0, byteArr, count, len);
                    count += len;
                }
            }

            final BitmapFactory.Options options = new BitmapFactory.Options();
            options.inJustDecodeBounds = true;
            BitmapFactory.decodeByteArray(byteArr, 0, count, options);

            options.inSampleSize = calculateInSampleSize(options, reqWidth,
                    reqHeight);
            options.inPurgeable = true;
            options.inInputShareable = true;
            options.inJustDecodeBounds = false;
            options.inPreferredConfig = Bitmap.Config.ARGB_8888;

            int[] pids = { android.os.Process.myPid() };
            MemoryInfo myMemInfo = mAM.getProcessMemoryInfo(pids)[0];
            Log.e(TAG, "dalvikPss (decoding) = " + myMemInfo.dalvikPss);

            return BitmapFactory.decodeByteArray(byteArr, 0, count, options);

        } catch (Exception e) {
            e.printStackTrace();

            return null;
        }
    }

Die Methode, die die Berechnung:

public void onButtonClicked(View v) {
        int[] pids = { android.os.Process.myPid() };
        MemoryInfo myMemInfo = mAM.getProcessMemoryInfo(pids)[0];
        Log.e(TAG, "dalvikPss (beginning) = " + myMemInfo.dalvikPss);

        long startTime = System.currentTimeMillis();

        FileInputStream inputStream;
        String filePath = Environment.getExternalStorageDirectory()
                .getAbsolutePath() + "/test2.png";
        File file = new File(filePath);
        try {
            inputStream = new FileInputStream(file);
//         mBitmap = decodeSampledBitmapFromResource(inputStream, 800, 800);
            mBitmap = decodeSampledBitmapFromResourceMemOpt(inputStream, 800,
                    800);
            ImageView imageView = (ImageView) findViewById(R.id.image);
            imageView.setImageBitmap(mBitmap);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        myMemInfo = mAM.getProcessMemoryInfo(pids)[0];
        Log.e(TAG, "dalvikPss (after all) = " + myMemInfo.dalvikPss
                + " time = " + (System.currentTimeMillis() - startTime));
    }

Und das Ergebnis:

03-13 16:02:20.373: E/DecodeBitmap(13663): dalvikPss (beginning) = 1823
03-13 16:02:20.923: E/DecodeBitmap(13663): dalvikPss (decoding) = 18414
03-13 16:02:21.294: E/DecodeBitmap(13663): dalvikPss (after all) = 18414 time = 917

InformationsquelleAutor der Antwort Binh Tran

4

Dies ist ein häufiges Problem, das Benutzer normalerweise Gesichter beim spielen mit großen bitmaps, und es gibt viele Fragen diskutierte auf der Website, hier hier hier und hier und viele mehr, auch wenn der Benutzer nicht in der Lage zu manipulieren die exakte Lösung.

Stolperte ich über eine Bibliothek irgendwann zurück, das die Verwaltung der bitmaps reibungslos und andere links, die ich unten aufgelistet. Hoffe, das hilft!

smoothie-Bibliothek

Android-BitmapCache

Android-Universal-Image-Loader
Lösung für OutOfMemoryError: bitmap size exceeds VM budget

InformationsquelleAutor der Antwort RobinHood
2

ARGB_8888 verwendet mehr Speicher als es dauert, Alpha-color-Wert, so mein Vorschlag ist, verwenden Sie RGB_565 wie gesagt HIER

Hinweis: die Qualität wird etwas geringer im Vergleich zu ARGB_8888.

InformationsquelleAutor der Antwort nidhi_adiga
1

Sind Sie wahrscheinlich das festhalten an bisherigen bitmap-Referenzen. Ich vermute, dass Sie die Ausführung dieser code mehrere Male und nie ausführen bitmap.recycle(). Speicher wird zwangsläufig ausgehen.

InformationsquelleAutor der Antwort Paul Lammertsma
1

Hatte ich viele Probleme mit Bitmap-Speicher-Nutzung.

Ergebnisse:
- Die meisten Geräte haben eine begrenzte heap-Speicher für Grafiken, die meisten kleinen Geräte sind begrenzt auf 16 MB für apps insgesamt, nicht nur Ihre app
- Verwenden 4 bit oder 8-bit oder 16-bit-bitmaps, wenn anwendbar
- Versuchen, Formen zu zeichnen von Grund auf, lassen Sie bitmaps, wenn möglich.
InformationsquelleAutor der Antwort AVEbrahimi
1

Verwenden WebView dynamisch geladen, so viele Bilder wie Sie möchten, es ist gebaut mit NDK (niedrige Stufe), so hat keine GDI-heap-Speicher Einschränkungen.
Es funktioniert glatt und schnell 🙂

InformationsquelleAutor der Antwort AVEbrahimi
1

Out-of-memory-Probleme beim Dekodieren von bitmaps werden nicht oft verknüpft mit dem Bild, die Größe, die Sie decodieren.
Natürlich, wenn Sie versuchen, öffnen Sie ein Bild 5000x5000px Sie werden nicht mit einem OutOfMemoryError, aber mit der Größe von 800x800px es ist vollkommen vernünftig und sollte funktionieren.

Wenn Ihr Gerät aus dem Speicher mit 3.2 MB Bild es ist wahrscheinlich, weil Sie undicht Kontext irgendwo in der app.

Es ist der erste Teil der dieser Beitrag:

Ich denke, problem ist nicht in Ihrem layout, das problem ist woanders
Ihr code. und wahrscheinlich sind Sie undicht Kontext irgendwo.

Was es bedeutet, dass Sie mit Aktivität, Kontext-Komponenten, sollten nicht verhindern, dass Sie von der garbage Collection freigegeben. Da Komponenten oft von Aktivitäten, diese Aktivitäten sind nicht die GC und Ihre java-heap wird sehr schnell wachsen und Ihre app Absturz zur einen oder anderen Zeit.

Als Raghunandan, sagte, müssen Sie eine MATTE zu finden, welche Aktivität/Komponente gehalten wird, und entfernen Sie die Rahmen undicht.

Der beste Weg, fand ich jetzt zu erkennen, Kontext-Leck ist die Orientierung ändern.
Zum Beispiel, drehen Sie Ihre ActivityMain mehrmals, führen MATTE und prüfen Sie, ob Sie nur eine Instanz von ActivityMain. Wenn Sie mehrere Einsen (so viel wie Drehung verpasst) es bedeutet, dass es einen Zusammenhang Leck.

Fand ich vor Jahren eine gutes tutorial über die Verwendung von MAT. Vielleicht ist es besser jetzt.

Andere Beiträge von memory leaks:

Android - Speicherverlust oder?

Out-of-memory-Fehler auf android-emulator, aber nicht auf dem Gerät

InformationsquelleAutor der Antwort ol_v_er
0

Haben Sie einen Blick auf dieses video. http://www.youtube.com/watch?v=_CruQY55HOk. Verwenden Sie nicht system.gc() wie vorgeschlagen im video. Verwenden Sie eine MATTE Analyzer heraus zu finden, memory leaks. Der zurückgegebene bitmap ist zu groß, verursacht Speicherverlust, denke ich.

InformationsquelleAutor der Antwort Raghunandan
0

Es scheint, Sie haben große Bild angezeigt wird.

Können Sie Bild herunterladen und speichern, um sdcard ( Beispiel ), dann können Sie Benutzer diese
code um Bild von sdcard.

InformationsquelleAutor der Antwort MAC

-1

ich hatte auch gleiche problem früher.. und ich habe es geschafft es durch die Verwendung dieser Funktion, wo man die Skala als Ihre erforderliche Breite und Höhe.

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

        //Find the correct scale value. It should be the power of 2.
        final int REQUIRED_SIZE=70;
        int width_tmp=o.outWidth, height_tmp=o.outHeight;
        int scale=1;
        while(true)
        {
            if(width_tmp/2<REQUIRED_SIZE || height_tmp/2<REQUIRED_SIZE)
                break;
            width_tmp/=2;
            height_tmp/=2;
            scale*=2;
        }

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

beziehen und die Memory-Leak-Fehler Android und Fehler beim laden der Bilder zu gridview android

InformationsquelleAutor der Antwort Sanket Kachhela

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.