Recomposed
Canvas

Bitmap-Grundlagen: Pixelpuffer, Byte-Layout und warum Dateigröße nichts über den Speicher aussagt

Oct 16, 2026 · 5 min read

Bitmap-Grundlagen: Pixelpuffer, Byte-Layout und warum Dateigröße nichts über den Speicher aussagt

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 MB

Gleiches 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:

FIG. 01
ARGB_8888: vier Bytes kodieren ein Pixel, in Speicherreihenfolge

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.

FIG. 02
Decodierung trennt den Zusammenhang zwischen Dateigröße und Speicherbedarf
  • 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 Bitmap in 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 einem CGBitmapContext, bei dem man bitsPerComponent und einen CGColorSpace wählt. Ein Graustufen-Colorspace ohne Alpha ergibt dasselbe 1 Byte/Pixel wie ALPHA_8.
  • Web/Canvas: ImageData ist immer RGBA mit 4 Bytes/Pixel, ohne kleinere native Option. Eine Graustufen-Ersparnis zu erreichen bedeutet, von Hand ein Uint8ClampedArray mit 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, RGB565 und R8 (ein einzelner Rot-/Leuchtdichtekanal) spiegeln Bitmap.Config fast eins zu eins. R8 ist das GPU-Textur-Äquivalent zu ALPHA_8 fü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.

Keep reading

Related reads

Neue Beiträge direkt in dein Postfach