Die Intuition
Die Größe einer Datei auf der Festplatte und die Größe eines decodierten Bitmaps im Speicher fühlen sich wie dieselbe Zahl an, nur anders skaliert. Sie haben überhaupt nichts miteinander zu tun.
- Ein decodiertes Bitmap ist ein flaches Raster aus Pixeln im RAM, ohne jede Erinnerung an die Komprimierung, aus der es entstanden ist.
- Sein Speicherbedarf ist reine Arithmetik:
Breite × Höhe × Bytes pro Pixel. Nichts an der ursprünglichen Datei fließt in diese Formel ein. - Deshalb kann ein winziges JPEG direkt von einer Handykamera nach dem Decodieren auf Dutzende Megabyte anwachsen, während eine riesige Datei zu fast nichts decodieren kann.
Gleiche Pixel, unterschiedliche Byte-Anzahl
Der Teil der Formel, den man tatsächlich kontrolliert, sind die Bytes pro
Pixel, über Bitmap.Config. Gleiches Bild, gleiche Abmessungen,
unterschiedliche Config:
val width = 4000
val height = 3000
// ARGB_8888: 4 Bytes/Pixel, im Speicher abgelegt als R, G, B, A (der Name
// beschreibt die Reihenfolge beim Packen in ein Int, nicht die rohe Byte-Reihenfolge)
val full = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888)
full.byteCount // 4000 * 3000 * 4 = 48.000.000 Bytes ≈ 46 MB
// RGB_565: 2 Bytes/Pixel, überhaupt kein Alphakanal
val half = Bitmap.createBitmap(width, height, Bitmap.Config.RGB_565)
half.byteCount // 4000 * 3000 * 2 = 24.000.000 Bytes ≈ 23 MBGleiches Pixelraster, gleiche Abmessungen, halber Speicherbedarf, denn was sich geändert hat, sind die Bytes pro Pixel, nicht die Pixelanzahl. Jedes Pixel ist eine Gruppe von Bytes fester Größe, zeilenweise in einem einzigen flachen Speicherblock abgelegt:
Dateigröße und decodierter Speicherbedarf sind voneinander unabhängige Zahlen
Die komprimierte Größe einer Datei und der decodierte Speicherbedarf desselben Bildes stammen aus zwei verschiedenen Stufen der Pipeline, und sie skalieren nicht gemeinsam.
- Dateigröße hängt vom Inhalt ab. Ein Foto mit Bildrauschen komprimiert schlecht, ein leerer Himmel komprimiert fast auf nichts, und keines von beiden hat eine feste Beziehung zu den Pixelabmessungen.
- Decodierter Speicherbedarf hängt nur von den Pixelabmessungen und
den Bytes pro Pixel ab. Sobald man ein
Bitmapin der Hand hält, ist die Komprimierung verschwunden. Es sind wieder nur Zahlen in einem Array.
Falls du schon einmal einen OutOfMemoryError bekommen hast, der
angesichts der geringen Größe der Asset-Datei keinen Sinn ergab, liegt
das daran: Ein 20-KB-JPEG direkt von einer Handykamera kann 4000 × 3000
Pixel groß sein, was bei ARGB_8888 zu 4000 × 3000 × 4 ≈ 46 MB
decodiert. Die Datei war 20 KB groß. Das, was du im RAM hältst, sind 46
MB. Die Dateigröße war nie die Zahl, auf die es ankam, die
Pixelabmessungen waren es.
The fundamental
Ein Bitmap ist ein : ein flacher, Speicherblock, in dem
jedes Pixel dieselbe feste Anzahl Bytes belegt. Der Gesamtspeicherbedarf
ist deterministisch, Breite × Höhe × Bytes pro Pixel, und vollständig
entkoppelt von der komprimierten Dateigröße, aus der er entstanden ist.
Bytes pro Pixel sind ein Kompromiss entlang zweier Achsen: wie viele Kanäle man behält (Alpha, RGB oder nur Leuchtdichte), und wie viele Bits pro Kanal (8, 5/6, oder 16-Bit-Float). Schrumpft man eine der beiden Achsen, wird der Pixelpuffer kleiner. Die Auflösung des Bildes hat sich dabei überhaupt nicht geändert.
Anderswo: gleiches Grundprinzip, anderes Framework
- iOS:
CGImage/UIImage, getragen von einemCGBitmapContext, bei dem manbitsPerComponentund einenCGColorSpacewählt. Ein Graustufen-Colorspace ohne Alpha ergibt dasselbe 1 Byte/Pixel wieALPHA_8. - Web/Canvas:
ImageDataist immer RGBA mit 4 Bytes/Pixel, ohne kleinere native Option. Eine Graustufen-Ersparnis zu erreichen bedeutet, von Hand einUint8ClampedArraymit 1 Byte/Pixel zu packen und es selbst zu zeichnen. - PNG, auf der Festplatte statt im Speicher: hat explizite Farbtypen für dieselbe Idee: Truecolor+Alpha (4 Bytes), Truecolor (3 Bytes), Graustufen (1 Byte), Indexed/Palette (1 Byte plus eine Nachschlagetabelle). Derselbe Kanal-Anzahl-Kompromiss, nur persistiert statt live im RAM.
- GPU-Texturen (OpenGL/Vulkan): Formate wie
RGBA8,RGB565undR8(ein einzelner Rot-/Leuchtdichtekanal) spiegelnBitmap.Configfast eins zu eins.R8ist das GPU-Textur-Äquivalent zuALPHA_8für Graustufen.
Wo das in der Praxis tatsächlich zu Problemen führt
In voller Auflösung zu decodieren, wenn nur ein Thumbnail nötig ist, verschwendet genau den Speicher, vor dem die Einleitung gewarnt hat
BitmapFactory.decodeFile()/decodeResource() decodiert standardmäßig in
den nativen Pixel-Abmessungen des Bildes, egal wie klein die ImageView
ist, die es anzeigen wird. Ein 4000 × 3000 großes Foto in einen
120dp-Avatar zu laden, allokiert trotzdem den vollen ~46MB großen
ARGB_8888-Puffer und verwirft den größten Teil davon in dem Moment, in
dem die View ihn herunterskaliert.
Lies zuerst die Abmessungen aus, ganz ohne Pixel-Allokation, und übergib
einen berechneten inSampleSize an die eigentliche Decodierung:
val bounds = BitmapFactory.Options().apply { inJustDecodeBounds = true }
BitmapFactory.decodeFile(path, bounds) // nur outWidth/outHeight, keine Pixel-Bytes werden allokiert
var sampleSize = 1
while (bounds.outWidth / (sampleSize * 2) >= reqWidth &&
bounds.outHeight / (sampleSize * 2) >= reqHeight) {
sampleSize *= 2
}
val decoded = BitmapFactory.decodeFile(path, BitmapFactory.Options().apply {
inSampleSize = sampleSize
})inSampleSize teilt beide Abmessungen vor dem Decodieren, sodass der
Speicherbedarf quadratisch mit dem Faktor sinkt: inSampleSize = 4 macht
aus einer 46MB-Decodierung etwa 2,9MB. Die Formel aus der Einleitung,
Breite × Höhe × Bytes pro Pixel, hat sich nicht geändert, sie läuft nur
gegen eine kleinere Breite und Höhe.
Ein recyceltes Bitmap stürzt beim nächsten Lesezugriff ab, nicht beim recycle()-Aufruf
Bibliotheken zum Laden von Bildern und eigene Caches können recycle()
auf einem Bitmap aufrufen, um dessen nativen Speicher sofort
freizugeben, statt auf den GC zu warten. Der Absturz passiert nicht dort,
er passiert später, immer wenn etwas, das die Referenz noch hält,
getPixels() aufruft oder es zeichnet: IllegalStateException: Can't call getPixels() on a recycled bitmap.
Prüfe bitmap.isRecycled(), bevor du ein Bitmap berührst, das eine
Cache-Entfernung oder eine Neuerstellung bei einer Konfigurationsänderung
überlebt hat, statt jeden Pixelzugriff nachträglich in ein try/catch zu
verpacken.
Rohe Pixel mit der falschen Zeilenbreite auslesen verzerrt das Bild diagonal
Plattformen können jede Zeile aus Gründen der Hardware-Effizienz auf eine
Ausrichtungsgrenze auffüllen, sodass der
manchmal größer ist als width * bytesPerPixel. Bitmap.getRowBytes()
liefert den tatsächlichen Wert. Berechnet man stattdessen selbst width * bytesPerPixel und verwendet das zum Durchlaufen eines rohen
Pixelpuffers, kommt das Bild zunehmend verzerrt heraus, weil jede Zeile
nach der ersten um eine Auffüllung verschoben ist, die man nie
berücksichtigt hat.
Ein halbtransparentes rotes Pixel wird nicht als (255, 0, 0, 128) gespeichert
Android-Bitmaps speichern RGB-Werte bereits mit Alpha multipliziert, genannt . Mischt man Pixel-Bytes manuell, ohne das zu berücksichtigen, kommen halbtransparente Kanten ausgewaschen oder abgedunkelt heraus, weil man bereits skalierte Farbwerte ein zweites Mal skaliert.
getPixels() wirft bei einem HARDWARE-Bitmap eine Exception
Seit Android 8 kann BitmapFactory direkt in den GPU-Speicher decodieren,
für schnelle Anzeige. Das ist großartig für den Speicherbedarf, da die
Pixel den Java- oder Native-Heap überhaupt nie berühren, bedeutet aber
auch, dass man getPixels() nicht aufrufen oder mit einem Software-
Canvas darauf zeichnen kann. Code, der davon ausgeht, dass jedes
Bitmap lesbar ist, bricht beim ersten Mal, wenn er auf eines dieser
Bitmaps trifft.
Jedes dieser Probleme, ob die Größe der Decodierung, die gewählte Config oder Pooling und Recycling, ist genau das, was eine Bildlade-Bibliothek wie Coil oder Glide automatisiert. Sie umgehen diese Arithmetik nicht, sie berechnen sie nur für dich hinter einem Request-Builder.
Der Speicherbedarf eines Bitmaps ist Breite × Höhe × Bytes pro Pixel,
Punkt. Nichts an der Datei, aus der es entstanden ist, oder dem Format,
mit dem es begann, ändert diese Arithmetik, sobald es decodiert ist.



